src/nlsr_rtc.cpp

#include <iostream>
#include <cmath>
#include "nlsr_lsdb.hpp"
#include "nlsr_rtc.hpp"
#include "nlsr_map.hpp"
#include "nlsr_lsa.hpp"
#include "nlsr_nexthop.hpp"
#include "nlsr.hpp"

namespace nlsr
{

    using namespace std;

    void
    RoutingTableCalculator::allocateAdjMatrix()
    {
        adjMatrix = new double*[numOfRouter];
        for(int i = 0; i < numOfRouter; ++i)
        {
            adjMatrix[i] = new double[numOfRouter];
        }
    }

    void
    RoutingTableCalculator::initMatrix()
    {
        for(int i=0; i<numOfRouter; i++)
        {
            for(int j=0; j<numOfRouter; j++)
                adjMatrix[i][j]=0;
        }
    }

    void
    RoutingTableCalculator::makeAdjMatrix(Nlsr& pnlsr, Map pMap)
    {
        std::list<AdjLsa> adjLsdb=pnlsr.getLsdb().getAdjLsdb();
        for( std::list<AdjLsa>::iterator it=adjLsdb.begin();
                it!= adjLsdb.end() ; it++)
        {
            string linkStartRouter=(*it).getOrigRouter();
            int row=pMap.getMappingNoByRouterName(linkStartRouter);
            std::list<Adjacent> adl=(*it).getAdl().getAdjList();
            for( std::list<Adjacent>::iterator itAdl=adl.begin();
                    itAdl!= adl.end() ; itAdl++)
            {
                string linkEndRouter=(*itAdl).getAdjacentName();
                int col=pMap.getMappingNoByRouterName(linkEndRouter);
                double cost=(*itAdl).getLinkCost();
                if ( (row >= 0 && row<numOfRouter) && (col >= 0 && col<numOfRouter) )
                {
                    adjMatrix[row][col]=cost;
                }
            }

        }
    }

    void
    RoutingTableCalculator::printAdjMatrix()
    {
        for(int i=0; i<numOfRouter; i++)
        {
            for(int j=0; j<numOfRouter; j++)
                printf("%f ",adjMatrix[i][j]);
            printf("\n");
        }
    }

    void
    RoutingTableCalculator::adjustAdMatrix(int source, int link, double linkCost)
    {
        for ( int i = 0; i < numOfRouter; i++ )
        {
            if ( i == link )
            {
                adjMatrix[source][i]=linkCost;
            }
            else
            {
                adjMatrix[source][i]=0;
            }
        }
    }

    int
    RoutingTableCalculator::getNumOfLinkfromAdjMatrix(int sRouter)
    {
        int noLink=0;
        for(int i=0; i<numOfRouter; i++)
        {
            if ( adjMatrix[sRouter][i] > 0 )
            {
                noLink++;
            }
        }
        return noLink;
    }

    void
    RoutingTableCalculator::getLinksFromAdjMatrix(int *links,
            double *linkCosts, int source)
    {
        int j=0;
        for (int i=0; i <numOfRouter; i++)
        {
            if ( adjMatrix[source][i] > 0 )
            {
                links[j]=i;
                linkCosts[j]=adjMatrix[source][i];
                j++;
            }
        }
    }

    void
    RoutingTableCalculator::freeAdjMatrix()
    {
        for(int i = 0; i < numOfRouter; ++i)
        {
            delete [] adjMatrix[i];
        }
        delete [] adjMatrix;
    }


    void
    RoutingTableCalculator::allocateLinks()
    {
        links=new int[vNoLink];
    }

    void RoutingTableCalculator::allocateLinkCosts()
    {
        linkCosts=new double[vNoLink];
    }


    void
    RoutingTableCalculator::freeLinks()
    {
        delete [] links;
    }
    void
    RoutingTableCalculator::freeLinksCosts()
    {
        delete [] linkCosts;
    }

    void
    LinkStateRoutingTableCalculator::calculatePath(Map& pMap,
            RoutingTable& rt, Nlsr& pnlsr)
    {
        cout<<"LinkStateRoutingTableCalculator::calculatePath Called"<<endl;
        allocateAdjMatrix();
        initMatrix();
        makeAdjMatrix(pnlsr,pMap);
        cout<<pMap;
        printAdjMatrix();
        string routerName=pnlsr.getConfParameter().getRouterPrefix();
        int sourceRouter=pMap.getMappingNoByRouterName(routerName);
        int noLink=getNumOfLinkfromAdjMatrix(sourceRouter);
        allocateParent();
        allocateDistance();

        if ( pnlsr.getConfParameter().getMaxFacesPerPrefix() == 1 )
        {
            // Single Path
            doDijkstraPathCalculation(sourceRouter);
            // print all ls path -- debugging purpose
            printAllLsPath(sourceRouter);
            // update routing table
            addAllLsNextHopsToRoutingTable(pnlsr, rt, pMap, sourceRouter);
        }
        else
        {
            // Multi Path
            setNoLink(getNumOfLinkfromAdjMatrix(sourceRouter));
            allocateLinks();
            allocateLinkCosts();

            getLinksFromAdjMatrix(links, linkCosts, sourceRouter);
            for (int i=0 ; i < vNoLink; i++)
            {

                adjustAdMatrix(sourceRouter,links[i], linkCosts[i]);
                printAdjMatrix();
                doDijkstraPathCalculation(sourceRouter);
                // print all ls path -- debugging purpose
                printAllLsPath(sourceRouter);
                //update routing table
                addAllLsNextHopsToRoutingTable(pnlsr, rt, pMap, sourceRouter);
            }

            freeLinks();
            freeLinksCosts();
        }

        freeParent();
        freeDistance();
        freeAdjMatrix();
    }

