ModelPush.cpp

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

#include "EventServerStart.h"
#include "EventClientArrive.h"
#include "EventClientWatch.h"
#include "EventClientLeave.h"

#pragma warning(disable : 4996)

CModelPush::CModelPush(
    char*       name,
    __time      maxTime,
    CTopo*      topology,
    __uint32    topologyNumber,
    CModelChannel*  modelChannel,
    __uint32    numHosts,
    __uint32    numGateways,
    __uint32    bwAccessBins,
    __bitrate*  bwAccessUpLink,
    __bitrate*  bwAccessDownLink,
    double*     bwAccessRatio,
    __time      delayAccessUpLink,
    __time      delayAccessDownLink,
    __bitrate   bwServerUpLink,
    __bitrate   bwServerDownLink,
    __time      delayServerUpLink,
    __time      delayServerDownLink,
    __uint32    queueLink,
    __uint32    queueLinkServer,
    __uint32    numChannelsMcast,
    __uint32    numChannelsUcast,
    __bitrate   channelBw,
    __byte      channelFps,
    __byte      mpegGopDistanceItoI,
    __byte      mpegGopDistanceItoP,
    __uint32    streamBufferSize,
    __uint32    streamBufferSizeHistory,
    __uint32    streamBufferSizeBuffering,
    __time      streamBufferUnderrunTimeout,
    double      streamBwMargin,
    __uint32    bootQueryMax,
    __uint32    bootRefreshThreshold,
    __time      bootQueryTimeout,
    __time      bootRegisterDelay
    ) : CModel(maxTime, topology)
{
    assert(name);
    assert(numHosts > 0);
    assert(numGateways > 0);
    assert(bwAccessBins > 0);

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

    // Nodes
    this->numHosts = numHosts;
    this->numServers = 1;
    this->numGateways = (numGateways <= this->topology->Nodes())?numGateways:this->topology->Nodes();
    this->bwAccessBins = bwAccessBins;
    this->bwAccessUpLink = bwAccessUpLink;
    this->bwAccessDownLink = bwAccessDownLink;
    this->bwAccessRatio = bwAccessRatio;
    this->delayAccessUpLink = delayAccessUpLink;
    this->delayAccessDownLink = delayAccessDownLink;
    this->bwServerUpLink = bwServerUpLink;
    this->bwServerDownLink = bwServerDownLink;
    this->delayServerUpLink = delayServerUpLink;
    this->delayServerDownLink = delayServerDownLink;
    this->queueLink = queueLink;
    this->queueLinkServer = queueLinkServer;

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

    // Channels
    this->numChannels = numChannelsUcast + numChannelsMcast;
    this->numChannelsUcast = numChannelsUcast;
    this->numChannelsMcast = numChannelsMcast;
    this->channelBw = channelBw;
    this->channelFps = channelFps;

    // Stream
    this->streamBufferSize = streamBufferSize;
    this->streamBufferSizeHistory = streamBufferSizeHistory;
    this->streamBufferSizeBuffering = streamBufferSizeBuffering;
    this->streamBufferUnderrunTimeout = streamBufferUnderrunTimeout;
    this->streamBwMargin = streamBwMargin;

    // Bootstrap
    this->bootQueryMax = bootQueryMax;
    this->bootRefreshThreshold = bootRefreshThreshold;
    this->bootQueryTimeout = bootQueryTimeout;
    this->bootRegisterDelay = bootRegisterDelay;

    // 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;

    // Generate gateway for server
    this->gatewayServer = CRand::Generate(this->topology->Nodes());

    // 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->numServers;

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

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

    // Addresses for the multicast RP for each channel
    this->mcastRp = new CAddress[this->numChannelsMcast];

    for(__uint32 index = 0; index < this->numChannelsMcast; index++)
        this->mcastRp[index] = ROUTER_ADDR(this->gatewayServer);

    // Create channels
    this->channelsMcast = new CChannel[this->numChannelsMcast];

    for(__uint32 index = 0; index < this->numChannelsMcast; index++)
        this->channelsMcast[index] = CChannel(index, CChannel::CHANNEL_MULTICAST, CAddress::Multicast(index), this->channelBw, this->channelFps);

    this->channelsUcast = new CChannel[this->numChannelsUcast];

    for(__uint32 index = 0; index < this->numChannelsUcast; index++)
        this->channelsUcast[index] = CChannel(index + this->numChannelsMcast, CChannel::CHANNEL_UNICAST, SERVER_ADDR(0), this->channelBw, this->channelFps);

    // Create stream sources for all channels
    this->streamSources = new CStreamSourceMpeg*[this->numChannels];

    // Create stream sources
    for(__uint32 index = 0; index < this->numChannels; index++)
    {
        this->streamSources[index] = new CStreamSourceMpeg(
            this->Channel(index),
            mpegGopDistanceItoI,
            mpegGopDistanceItoP);
    }

    // Generate access bandwidth
    this->bwAccessHostUpLink = new __bitrate[this->numHosts];
    this->bwAccessHostDownLink = new __bitrate[this->numHosts];

    // Randomize Hosts
    CShuffle shuffleHosts(this->numHosts);

    __uint32 index = 0;
    for(unsigned bin = 0; (bin < this->bwAccessBins) && (index < this->numHosts); bin++)
    {
        __uint32 binSize = (__uint32)ceil(this->bwAccessRatio[bin] * this->numHosts);
        for(__uint32 idx = 0; idx < binSize; idx++, index++)
        {
            this->bwAccessHostUpLink[shuffleHosts[index]] = this->bwAccessUpLink[bin];
            this->bwAccessHostDownLink[shuffleHosts[index]] = this->bwAccessDownLink[bin];
        }
    }

    // Data
    this->data = new CData(
        this->name,
        this->topologyNumber,
        this->numChannelsMcast
        );
}

