include/libtfo/fibentry.hh

Go to the documentation of this file.

#ifndef __FIBENTRY_HH__
#define __FIBENTRY_HH__

#include <stdint.h>

enum FibEntryState
{
    FIB_ENTRY_STATE_INACTIVE, 
    FIB_ENTRY_STATE_ACTIVE, 
    FIB_ENTRY_STATE_MOD_ADD, 
    FIB_ENTRY_STATE_MOD_MOVE, 
    FIB_ENTRY_STATE_MOD_ACTION, 
    FIB_ENTRY_STATE_MOD_REMOVE, 
};

enum FibEntryTable
{
    FIB_ENTRY_TABLE_FAST,
    FIB_ENTRY_TABLE_SLOW
};

enum FibEntryHitsUpdateType
{
    FIB_ENTRY_HITS_ADD,
    FIB_ENTRY_HITS_UPDATE_BIN,
    FIB_ENTRY_HITS_UPDATE_TOTAL,
    FIB_ENTRY_HITS_REPLACE
};

template <typename M, typename A, typename U>
class FibEntry
{
    public:
        typedef M match_type;
        typedef A action_type;
        typedef U user_type;

        inline FibEntry (uint32_t size_b2, uint32_t size_b3, const M& m, const A& a)
            : _match(m), _action(a), _old_action(a),
            _state(FIB_ENTRY_STATE_INACTIVE), _table(FIB_ENTRY_TABLE_SLOW), _ttl(0),
            _size_b2(size_b2), _size_b3(size_b3),
            _hits_current(0), _hits_total(0), _hits_b1(0), _hits_b2(0), _hits_b3(0),
            _hits_ring_size(0), _hits_ring_pos(0)
        {
            _hits_ring = new uint64_t[size_b3];
        }

        inline ~FibEntry (void)
        {
            delete [] _hits_ring;
        }

        inline const M& match (void) const
        { return _match; }

        inline const A& action (void) const
        { return _action; }

        inline const A& action (const A& a)
        { return (_action = a); }

        inline const A& old_action (void) const
        { return _old_action; }

        inline const A& old_action (const A& a)
        { return (_old_action = a); }

        inline U& user_data (void)
        { return _user_data; }

        inline const enum FibEntryState& state (void) const
        { return _state; }

        inline const enum FibEntryState& state (enum FibEntryState s)
        { return (_state = s); }

        inline const enum FibEntryTable& table (void) const
        { return _table; }

        inline const enum FibEntryTable& table (enum FibEntryTable t)
        { return (_table = t); }

        inline const uint32_t ttl (void) const
        { return _ttl; }

        inline const uint32_t ttl (uint32_t t)
        { return (_ttl = t); }

        inline const uint32_t ttl_decrement (void)
        { return (_ttl ? --_ttl : 0); }

        inline const uint64_t& hits_total (void) const
        { return _hits_total; }

        inline const uint64_t& hits_b1 (void) const
        { return _hits_b1; }

        inline const uint64_t& hits_b2 (void) const
        { return _hits_b2; }

        inline const uint64_t& hits_b3 (void) const
        { return _hits_b3; }

        inline void update_hits (const uint64_t& hits, const enum FibEntryHitsUpdateType type)
        {
            switch (type)
            {
            case FIB_ENTRY_HITS_ADD:
                _hits_current += hits;
                break;
            case FIB_ENTRY_HITS_UPDATE_BIN:
                _hits_current = hits;
                break;
            case FIB_ENTRY_HITS_UPDATE_TOTAL:
                if (hits >= _hits_total)
                {
                    _hits_current = hits - _hits_total;
                    break;
                }
                /* if (hits < _hits_total), we assume a counter wrap-around or reset
                   has happened, i.e., we proceed similar to FIB_ENTRY_HITS_REPLACE. */
            case FIB_ENTRY_HITS_REPLACE:
                _hits_current = hits;
                _hits_total = 0;
                break;
            }
        }

        inline void bin_complete (void)
        {
#define FIB_ENTRY_RING_POS(curr, dist, size) \
            (((curr) >= (dist)) ? \
             ((curr) - (dist)) : \
             ((size) - ((dist) - (curr))))

            _hits_total += _hits_current;

            _hits_b1 = _hits_current;

            _hits_b2 += _hits_current;
            if (_hits_ring_size >= _size_b2)
                _hits_b2 -= _hits_ring[FIB_ENTRY_RING_POS(_hits_ring_pos, _size_b2 - 1, _hits_ring_size)];

            _hits_b3 += _hits_current;
            if (_hits_ring_size >= _size_b3)
                _hits_b3 -= _hits_ring[FIB_ENTRY_RING_POS(_hits_ring_pos, _size_b3 - 1, _hits_ring_size)];

            _hits_ring_pos = (_hits_ring_pos + 1) % _size_b3;
            _hits_ring[_hits_ring_pos] = _hits_current;
            if (_hits_ring_size < _size_b3)
                _hits_ring_size++;

            _hits_current = 0;
        }

    private:
        /* forwarding information */
        const M _match;
        A _action;
        A _old_action;
        U _user_data;

        /* installation status */
        enum FibEntryState _state;
        enum FibEntryTable _table;
        int _ttl;

        /* bin sizes */
        uint32_t _size_b2;
        uint32_t _size_b3;

        /* traffic statistics */
        uint64_t  _hits_current;
        uint64_t  _hits_total;
        uint64_t  _hits_b1;
        uint64_t  _hits_b2;
        uint64_t  _hits_b3;
        uint64_t* _hits_ring;
        uint32_t  _hits_ring_size;
        uint32_t  _hits_ring_pos;
};

#endif