    void
    LinkStateRoutingTableCalculator::doDijkstraPathCalculation(int sourceRouter)
    {
        int i;
        int v,u;
        int *Q=new int[numOfRouter];
        int head=0;
        /* Initiate the Parent */
        for (i = 0 ; i < numOfRouter; i++)
        {
            parent[i]=EMPTY_PARENT;
            distance[i]=INF_DISTANCE;
            Q[i]=i;
        }

        if ( sourceRouter != NO_MAPPING_NUM )
        {
            distance[sourceRouter]=0;
            sortQueueByDistance(Q,distance,head,numOfRouter);

            while (head < numOfRouter )
            {
                u=Q[head];
                if(distance[u] == INF_DISTANCE)
                {
                    break;
                }

                for(v=0 ; v <numOfRouter; v++)
                {
                    if( adjMatrix[u][v] > 0 )
                    {
                        if ( isNotExplored(Q,v,head+1,numOfRouter) )
                        {
                            if( distance[u] + adjMatrix[u][v] <  distance[v])
                            {
                                distance[v]=distance[u] + adjMatrix[u][v] ;
                                parent[v]=u;
                            }

                        }

                    }

                }

                head++;
                sortQueueByDistance(Q,distance,head,numOfRouter);
            }
        }
        delete [] Q;
    }

    void
    LinkStateRoutingTableCalculator::addAllLsNextHopsToRoutingTable(Nlsr& pnlsr,
            RoutingTable& rt, Map& pMap, int sourceRouter)
    {
        cout<<"LinkStateRoutingTableCalculator::addAllNextHopsToRoutingTable Called";
        cout<<endl;
        for(int i=0; i < numOfRouter ; i++)
        {
            if ( i!= sourceRouter )
            {
                int nextHopRouter=getLsNextHop(i,sourceRouter);
                double routeCost=distance[i];
                string nextHopRouterName=pMap.getRouterNameByMappingNo(nextHopRouter);
                int nxtHopFace=
                    pnlsr.getAdl().getAdjacent(nextHopRouterName).getConnectingFace();
                cout<<"Dest Router: "<<pMap.getRouterNameByMappingNo(i)<<endl;
                cout<<"Next hop Router: "<<nextHopRouterName<<endl;
                cout<<"Next hop Face: "<<nxtHopFace<<endl;
                cout<<"Route Cost: "<<routeCost<<endl;
                cout<<endl;
                // Add next hop to routing table
                NextHop nh(nxtHopFace,routeCost);
                rt.addNextHop(pMap.getRouterNameByMappingNo(i),nh);

            }
        }
    }

    int
    LinkStateRoutingTableCalculator::getLsNextHop(int dest, int source)
    {
        int nextHop;
        while ( parent[dest] != EMPTY_PARENT )
        {
            nextHop=dest;
            dest=parent[dest];

        }

        if ( dest != source )
        {
            nextHop=NO_NEXT_HOP;
        }

        return nextHop;
    }

    void
    LinkStateRoutingTableCalculator::printAllLsPath(int sourceRouter)
    {
        cout<<"LinkStateRoutingTableCalculator::printAllLsPath Called"<<endl;
        cout<<"Source Router: "<<sourceRouter<<endl;
        for(int i=0; i < numOfRouter ; i++)
        {
            if ( i!= sourceRouter )
            {
                printLsPath(i);
                cout<<endl;
            }
        }
    }

    void
    LinkStateRoutingTableCalculator::printLsPath(int destRouter)
    {
        if (parent[destRouter] != EMPTY_PARENT )
        {
            printLsPath(parent[destRouter]);
        }

        cout<<" "<<destRouter;
    }

    void
    LinkStateRoutingTableCalculator::sortQueueByDistance(int *Q,
            double *dist,int start,int element)
    {
        for ( int i=start ; i < element ; i ++)
        {
            for( int j=i+1; j<element; j ++)
            {
                if (dist[Q[j]] < dist[Q[i]])
                {
                    int tempU=Q[j];
                    Q[j]=Q[i];
                    Q[i]=tempU;
                }
            }
        }

    }

    int
    LinkStateRoutingTableCalculator::isNotExplored(int *Q,
            int u,int start, int element)
    {
        int ret=0;
        for(int i=start; i< element; i++)
        {
            if ( Q[i] == u )
            {
                ret=1;
                break;
            }
        }
        return ret;
    }

