RouteTable.h

Go to the documentation of this file.

#ifndef ROUTETABLE_H
#define ROUTETABLE_H

#include <set>
#include "Forest.h"
#include "Util.h"
#include "Hash.h"
#include "HashMap.h"
#include "ComtreeTable.h"

namespace forest {

class RouteTable {
public:
                                RouteTable(int, fAdr_t, ComtreeTable*);
                                ~RouteTable();

                // predicates
                bool            validRtx(int) const;
                bool            isLink(int,int) const;
                bool            noLinks(int) const;

                // iteration methods
                int             firstRtx() const;
                int             nextRtx(int) const;
                int             firstComtLink(int) const;
                int             nextComtLink(int, int) const;

                // access methods
                int             getRtx(comt_t, fAdr_t) const;
                comt_t          getComtree(int) const;
                fAdr_t          getAddress(int) const;          
                int             getLinkCount(int) const;                        

                // modifiers
                bool            addLink(int,int);
                void            removeLink(int,int);            
                int             addRoute(comt_t,fAdr_t,int);
                void            removeRoute(int);
                void            purge(comt_t, int);
                void            setLink(int,int);

                // input/output
                bool            read(istream&);
                string          toString() const;
                string          entry2string(int) const; 
private:
                int             maxRtx;                                         
                int             myAdr;                                          
                ComtreeTable *ctt;                              

                typedef HashSet<int32_t,Hash::s32> Vset;

                HashMap<uint64_t,Vset,Hash::u64> *rteMap;

                // map (comtree,link) to list of rtx values (routes that use link)
                HashMap<uint64_t,Vset,Hash::u64> *clMap;

                // helper functions
                uint64_t rmKey(comt_t, fAdr_t) const;  
                uint64_t cmKey(comt_t, int32_t) const;  
                bool            readRoute(istream&);            
};

inline bool RouteTable::validRtx(int rtx) const {
                return rteMap->valid(rtx);
}

inline bool RouteTable::isLink(int rtx, int cLnk) const {
                Vset& lset = rteMap->getValue(rtx);
                return lset.contains(cLnk);
}

inline bool RouteTable::noLinks(int rtx) const {
                Vset& lset = rteMap->getValue(rtx);
                return lset.empty();
}

inline int RouteTable::firstRtx() const {
                return rteMap->first();
}

inline int RouteTable::nextRtx(int rtx) const {
                return rteMap->next(rtx);
}

inline int RouteTable::firstComtLink(int rtx) const {
                return rteMap->getValue(rtx).first();
}

inline int RouteTable::nextComtLink(int rtx, int cLnk) const {
                return rteMap->getValue(rtx).next(cLnk);
}

inline int RouteTable::getRtx(comt_t comt, fAdr_t adr) const {
        return rteMap->find(rmKey(comt,adr));
}   

inline comt_t RouteTable::getComtree(int rtx) const {
                uint64_t kee = rteMap->getKey(rtx);
                return (comt_t) (kee >> 32);
}

inline fAdr_t RouteTable::getAddress(int rtx) const {
                uint64_t kee = rteMap->getKey(rtx);
                return (fAdr_t) (kee & 0xffffffff);
}

inline int RouteTable::getLinkCount(int rtx) const {
                return rteMap->getValue(rtx).size();
}

inline bool RouteTable::addLink(int rtx, int cLnk) {
                if (!validRtx(rtx) || !Forest::mcastAdr(getAddress(rtx)))
                                return false;
                Vset& lset = rteMap->getValue(rtx);
                lset.insert(cLnk);
                uint64_t kee = cmKey(getComtree(rtx),cLnk);
                int x = clMap->find(kee);
                if (x == 0) {
                                Vset new_routes;
                                x = clMap->put(kee,new_routes);
                }
                clMap->getValue(x).insert(rtx);
                return true;
}

inline void RouteTable::removeLink(int rtx, int cLnk) {
                if (!validRtx(rtx) || !Forest::mcastAdr(getAddress(rtx)))
                                return;
                Vset& lset = rteMap->getValue(rtx);
                lset.remove(cLnk);
                uint64_t kee = cmKey(getComtree(rtx),cLnk);
                Vset& routes = clMap->get(kee);
                routes.remove(rtx);
                if (lset.size() == 0) // no subscribers left
                                rteMap->remove(rteMap->getKey(rtx));
                if (routes.size() == 0) // no routes mapped to cLnk
                                clMap->remove(kee);
}

inline void RouteTable::setLink(int rtx, int cLnk) {
                if (!validRtx(rtx) || Forest::mcastAdr(getAddress(rtx)))
                                return;
                // assume link set is empty or has a single member
                Vset& lset = rteMap->getValue(rtx);
                if (lset.size() != 0) {
                                int old_cLnk = lset.first();
                                uint64_t kee = cmKey(getComtree(rtx),old_cLnk);
                                Vset& routes = clMap->get(kee);
                                routes.remove(rtx);
                                if (routes.size() == 0) clMap->remove(kee);
                                lset.remove(old_cLnk);
                }
                uint64_t kee = cmKey(getComtree(rtx),cLnk);
                int x = clMap->find(kee);
                if (x == 0) {
                                Vset new_routes;
                                x = clMap->put(kee,new_routes);
                }
                clMap->getValue(x).insert(rtx);
                lset.insert(cLnk);
}

inline uint64_t RouteTable::rmKey(comt_t comt, int32_t adr) const {
                // zero out local address parts for uncast addresses to non-local zip
                bool local = ((adr & 0xffff0000) ^ (myAdr & 0xffff0000)) == 0;
                if (!Forest::mcastAdr(adr) && !local)  adr &= 0xffff0000;
                return (uint64_t(comt) << 32) | (uint64_t(adr) & 0xffffffff);
}

inline uint64_t RouteTable::cmKey(comt_t comt, int32_t cLnk) const {
                return (uint64_t(comt) << 32) | (uint64_t(cLnk) & 0xffffffff);
}

} // ends namespace


#endif