CModelPush::~CModelPush()
{
    // 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;

    // Delete multicast RP addresses
    delete[] this->mcastRp;

    // Delete stream sources
    for(__uint32 index = 0; index < this->numChannels; index++)
        delete this->streamSources[index];
    delete[] this->streamSources;

    // Delete channels
    delete[] this->channelsMcast;
    delete[] this->channelsUcast;

    // Delete access bandwidth
    delete[] this->bwAccessHostUpLink;
    delete[] this->bwAccessHostDownLink;

    // Delete data
    delete this->data;

    // Delete multicast
    delete this->multicast;
}

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

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

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

    // Generate server
    this->server = new CHostServerPush(
        SERVER_ID(0),
        this->sim,
        SERVER_ADDR(0),
        this,
        this->data);

    // 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] + ((index == this->gatewayServer)?1:0),
            this,
            this,
            this->mcastRp
            );
    }

    // 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->bwAccessHostUpLink[index],
            this->bwAccessHostDownLink[index],
            this->delayAccessUpLink,
            this->delayAccessDownLink
            );
    }

    // Generate server link
    this->linkServer = new CLink(
        LINK_SERVER_ID(0),
        this->sim,
        this->queueLinkServer,
        this->bwServerUpLink,
        this->bwServerDownLink,
        this->delayServerUpLink,
        this->delayServerDownLink
        );

    // 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]);
    }

        // Generate for server : add link to server
    this->server->AddLink(this->linkServer);
        // Generate for server gateway
    this->routers[this->gatewayServer]->AddLink(this->linkServer);

    // 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());
            }
        }

        // Routes: node to server
        if(this->gatewayServer == node)
            // If the node is the gateway of the server
            this->route[ROUTER_ADDR(node)][SERVER_ADDR(0)] = this->routers[node]->LinkIndex(this->linkServer->Id());
        else
            // Else: the route to the server gateway
            this->route[ROUTER_ADDR(node)][SERVER_ADDR(0)] = this->routers[node]->LinkIndex(this->linksCore[this->topology->Route()->NextEdge(node, this->gatewayServer)]->Id());
    }

    // Multicast
    this->multicast = new CMulticast(this->numChannelsMcast, this->topology, this->gatewayServer);

#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 CModelPush::Events()
{
    return 1 + this->numHosts;
}

CSimEvent* CModelPush::Event(__uint32 index, __time& time)
{
    switch(index)
    {
    case 0: // Server init event
        time = 0;
        return new CEventServerStart(this->server);
    default: // Peer arrive
        time = 0;
        return new CEventClientArrive(this->hosts[index-1]);
    }
}

