ModelFlow.cpp

#include "Headers.h"
#include "ModelFlow.h"
#include "Shuffle.h"
#include "Rand.h"
#include "Debug.h"

#include "EventFlowConnect.h"
#include "EventFlowDisconnectReceiver.h"
#include "EventFlowDisconnectSender.h"
#include "EventFlowStart.h"
#include "EventFlowStop.h"

#pragma warning(disable : 4996)

CModelFlow::CModelFlow(
    __time      maxTime,
    CTopo*      topology,
    __uint32    topologyNumber,
    __uint32    numHosts,
    __uint32    numGateways,
    __bitrate   bwAccessUpLink,
    __bitrate   bwAccessDownLink,
    __time      delayAccessUpLink,
    __time      delayAccessDownLink,
    __uint32    queueLink
    ) : CModel(maxTime, topology)
{
    assert(numHosts > 0);
    assert(numGateways > 0);

    // Simulator
    this->sim = NULL;
    this->topology = topology;
    this->topologyNumber = topologyNumber;

    // Nodes
    this->numHosts = numHosts;
    this->numGateways = (numGateways <= this->topology->Nodes())?numGateways:this->topology->Nodes();
    this->bwAccessUpLink = bwAccessUpLink;
    this->bwAccessDownLink = bwAccessDownLink;
    this->delayAccessUpLink = delayAccessUpLink;
    this->delayAccessDownLink = delayAccessDownLink;
    this->queueLink = queueLink;

    this->hosts = NULL;
    this->routers = NULL;
    this->linksCore = NULL;
    this->linksAccess = NULL;

    // Generate gateways
    this->gateways = new __uint32[this->numHosts];

    // Generate gateway links (the number of access links for each gateway)
    this->routerAccessLinks = new __uint32[this->topology->Nodes()];

    for(__uint32 index = 0; index < this->topology->Nodes(); index++)
        this->routerAccessLinks[index] = 0;

    // Shuffle routers
    CShuffle shuffleRouters(this->topology->Nodes());

    // Assign a gateway for each host
    for(__uint32 index = 0; index < this->numHosts; index++)
    {
        __uint32 gw = shuffleRouters[CRand::Generate(this->numGateways-1)];
        assert(gw < this->topology->Nodes());
        
        this->gateways[index] = gw;
        this->routerAccessLinks[gw]++;
    }

    // Generate route
    this->routeNodes = this->topology->Nodes();
    this->routeDst = this->topology->Nodes() + this->numHosts;

    this->route = new int*[this->routeNodes];

    for(__uint32 index = 0; index < this->routeNodes; index++)
    {
        this->route[index] = new int[this->routeDst];
    }
}

CModelFlow::~CModelFlow()
{
    // Delete gateways
    delete[] this->gateways;
    delete[] this->routerAccessLinks;

    // Delete routes
    for(__uint32 index = 0; index < this->routeNodes; index++)
        delete[] this->route[index];
    delete[] this->route;
}