    void
    LinkStateRoutingTableCalculator::allocateParent()
    {
        parent=new int[numOfRouter];
    }

    void
    LinkStateRoutingTableCalculator::allocateDistance()
    {
        distance= new double[numOfRouter];
    }

    void
    LinkStateRoutingTableCalculator::freeParent()
    {
        delete [] parent;
    }

    void LinkStateRoutingTableCalculator::freeDistance()
    {
        delete [] distance;
    }



    void
    HypRoutingTableCalculator::calculatePath(Map& pMap,
            RoutingTable& rt, Nlsr& pnlsr)
    {
        makeAdjMatrix(pnlsr,pMap);
        string routerName=pnlsr.getConfParameter().getRouterPrefix();
        int sourceRouter=pMap.getMappingNoByRouterName(routerName);
        int noLink=getNumOfLinkfromAdjMatrix(sourceRouter);
        setNoLink(noLink);
        allocateLinks();
        allocateLinkCosts();

        getLinksFromAdjMatrix(links, linkCosts, sourceRouter);

        for(int i=0 ; i < numOfRouter ; ++i)
        {
            int k=0;
            if ( i != sourceRouter)
            {
                allocateLinkFaces();
                allocateDistanceToNeighbor();
                allocateDistFromNbrToDest();

                for(int j=0; j<vNoLink; j++)
                {
                    string nextHopRouterName=pMap.getRouterNameByMappingNo(links[j]);
                    int nextHopFace=
                        pnlsr.getAdl().getAdjacent(nextHopRouterName).getConnectingFace();
                    double distToNbr=getHyperbolicDistance(pnlsr,pMap,
                                                           sourceRouter,links[j]);
                    double distToDestFromNbr=getHyperbolicDistance(pnlsr,
                                             pMap,links[j],i);
                    if ( distToDestFromNbr >= 0 )
                    {
                        linkFaces[k] = nextHopFace;
                        distanceToNeighbor[k] = distToNbr;
                        distFromNbrToDest[k] = distToDestFromNbr;
                        k++;
                    }
                }

                addHypNextHopsToRoutingTable(pnlsr,pMap,rt,k,i);

                freeLinkFaces();
                freeDistanceToNeighbor();
                freeDistFromNbrToDest();
            }
        }

        freeLinks();
        freeLinksCosts();
        freeAdjMatrix();
    }

    void
    HypRoutingTableCalculator::addHypNextHopsToRoutingTable(Nlsr& pnlsr,Map& pMap,
            RoutingTable& rt, int noFaces, int dest)
    {
        for(int i=0 ; i < noFaces ; ++i)
        {
            string destRouter=pMap.getRouterNameByMappingNo(dest);
            NextHop nh(linkFaces[i],distFromNbrToDest[i]);
            rt.addNextHop(destRouter,nh);
            if( isDryRun == 1 )
            {
                rt.addNextHopToDryTable(destRouter,nh);
            }
        }

    }

    double
    HypRoutingTableCalculator::getHyperbolicDistance(Nlsr& pnlsr,
            Map& pMap, int src, int dest)
    {
        double distance=0.0;

        string srcRouterKey=pMap.getRouterNameByMappingNo(src)+"/3";
        string destRouterKey=pMap.getRouterNameByMappingNo(dest)+"/3";

        double srcRadius=(pnlsr.getLsdb().getCorLsa(srcRouterKey).first).getCorRadius();
        double srcTheta=(pnlsr.getLsdb().getCorLsa(srcRouterKey).first).getCorTheta();

        double destRadius=(pnlsr.getLsdb().getCorLsa(
                               destRouterKey).first).getCorRadius();
        double destTheta=(pnlsr.getLsdb().getCorLsa(destRouterKey).first).getCorTheta();


        double diffTheta = fabs (srcTheta - destTheta);

        if (diffTheta > MATH_PI)
        {
            diffTheta = 2 * MATH_PI - diffTheta;
        }

        if ( srcRadius != -1 && destRadius != -1 )
        {
            if (diffTheta == 0)
                distance = fabs (srcRadius - destRadius);
            else
                distance = acosh((cosh(srcRadius)*cosh(destRadius))-
                                 (sinh(srcRadius)*sinh(destRadius)*cos(diffTheta)));
        }
        else
        {
            distance = -1;
        }

        return distance;
    }

    void
    HypRoutingTableCalculator::allocateLinkFaces()
    {
        linkFaces=new int[vNoLink];
    }

    void
    HypRoutingTableCalculator::allocateDistanceToNeighbor()
    {
        distanceToNeighbor=new double[vNoLink];
    }

    void
    HypRoutingTableCalculator::allocateDistFromNbrToDest()
    {
        distFromNbrToDest=new double[vNoLink];
    }

    void
    HypRoutingTableCalculator::freeLinkFaces()
    {
        delete [] linkFaces;
    }

    void
    HypRoutingTableCalculator::freeDistanceToNeighbor()
    {
        delete [] distanceToNeighbor;
    }

    void
    HypRoutingTableCalculator::freeDistFromNbrToDest()
    {
        delete [] distFromNbrToDest;
    }

}//namespace nlsr