void CModelPush::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 server
    this->dataBwServerTotal = 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 server stream
    this->dataBwServerStreamTotal = 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;

    // Data : bandwidth server control
    this->dataBwServerControlTotal = 0;

    // Data : multicast entries
    this->dataRouterMcastEntries = 0;
    this->dataRouterMcastEntriesIgmp = 0;
    this->dataRouterMcastEntriesPimSm = 0;

    // Server link
    this->dataBwTotal += this->linkServer->StatBits(0,0) + this->linkServer->StatBits(0,1) + this->linkServer->StatBits(1,0) + this->linkServer->StatBits(1,1);
    this->dataBwServerTotal += this->linkServer->StatBits(0,0) + this->linkServer->StatBits(0,1) + this->linkServer->StatBits(1,0) + this->linkServer->StatBits(1,1);
    this->dataBwStreamTotal += this->linkServer->StatBits(1,0) + this->linkServer->StatBits(1,1);
    this->dataBwServerStreamTotal += this->linkServer->StatBits(1,0) + this->linkServer->StatBits(1,1);
    this->dataBwServerControlTotal += this->linkServer->StatBits(0,0) + this->linkServer->StatBits(0,1);

    // 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->dataBwServerAvg = this->dataBwServerTotal/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->dataBwServerStreamAvg = this->dataBwServerStreamTotal/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;
    this->dataBwServerControlAvg = this->dataBwServerControlTotal/this->maxTime;

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

    // Global file
    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);
    }