void CModelFlow::Init(CSimHandler* sim)
{
    this->sim = sim;

    // Generate hosts
    this->hosts = new CHostFlow*[this->numHosts];

    for(__uint32 index = 0; index < this->numHosts; index++)
    {
        this->hosts[index] = new CHostFlow(
            HOST_ID(index),
            this->sim,
            HOST_ADDR(index),
            this
            );
    }

    // Generate routers
    this->routers = new CRouter*[this->topology->Nodes()];

    for(__uint32 index = 0; index < this->topology->Nodes(); index++)
    {
        this->routers[index] = new CRouter(
            ROUTER_ID(this->topology->Node(index)->Id()),
            this->sim,
            ROUTER_ADDR(index),
            this->topology->Node(index)->Degree() + this->routerAccessLinks[index],
            this,
            this,
            NULL
            );
    }

    // Generate core links
    this->linksCore = new CLink*[this->topology->Edges()];

    for(__uint32 index = 0; index < this->topology->Edges(); index++)
    {
        assert(this->topology->Edge(index)->Nodes()[0] < this->topology->Nodes());
        assert(this->topology->Edge(index)->Nodes()[1] < this->topology->Nodes());

        this->linksCore[index] = new CLink(
            LINK_CORE_ID(this->topology->Edge(index)->Id()),
            this->sim,
            this->queueLink,
            this->topology->Edge(index)->Bandwidth(),
            this->topology->Edge(index)->Bandwidth(),
            this->topology->Edge(index)->Delay(),
            this->topology->Edge(index)->Delay());
    }

    // Generate access links
    this->linksAccess = new CLink*[this->numHosts];

    for(__uint32 index = 0; index < this->numHosts; index++)
    {
        this->linksAccess[index] = new CLink(
            LINK_ACCESS_ID(index),
            this->sim,
            this->queueLink,
            this->bwAccessUpLink,
            this->bwAccessDownLink,
            this->delayAccessUpLink,
            this->delayAccessDownLink
            );
    }

    // Generate node-link mappings
        // Generate for routers and core links
    for(__uint32 index = 0; index < this->topology->Nodes(); index++)
        for(__uint32 idx = 0; idx < this->topology->Node(index)->Degree(); idx++)
            this->routers[index]->AddLink(this->linksCore[this->topology->Node(index)->Edge(idx)]);

        // Generate for hosts, gateway routers and access links
    for(__uint32 index = 0; index < this->numHosts; index++)
    {
        // Add link to the host: entry 0 corresponds to the host (uplink)
        this->hosts[index]->AddLink(this->linksAccess[index]);

        // Add link to the corresponding gateway: entry 1 corresponds to the router (downlink)
        this->routers[this->gateways[index]]->AddLink(this->linksAccess[index]);
    }

    // Calculate routes
    for(__uint32 node = 0; node < this->routeNodes; node++)
    {
        // Routes: node to node
        for(__uint32 dst = 0; dst < this->routeNodes; dst++)
            if(dst == node) this->route[ROUTER_ADDR(node)][ROUTER_ADDR(dst)] = -1;
            else this->route[ROUTER_ADDR(node)][ROUTER_ADDR(dst)] = this->routers[node]->LinkIndex(this->linksCore[this->topology->Route()->NextEdge(node, dst)]->Id());

        // Routes: node to host
        for(__uint32 host = 0; host < this->numHosts; host++)
        {
            if(this->gateways[host] == node)
            {
                // If the node is the gateway of the destination
                this->route[ROUTER_ADDR(node)][HOST_ADDR(host)] = this->routers[node]->LinkIndex(this->linksAccess[host]->Id());
            }
            else
            {
                // Else: the route to the gateway
                this->route[ROUTER_ADDR(node)][HOST_ADDR(host)] = this->routers[node]->LinkIndex(this->linksCore[this->topology->Route()->NextEdge(node, this->gateways[host])]->Id());
            }
        }
    }


#if DEBUG_TOPOLOGY
    // Verify routers
    for(__uint32 index = 0; index < this->topology->Nodes(); index++)
    {
        // Check the links
        for(__uint32 idx = 0; idx < this->routers[index]->NumLinks(); idx++)
        {
            CLink* link = this->routers[index]->Link(idx);
            __uint32 entry = this->routers[index]->LinkEntry(idx);
            
            assert(link);
            assert(link->Node(entry) == this->routers[index]);
            assert(link->NodeEntry(entry) == idx);
        }
    }
    // Verify hosts
    for(__uint32 index = 0; index < this->numHosts; index++)
    {
        CLink* link = this->hosts[index]->Link();
        __uint32 entry = this->hosts[index]->LinkEntry();
        
        assert(link);
        assert(link->Node(entry) == this->hosts[index]);
        assert(link->NodeEntry(entry) == 0);
    }
    // Verify core links
    for(__uint32 index = 0; index < this->topology->Edges(); index++)
    {
        for(__uint32 idx = 0; idx < 2; idx++)
        {
            CRouter* router = type_cast<CRouter*>(this->linksCore[index]->Node(idx));
            __uint32 entry = this->linksCore[index]->NodeEntry(idx);

            assert(router);
            assert(router->Link(entry) == this->linksCore[index]);
            assert(router->LinkEntry(entry) == idx);
        }
    }
    // Verify access links
    for(__uint32 index = 0; index < this->numHosts; index++)
    {
        CHost* host = type_cast<CHost*>(this->linksAccess[index]->Node(0));
        __uint32 entryHost = this->linksAccess[index]->NodeEntry(0);
        CRouter* router = type_cast<CRouter*>(this->linksAccess[index]->Node(1));
        __uint32 entryRouter = this->linksAccess[index]->NodeEntry(1);

        assert(host);
        assert(host->Link() == this->linksAccess[index]);
        assert(host->LinkEntry() == 0);
        assert(router);
        assert(router->Link(entryRouter) == this->linksAccess[index]);
        assert(router->LinkEntry(entryRouter) == 1);
    }
    // Verify routes
        // router-to-router
    
    for(__uint32 src = 0; src < this->routeNodes; src++)
        for(__uint32 dst = 0; dst < this->routeNodes; dst++)
        {
            CNode* node = this->routers[src];
            CLink* link;
            __uint32 linkEntry;
            int index;

            while(node != this->routers[dst])
            {
                index = this->route[node->Address().Address()][this->routers[dst]->Address().Address()];
                link = type_cast<CRouter*>(node)->Link(index);
                linkEntry = type_cast<CRouter*>(node)->LinkEntry(index);
                node = type_cast<CNode*>(link->Node(linkEntry ^ 1));
            }
            // Check the destination was reached
            assert(node == this->routers[dst]);
        }

        // router-to-hosts
    for(__uint32 src = 0; src < this->routeNodes; src++)
        for(__uint32 dst = 0; dst < this->numHosts; dst++)
        {
            CNode* node = this->routers[src];
            CLink* link;
            __uint32 linkEntry;
            int index;

            while(node != this->hosts[dst])
            {
                index = this->route[node->Address().Address()][this->hosts[dst]->Address().Address()];
                link = type_cast<CRouter*>(node)->Link(index);
                linkEntry = type_cast<CRouter*>(node)->LinkEntry(index);
                node = type_cast<CNode*>(link->Node(linkEntry ^ 1));
            }
            // Check the destination was reached
            assert(node == this->hosts[dst]);
        }
#endif
}