#ifdef STAT_VERBOSE

    /*
     * Advanced statistics
     */

    // Statistics file in user form

    sprintf(fileName, "stat_%s_%u_%u.stat", this->name, this->topologyNumber, this->numChannelsMcast);
    if(FILE_OPEN(out, fileName, "w")) printf("\nCannot write to file %s.", fileName);
    else
    {
        // Save host statistics
        fprintf(out, "\n\nHosts\n");
        fprintf(out, "\nHost        Gw         Read      Write"); 
        fprintf(out, "\n======================================================================="); 

        fprintf(out, "\nSERVER     %3u   %10llu %10llu",
            this->gatewayServer,
            this->server->StatPacketsRead(),
            this->server->StatPacketsWrite());

        for(__uint32 index = 0; index < this->numHosts; index++)
        {
            fprintf(out, "\nHOST %3u   %3u   %10llu %10llu",
                index,
                this->gateways[index],
                this->hosts[index]->StatPacketsRead(),
                this->hosts[index]->StatPacketsWrite()
                );
        }

        // Save router statistics
        fprintf(out, "\n\nRouters\n");
        fprintf(out, "\nRouter             Read      Write     Entr IGMP Entr PIMSM "); 
        fprintf(out, "\n============================================================="); 

        for(__uint32 index = 0; index < this->topology->Nodes(); index++)
        {
            fprintf(out, "\nROUTER %3u   %10llu %10llu %10.5lf %10.5lf",
                index,
                this->routers[index]->StatPacketsRead(),
                this->routers[index]->StatPacketsWrite(),
                this->routers[index]->StatMcastEntriesIgmp(),
                this->routers[index]->StatMcastEntriesPimSm()
                );
        }


        // Save link statistics : server
        fprintf(out, "\n\nServer link (00-hi/up 01-hi/down 10-low/up 11-low/down)\n");
        fprintf(out, "\nLink         Bw0        Bw1   Util00 Util01 Util10 Util11 Pack00 Disc00 Pack01 Disc01 Pack10 Disc10 Pack11 Disc11 Bits00 Bits01 Bits10 Bits11 Que00  Que01  Que10  Que11"); 
        fprintf(out, "\n========================================================================================================================================================================"); 

        this->linkServer->Finalize();
        fprintf(out, "\n%3u   %10.0lf %10.0lf : %6.4lf %6.4lf %6.4lf %6.4lf %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6.2lf %6.2lf %6.2lf %6.2lf ",
            0,
            this->linkServer->Bandwidth(0),
            this->linkServer->Bandwidth(1),
            this->linkServer->StatUtilization(0, 0),
            this->linkServer->StatUtilization(0, 1),
            this->linkServer->StatUtilization(1, 0),
            this->linkServer->StatUtilization(1, 1),
            this->linkServer->StatPackets(0, 0),
            this->linkServer->StatDiscard(0, 0),
            this->linkServer->StatPackets(0, 1),
            this->linkServer->StatDiscard(0, 1),
            this->linkServer->StatPackets(1, 0),
            this->linkServer->StatDiscard(1, 0),
            this->linkServer->StatPackets(1, 1),
            this->linkServer->StatDiscard(1, 1),
            this->linkServer->StatBits(0, 0),
            this->linkServer->StatBits(0, 1),
            this->linkServer->StatBits(1, 0),
            this->linkServer->StatBits(1, 1),
            this->linkServer->StatQueue(0, 0),
            this->linkServer->StatQueue(0, 1),
            this->linkServer->StatQueue(1, 0),
            this->linkServer->StatQueue(1, 1)
            );


        // Save link statistics : access
        fprintf(out, "\n\nAccess links (00-hi/up 01-hi/down 10-low/up 11-low/down)\n");
        fprintf(out, "\nLink         Bw0        Bw1   Util00 Util01 Util10 Util11 Pack00 Disc00 Pack01 Disc01 Pack10 Disc10 Pack11 Disc11 Bits00 Bits01 Bits10 Bits11 Que00  Que01  Que10  Que11"); 
        fprintf(out, "\n========================================================================================================================================================================"); 
        for(__uint32 index = 0; index < this->numHosts; index++)
        {
            this->linksAccess[index]->Finalize();
            fprintf(out, "\n%3u   %10.0lf %10.0lf : %6.4lf %6.4lf %6.4lf %6.4lf %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6.2lf %6.2lf %6.2lf %6.2lf ",
                index,
                this->linksAccess[index]->Bandwidth(0),
                this->linksAccess[index]->Bandwidth(1),
                this->linksAccess[index]->StatUtilization(0, 0),
                this->linksAccess[index]->StatUtilization(0, 1),
                this->linksAccess[index]->StatUtilization(1, 0),
                this->linksAccess[index]->StatUtilization(1, 1),
                this->linksAccess[index]->StatPackets(0, 0),
                this->linksAccess[index]->StatDiscard(0, 0),
                this->linksAccess[index]->StatPackets(0, 1),
                this->linksAccess[index]->StatDiscard(0, 1),
                this->linksAccess[index]->StatPackets(1, 0),
                this->linksAccess[index]->StatDiscard(1, 0),
                this->linksAccess[index]->StatPackets(1, 1),
                this->linksAccess[index]->StatDiscard(1, 1),
                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->linksAccess[index]->StatQueue(0, 0),
                this->linksAccess[index]->StatQueue(0, 1),
                this->linksAccess[index]->StatQueue(1, 0),
                this->linksAccess[index]->StatQueue(1, 1)
                );
        }
        
        // Save link statistics : core
        fprintf(out, "\n\nCore links (00-hi/up 01-hi/down 10-low/up 11-low/down)\n");
        fprintf(out, "\nLink         Bw0        Bw1   Util00 Util01 Util10 Util11 Pack00 Disc00 Pack01 Disc01 Pack10 Disc10 Pack11 Disc11 Bits00 Bits01 Bits10 Bits11 Que00  Que01  Que10  Que11"); 
        fprintf(out, "\n========================================================================================================================================================================"); 
        for(__uint32 index = 0; index < this->topology->Edges(); index++)
        {
            this->linksCore[index]->Finalize();
            fprintf(out, "\n%3u   %10.0lf %10.0lf : %6.4lf %6.4lf %6.4lf %6.4lf %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6llu %6.2lf %6.2lf %6.2lf %6.2lf ",
                index,
                this->linksCore[index]->Bandwidth(0),
                this->linksCore[index]->Bandwidth(1),
                this->linksCore[index]->StatUtilization(0, 0),
                this->linksCore[index]->StatUtilization(0, 1),
                this->linksCore[index]->StatUtilization(1, 0),
                this->linksCore[index]->StatUtilization(1, 1),
                this->linksCore[index]->StatPackets(0, 0),
                this->linksCore[index]->StatDiscard(0, 0),
                this->linksCore[index]->StatPackets(0, 1),
                this->linksCore[index]->StatDiscard(0, 1),
                this->linksCore[index]->StatPackets(1, 0),
                this->linksCore[index]->StatDiscard(1, 0),
                this->linksCore[index]->StatPackets(1, 1),
                this->linksCore[index]->StatDiscard(1, 1),
                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->linksCore[index]->StatQueue(0, 0),
                this->linksCore[index]->StatQueue(0, 1),
                this->linksCore[index]->StatQueue(1, 0),
                this->linksCore[index]->StatQueue(1, 1)
                );
        }
        fclose(out);
    }

    // Statistics file in computer form

        // Hosts

    sprintf(fileName, "hosts_%s_%u_%u.stat", this->name, this->topologyNumber, this->numChannelsMcast);
    if(FILE_OPEN(out, fileName, "w"))  printf("\nCannot write to file %s.", fileName);
    else
    {
        // Save host statistics
        fprintf(out, "0 %u %llu %llu\n",
            this->gatewayServer,
            this->server->StatPacketsRead(),
            this->server->StatPacketsWrite());

        for(__uint32 index = 0; index < this->numHosts; index++)
        {
            fprintf(out, "%u %u %llu %llu\n",
                index,
                this->gateways[index],
                this->hosts[index]->StatPacketsRead(),
                this->hosts[index]->StatPacketsWrite()
                );
        }

        fclose(out);
    }
        // Routers

    sprintf(fileName, "routers_%s_%u_%u.stat", this->name, this->topologyNumber, this->numChannelsMcast);
    if(FILE_OPEN(out, fileName, "w"))  printf("\nCannot write to file %s.", fileName);
    else
    {
        for(__uint32 index = 0; index < this->topology->Nodes(); index++)
        {
            fprintf(out, "%u %llu %llu %.9lf %.9lf\n",
                index,
                this->routers[index]->StatPacketsRead(),
                this->routers[index]->StatPacketsWrite(),
                this->routers[index]->StatMcastEntriesIgmp(),
                this->routers[index]->StatMcastEntriesPimSm()
                );
        }

        fclose(out);
    }
        // Server link

    sprintf(fileName, "slink_%s_%u_%u.stat", this->name, this->topologyNumber, this->numChannelsMcast);
    if(FILE_OPEN(out, fileName, "w"))  printf("\nCannot write to file %s.", fileName);
    else
    {
        fprintf(out, "%u %.0lf %.0lf %.9lf %.9lf %.9lf %.9lf %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %.9lf %.9lf %.9lf %.9lf\n",
            0,
            this->linkServer->Bandwidth(0),
            this->linkServer->Bandwidth(1),
            this->linkServer->StatUtilization(0, 0),
            this->linkServer->StatUtilization(0, 1),
            this->linkServer->StatUtilization(1, 0),
            this->linkServer->StatUtilization(1, 1),
            this->linkServer->StatPackets(0, 0),
            this->linkServer->StatDiscard(0, 0),
            this->linkServer->StatPackets(0, 1),
            this->linkServer->StatDiscard(0, 1),
            this->linkServer->StatPackets(1, 0),
            this->linkServer->StatDiscard(1, 0),
            this->linkServer->StatPackets(1, 1),
            this->linkServer->StatDiscard(1, 1),
            this->linkServer->StatBits(0, 0),
            this->linkServer->StatBits(0, 1),
            this->linkServer->StatBits(1, 0),
            this->linkServer->StatBits(1, 1),
            this->linkServer->StatQueue(0, 0),
            this->linkServer->StatQueue(0, 1),
            this->linkServer->StatQueue(1, 0),
            this->linkServer->StatQueue(1, 1)
            );

        fclose(out);
    }
        // Access links

    sprintf(fileName, "alink_%s_%u_%u.stat", this->name, this->topologyNumber, this->numChannelsMcast);
    if(FILE_OPEN(out, fileName, "w"))  printf("\nCannot write to file %s.", fileName);
    else
    {
        for(__uint32 index = 0; index < this->numHosts; index++)
        {
            fprintf(out, "%u %.0lf %.0lf %.9lf %.9lf %.9lf %.9lf %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %.9lf %.9lf %.9lf %.9lf\n",
                index,
                this->linksAccess[index]->Bandwidth(0),
                this->linksAccess[index]->Bandwidth(1),
                this->linksAccess[index]->StatUtilization(0, 0),
                this->linksAccess[index]->StatUtilization(0, 1),
                this->linksAccess[index]->StatUtilization(1, 0),
                this->linksAccess[index]->StatUtilization(1, 1),
                this->linksAccess[index]->StatPackets(0, 0),
                this->linksAccess[index]->StatDiscard(0, 0),
                this->linksAccess[index]->StatPackets(0, 1),
                this->linksAccess[index]->StatDiscard(0, 1),
                this->linksAccess[index]->StatPackets(1, 0),
                this->linksAccess[index]->StatDiscard(1, 0),
                this->linksAccess[index]->StatPackets(1, 1),
                this->linksAccess[index]->StatDiscard(1, 1),
                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->linksAccess[index]->StatQueue(0, 0),
                this->linksAccess[index]->StatQueue(0, 1),
                this->linksAccess[index]->StatQueue(1, 0),
                this->linksAccess[index]->StatQueue(1, 1)
                );
        }

        fclose(out);
    }

        // Core links

    sprintf(fileName, "clink_%s_%u_%u.stat", this->name, this->topologyNumber, this->numChannelsMcast);
    if(FILE_OPEN(out, fileName, "w"))  printf("\nCannot write to file %s.", fileName);
    else
    {
        for(__uint32 index = 0; index < this->topology->Edges(); index++)
        {
            fprintf(out, "%u %.0lf %.0lf %.9lf %.9lf %.9lf %.9lf %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %.9lf %.9lf %.9lf %.9lf\n",
                index,
                this->linksCore[index]->Bandwidth(0),
                this->linksCore[index]->Bandwidth(1),
                this->linksCore[index]->StatUtilization(0, 0),
                this->linksCore[index]->StatUtilization(0, 1),
                this->linksCore[index]->StatUtilization(1, 0),
                this->linksCore[index]->StatUtilization(1, 1),
                this->linksCore[index]->StatPackets(0, 0),
                this->linksCore[index]->StatDiscard(0, 0),
                this->linksCore[index]->StatPackets(0, 1),
                this->linksCore[index]->StatDiscard(0, 1),
                this->linksCore[index]->StatPackets(1, 0),
                this->linksCore[index]->StatDiscard(1, 0),
                this->linksCore[index]->StatPackets(1, 1),
                this->linksCore[index]->StatDiscard(1, 1),
                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->linksCore[index]->StatQueue(0, 0),
                this->linksCore[index]->StatQueue(0, 1),
                this->linksCore[index]->StatQueue(1, 0),
                this->linksCore[index]->StatQueue(1, 1)
                );
        }

        fclose(out);
    }

#ifdef MULTICAST
    // Multicast statistics
    sprintf(fileName, "multicast_%s_%u.out", this->name, this->topologyNumber);
    if(FILE_OPEN(out, fileName, "w")) printf("\nCannot write to file %s.", fileName);
    else
    {
        for(__uint32 index = 0; index < this->multicast->Groups(); index++)
        {
            (*this->multicast)[index]->Finalize(this->sim->Time());
            
            fprintf(out, "%u %.9lf %.9lf\n", index, (*this->multicast)[index]->SizeCore(), (*this->multicast)[index]->SizeEdge());
        }
        fclose(out);
    }
#endif

#endif

    /*
     * 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 server
    if(this->server) delete this->server;

    // 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;
    }

    // Delete link server
    if(this->linkServer) delete this->linkServer;
}

int CModelPush::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()];
}

CChannel* CModelPush::Channel(__uint32 index)
{
    assert(index < this->numChannelsMcast + this->numChannelsUcast);

    return (index < this->numChannelsMcast)?&this->channelsMcast[index]:&this->channelsUcast[index - this->numChannelsMcast];
}

#ifdef MULTICAST

void CModelPush::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 CModelPush::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