__uint32 CModelFlow::Events()
{
    return 7; //1 + this->numHosts;
}

CSimEvent* CModelFlow::Event(__uint32 index, __time& time)
{
    switch(index)
    {
    case 0:
        time = 0;
        return new CEventFlowConnect(this->hosts[1], HOST_ADDR(0));;
    case 1:
        time = 10;
        return new CEventFlowStart(this->hosts[0], 0);
    case 2:
        time = 110;
        return new CEventFlowStop(this->hosts[0], 0);
    case 3:
        time = 900;
        //return new CEventFlowDisconnectSender(this->hosts[1]);
        return new CEventFlowDisconnectReceiver(this->hosts[1]);
    case 4:
        time = 50;
        return new CEventFlowConnect(this->hosts[2], HOST_ADDR(0));;
    case 5:
        time = 60;
        return new CEventFlowStart(this->hosts[0], 1);
    case 6:
        time = 160;
        return new CEventFlowStop(this->hosts[0], 1);
    case 7:
        time = 900;
        //return new CEventFlowDisconnectSender(this->hosts[1]);
        return new CEventFlowDisconnectReceiver(this->hosts[2]);
    }
    return NULL;
}

void CModelFlow::Finalize()
{
    //FILE* out;
    //char fileName[1024];

    /*
     * Simple statistics
     */

    // Calculate data

    // Data : bandwidth
    this->dataBwTotal = 0;

    // Data : bandwidth core
    this->dataBwCoreTotal = 0;

    // Data : bandwidth access
    this->dataBwAccessTotal = 0;

    // Data : bandwidth access uplink
    this->dataBwAccessUpTotal = 0;

    // Data : bandwidth access downlink
    this->dataBwAccessDownTotal = 0;

    // Data : bandwidth stream
    this->dataBwStreamTotal = 0;

    // Data : bandwidth core stream
    this->dataBwCoreStreamTotal = 0;

    // Data : bandwidth access stream
    this->dataBwAccessStreamTotal = 0;

    // Data : bandwidth access uplink stream
    this->dataBwAccessUpStreamTotal = 0;

    // Data : bandwidth access downlink stream
    this->dataBwAccessDownStreamTotal = 0;

    // Data : bandwidth control
    this->dataBwControlTotal = 0;

    // Data : bandwidth core control
    this->dataBwCoreControlTotal = 0;

    // Data : bandwidth access control
    this->dataBwAccessControlTotal = 0;

    // Data : bandwidth access uplink control
    this->dataBwAccessUpControlTotal = 0;

    // Data : bandwidth access downlink control
    this->dataBwAccessDownControlTotal = 0;

    // Core links
    for(__uint32 index = 0; index < this->topology->Edges(); index++)
    {
        this->dataBwTotal += this->linksCore[index]->StatBits(0,0) + this->linksCore[index]->StatBits(0,1) + this->linksCore[index]->StatBits(1,0) + this->linksCore[index]->StatBits(1,1);
        this->dataBwCoreTotal += this->linksCore[index]->StatBits(0,0) + this->linksCore[index]->StatBits(0,1) + this->linksCore[index]->StatBits(1,0) + this->linksCore[index]->StatBits(1,1);
        this->dataBwStreamTotal += this->linksCore[index]->StatBits(1,0) + this->linksCore[index]->StatBits(1,1);
        this->dataBwCoreStreamTotal += this->linksCore[index]->StatBits(1,0) + this->linksCore[index]->StatBits(1,1);
        this->dataBwControlTotal += this->linksCore[index]->StatBits(0,0) + this->linksCore[index]->StatBits(0,1);
        this->dataBwCoreControlTotal += this->linksCore[index]->StatBits(0,0) + this->linksCore[index]->StatBits(0,1);
    }

    // Access links
    for(__uint32 index = 0; index < this->numHosts; index++)
    {
        this->dataBwTotal += this->linksAccess[index]->StatBits(0,0) + this->linksAccess[index]->StatBits(0,1) + this->linksAccess[index]->StatBits(1,0) + this->linksAccess[index]->StatBits(1,1);
        this->dataBwAccessTotal += this->linksAccess[index]->StatBits(0,0) + this->linksAccess[index]->StatBits(0,1) + this->linksAccess[index]->StatBits(1,0) + this->linksAccess[index]->StatBits(1,1);
        this->dataBwAccessUpTotal += this->linksAccess[index]->StatBits(0,0) + this->linksAccess[index]->StatBits(1,0);
        this->dataBwAccessDownTotal += this->linksAccess[index]->StatBits(0,1) + this->linksAccess[index]->StatBits(1,1);
        this->dataBwStreamTotal += this->linksAccess[index]->StatBits(1,0) + this->linksAccess[index]->StatBits(1,1);
        this->dataBwAccessStreamTotal += this->linksAccess[index]->StatBits(1,0) + this->linksAccess[index]->StatBits(1,1);
        this->dataBwAccessUpStreamTotal += this->linksAccess[index]->StatBits(1,0);
        this->dataBwAccessDownStreamTotal += this->linksAccess[index]->StatBits(1,1);
        this->dataBwControlTotal += this->linksAccess[index]->StatBits(0,0) + this->linksAccess[index]->StatBits(0,1);
        this->dataBwAccessControlTotal += this->linksAccess[index]->StatBits(0,0) + this->linksAccess[index]->StatBits(0,1);
        this->dataBwAccessUpControlTotal += this->linksAccess[index]->StatBits(0,0);
        this->dataBwAccessDownControlTotal += this->linksAccess[index]->StatBits(0,1);
    }

    this->dataBwAvg = this->dataBwTotal/this->maxTime;
    this->dataBwCoreAvg = this->dataBwCoreTotal/this->maxTime;
    this->dataBwAccessAvg = this->dataBwAccessTotal/this->maxTime;
    this->dataBwAccessUpAvg = this->dataBwAccessUpTotal/this->maxTime;
    this->dataBwAccessDownAvg = this->dataBwAccessDownTotal/this->maxTime;
    this->dataBwStreamAvg = this->dataBwStreamTotal/this->maxTime;
    this->dataBwCoreStreamAvg = this->dataBwCoreStreamTotal/this->maxTime;
    this->dataBwAccessStreamAvg = this->dataBwAccessStreamTotal/this->maxTime;
    this->dataBwAccessUpStreamAvg = this->dataBwAccessUpStreamTotal/this->maxTime;
    this->dataBwAccessDownStreamAvg = this->dataBwAccessDownStreamTotal/this->maxTime;
    this->dataBwControlAvg = this->dataBwControlTotal/this->maxTime;
    this->dataBwCoreControlAvg = this->dataBwCoreControlTotal/this->maxTime;
    this->dataBwAccessControlAvg = this->dataBwAccessControlTotal/this->maxTime;
    this->dataBwAccessUpControlAvg = this->dataBwAccessUpControlTotal/this->maxTime;
    this->dataBwAccessDownControlAvg = this->dataBwAccessDownControlTotal/this->maxTime;

    // Routers
    for(__uint32 index = 0; index < this->topology->Nodes(); index++)
    {
        this->routers[index]->Finalize();
    }

    //sprintf(fileName, "network_%s_%u.out", this->name, this->topologyNumber);
    //if(FILE_OPEN(out, fileName, "a")) printf("\nCannot write to file %s.", fileName);
    //else
    //{
    //  fprintf(out, "%u %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %llu %.9lf %.9lf %.9lf %.9lf\n",
    //      this->numChannelsMcast,                 // 1
    //      this->dataBwTotal,                      // 2
    //      this->dataBwAvg,                        // 3
    //      this->dataBwCoreTotal,                  // 4
    //      this->dataBwCoreAvg,                    // 5
    //      this->dataBwAccessTotal,                // 6
    //      this->dataBwAccessAvg,                  // 7
    //      this->dataBwAccessUpTotal,              // 8
    //      this->dataBwAccessUpAvg,                // 9
    //      this->dataBwAccessDownTotal,            // 10
    //      this->dataBwAccessDownAvg,              // 11
    //      this->dataBwServerTotal,                // 12
    //      this->dataBwServerAvg,                  // 13
    //      this->dataBwStreamTotal,                // 14
    //      this->dataBwStreamAvg,                  // 15
    //      this->dataBwCoreStreamTotal,            // 16
    //      this->dataBwCoreStreamAvg,              // 17
    //      this->dataBwAccessStreamTotal,          // 18
    //      this->dataBwAccessStreamAvg,            // 19
    //      this->dataBwAccessUpStreamTotal,        // 20
    //      this->dataBwAccessUpStreamAvg,          // 21
    //      this->dataBwAccessDownStreamTotal,      // 22
    //      this->dataBwAccessDownStreamAvg,        // 23
    //      this->dataBwServerStreamTotal,          // 24
    //      this->dataBwServerStreamAvg,            // 25
    //      this->dataBwControlTotal,               // 26
    //      this->dataBwControlAvg,                 // 27
    //      this->dataBwCoreControlTotal,           // 28
    //      this->dataBwCoreControlAvg,             // 29
    //      this->dataBwAccessControlTotal,         // 30
    //      this->dataBwAccessControlAvg,           // 31
    //      this->dataBwAccessUpControlTotal,       // 32
    //      this->dataBwAccessUpControlAvg,         // 33
    //      this->dataBwAccessDownControlTotal,     // 34
    //      this->dataBwAccessDownControlAvg,       // 35
    //      this->dataBwServerControlTotal,         // 36
    //      this->dataBwServerControlAvg,           // 37
    //      this->dataRouterMcastEntries,           // 38
    //      this->dataRouterMcastEntriesIgmp,       // 39
    //      this->dataRouterMcastEntriesPimSm       // 40
    //      );

    //  fclose(out);
    //}

    /*
     * Cleanup objects created during simulation (objects that cannot be deleted in the destructor because they depend on the simulator)
     */

    // Delete hosts
    if(this->hosts)
    {
        for(__uint32 index = 0; index < this->numHosts; index++)
            delete this->hosts[index];
        delete[] this->hosts;
    }

    // Delete routers
    if(this->routers)
    {
        for(__uint32 index = 0; index < this->topology->Nodes(); index++)
            delete this->routers[index];
        delete[] this->routers;
    }

    // Delete links core
    if(this->linksCore)
    {
        for(__uint32 index = 0; index < this->topology->Edges(); index++)
            delete this->linksCore[index];
        delete[] this->linksCore;
    }

    // Delete links access
    if(this->linksAccess)
    {
        for(__uint32 index = 0; index < this->numHosts; index++)
            delete this->linksAccess[index];
        delete[] this->linksAccess;
    }
}

int CModelFlow::Forward(CAddress node, CAddress dst)
{
    // Calculates the outgoing link when the router receives a packet with a certain destination
    assert(node.Address() <= this->routeNodes);
    assert(dst.Address() <= this->routeDst);

    return this->route[node.Address()][dst.Address()];
}


#ifdef MULTICAST

void CModelFlow::MulticastJoin(__uint32 host, __uint32 group)
{
    // Add host to multicast group
    (*this->multicast)[group]->Add(this->sim->Time(), HOST_INDEX(host), this->gateways[HOST_INDEX(host)]);
}

void CModelFlow::MulticastLeave(__uint32 host, __uint32 group)
{
    // Remove host from multicast group
    (*this->multicast)[group]->Remove(this->sim->Time(), HOST_INDEX(host), this->gateways[HOST_INDEX(host)]);
}

#endif