TMBoostDD Class Reference

#include <TMBoostDD.h>

Inheritance diagram for TMBoostDD:

List of all members.

Public Member Functions
	TMBoostDD ()
virtual	~TMBoostDD ()
virtual void	handleUpdate (TMPacket *pkt)
virtual void	write2gml (string fname)
virtual void	handleLinkStateUpdate (LSMPacket *pkt)
virtual void	handleMetaDataUpdate (MetaDataPacket *pkt)
virtual void	calcFIDsFromTM_2_Nodes ()
bool	getReverseEdge (Edge e, Edge &rev)
Protected Member Functions
virtual void	initialize (int stage)
virtual int	numInitStages () const
virtual void	finish ()
virtual void	initializeGraph ()
virtual Vertex	getVertex (string nodeid)
virtual bool	vertexExists (string nodeid)
virtual Edge	getEdge (string lid, bool &found)
virtual bool	setEdgeWeights (string IIID)
virtual string	getFIDFromBoostResult_rec (Vertex src, Vertex dst, vector< Vertex > pre)
virtual vector< string >	getPathFromBoostResult_rec (Vertex src, Vertex dst, vector< Vertex > pre)
virtual string	getFIDFromPath (vector< string > path)
virtual double	getWeightFromBoostResult_rec (Vertex src, Vertex dst, vector< Vertex > pre)
virtual void	eliminateWeights_rec (Vertex src, Vertex dst, vector< Vertex > pre, InfoItems::iterator it)
virtual void	pathCalculation ()
Protected Attributes
GraphWrapper< VertexProp, EdgeProp >	g
	The graph representation.
weightMap	weightmap
	I don't think it is used in this version.
Private Types
typedef GraphWrapper < VertexProp, EdgeProp > ::Vertex	Vertex
typedef GraphWrapper < VertexProp, EdgeProp >::Edge	Edge
typedef GraphWrapper < VertexProp, EdgeProp > ::EdgePair	EdgePair
typedef GraphWrapper < VertexProp, EdgeProp > ::Graph	Graph
typedef property_map< Graph, edge_weight_t >::type	weightMap
typedef std::vector< Vertex >	predecessormap
typedef std::vector< double >	distancemap

---

Detailed Description

Extended Boost Topology Manager Application. Performs a Destination-Driven shortest path calculation and assigned each Subscriber to the closest Publisher.

---

Member Typedef Documentation

typedef std::vector<double> TMBoostDD::distancemap [private]

typedef GraphWrapper<VertexProp,EdgeProp>::Edge TMBoostDD::Edge [private]

typedef GraphWrapper<VertexProp,EdgeProp>::EdgePair TMBoostDD::EdgePair [private]

typedef GraphWrapper<VertexProp,EdgeProp>::Graph TMBoostDD::Graph [private]

typedef std::vector<Vertex> TMBoostDD::predecessormap [private]

typedef GraphWrapper<VertexProp,EdgeProp>::Vertex TMBoostDD::Vertex [private]

typedef property_map<Graph, edge_weight_t>::type TMBoostDD::weightMap [private]

---

Constructor & Destructor Documentation

TMBoostDD::TMBoostDD

(

)

Boost Topology Manager Interface class constructor.

{

}

TMBoostDD::~TMBoostDD

(

)

[virtual]

Boost Topology Manager Interface class destructor.

{

}

---

Member Function Documentation

void TMBoostDD::calcFIDsFromTM_2_Nodes

(

)

[virtual]

Calculates the FID from the Topology Manager to every node of the network according to the shortest path.

                                      {
  // predecessor_map
  std::vector<Vertex> p(g.getVertexCount());
  // distance_map
  std::vector<double> d(g.getVertexCount());

  Vertex src = getVertex(myNodeId);

  //XXX::The Topology manager is not path of the network in the simulation! Be carefull!!!
  dijkstra_shortest_paths(g.getGraph(), src, predecessor_map(&p[0]).distance_map(&d[0]));
  // For all nodes - update!
  for (TMtoNodes::iterator it = tm2nodes.begin(); it!=tm2nodes.end(); ++it){
    
    Vertex dst = getVertex(it->first);
    it->second = lidOR(getFIDFromBoostResult_rec(src, dst, p), getNodeInternalLID(it->first));
  }
  // WoW Easier than it sounds!
}

void TMBoostDD::eliminateWeights_rec	(	Vertex	src,
		Vertex	dst,
		vector< Vertex >	pre,
		InfoItems::iterator	it
	)			[protected, virtual]

Visit the predecessor map and turn the weights of the shortest path links to zero. RECURSIVE

                                                                                                     {
        Vertex pre_v = pre[dst];

        // Terminal Condition! Add node it
        if (dst == src) return;

        // Get the edge for pre_v - dst. NOT THE OPPOSITE!
        std::pair<Edge, bool> edge_res= g.getEdge(pre_v,dst);
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOR pre_v - dst: Check topology initializer, THIS SHOULD NEVER HAPPEN");
                return;
        }

        //Get the edge
        Edge e = edge_res.first;

        //std::cout << "Link " << g.properties(revedge.first.m_source).nodeid << "-" << g.properties(revedge.first.m_target).nodeid << " has rate " << g.properties(revedge.first).status[QoS_USEDRATE] << " with weight " << g.properties(e).weight << endl;

        //Check if the information item already passes from this link
        if(g.properties(e).weight!=0) {
                //Assign the link to zero, for future subscribers to use
                g.properties(e).weight=0;

                //Get the reverse edge
                Edge rev;
                if(!getReverseEdge(e,rev))
                        return;

                //Assign the selected link with the additional traffic of the new flow if not already assigned
                QoSList param = g.properties(rev).status;

                //If the necessary parameters exist
                if( param.find(QoS_USEDRATE)!=param.end() && it->second.metadata.find(QoS_BW_M)!=it->second.metadata.end() ) {
                        //Add the expected bitrate of the newly assigned Information Item, to the link's used rate
                        //std::cout << "Link " << g.properties(edge_rev.first.m_source).nodeid << "-" << g.properties(edge_rev.first.m_target).nodeid << " has rate " << param.find(QoS_USEDRATE)->second << endl;
                        g.properties(rev).status[QoS_USEDRATE] += it->second.metadata.find(QoS_BW_M)->second;
                        //std::cout << "Now it has rate: " << g.properties(edge_rev.first).status[QoS_USEDRATE] << " with QoS_BW_M " << it->second.metadata.find(QoS_BW_M)->second << endl;
                }
                else {
                        //Else print a warning
                        ev << "*** TM WARNING: QoS_USEDRATE/QoS_BW_M parameters not available in link weight assignment of routing calculation process." << endl;
                }
        }

        // Get all the previous recursively
        eliminateWeights_rec(src,pre_v,pre,it);
}

void TMBoostDD::finish

(

)

[protected, virtual]

The finish function of the Boost Topology Manager.

Reimplemented from TMInterface.

{
        TMInterface::finish();

        //Clear Graph
        g.clear();
}

TMBoostDD::Edge TMBoostDD::getEdge	(	string	lid,
		bool &	found
	)			[protected, virtual]

Get an edge based on the LID...

                                                        {
        GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei) {
                if (g.properties(*ei).lid.compare(lid)==0) {
                        found=true;
                        return *ei;
                }
        }
        found=false;
        // ?
        return Edge();
}

string TMBoostDD::getFIDFromBoostResult_rec	(	Vertex	src,
		Vertex	dst,
		vector< Vertex >	pre
	)			[protected, virtual]

Visit the predecessor map and calculate FID for a single destination/sub. RECURSIVE

                                                                                     {
 
        Vertex pre_v = pre[dst];

        // Terminal Condition! Add node it
        if (dst == src) return "";

        // Get the edge for pre_v - dst. NOT THE OPPOSITE!
        std::pair<Edge, bool> edge_res= g.getEdge(pre_v,dst);
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOR pre_v - dst: Check topology initializer, THIS SHOULD NEVER HAPPEN");
        return "";
        }

        Edge e = edge_res.first;

        // Get all the previous recursively
        string newfid=getFIDFromBoostResult_rec(src,pre_v,pre);

        newfid=lidOR(newfid,g.properties(e).lid);

        return newfid;
}

string TMBoostDD::getFIDFromPath

(

vector< string >

path

)

[protected, virtual]

                                                    {
        //The variable to OR the various lids
        string newfid="";

        //For all elements of the path, calculate the FID
        for(uint i=0;i<path.size();i++) {
                newfid=lidOR(newfid,path[i]);
        }

        return newfid;
}

vector< string > TMBoostDD::getPathFromBoostResult_rec	(	Vertex	src,
		Vertex	dst,
		vector< Vertex >	pre
	)			[protected, virtual]

Visit the predecessor map and find out all the path lids. RECURSIVE

                                                                                               {
        //Find the next hop
        Vertex pre_v = pre[dst];
        //The variable to preserve the path lid so far found
        vector<string> path;

        // Terminal Condition! Add node it
        if (dst == src) return path;

        // Get the edge for pre_v - dst. NOT THE OPPOSITE!
        std::pair<Edge, bool> edge_res= g.getEdge(dst,pre_v);
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOR pre_v - dst: Check topology initializer, THIS SHOULD NEVER HAPPEN");
                return path;
        }

        Edge e = edge_res.first;

        // Get all the previous recursively
        path=getPathFromBoostResult_rec(src,pre_v,pre);

        path.push_back(g.properties(e).lid);

        return path;
}

bool TMBoostDD::getReverseEdge	(	Edge	e,
		Edge &	rev
	)

Given a network link, it return the reverse one. Useful function because of the destination driven approach, followed in this algorithm.

                                                {
        //Reverse the given edge's end points
        std::pair<Edge, bool> edge_res= g.getEdge(e.m_target,e.m_source);

        //Check if edge exists
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOUND WHILE REVERSING: Check topology initializer, THIS SHOULD NEVER HAPPEN");
                return false;
        }

        //Get the edge
        rev = edge_res.first;

        return true;
}

TMBoostDD::Vertex TMBoostDD::getVertex

(

string

nodeid

)

[protected, virtual]

Get a vertex by nodeid, it returns UINT_MAX in case that the vertex is not found!

                                                 {

        GraphWrapper<VertexProp,EdgeProp>::vertex_iterator vi, vend;
        for (tie(vi, vend) = g.getVertices(); vi != vend; ++vi) {
          if (g.properties(*vi).nodeid.compare(nodeid)==0) return *vi;
        }

        return UINT_MAX;

}

double TMBoostDD::getWeightFromBoostResult_rec	(	Vertex	src,
		Vertex	dst,
		vector< Vertex >	pre
	)			[protected, virtual]

Visit the predecessor map and calculate path weight for a single destination/sub. RECURSIVE

                                                                                        {

        Vertex pre_v = pre[dst];

        // Terminal Condition! Add node it
        if (dst == src) return(0);

        // Get the edge for pre_v - dst. NOT THE OPPOSITE!
        std::pair<Edge, bool> edge_res= g.getEdge(pre_v,dst);
        if (edge_res.second == false){
                opp_error("*** NO EDGE FOR pre_v - dst: Check topology initializer, THIS SHOULD NEVER HAPPEN");
        return(0);
        }

        Edge e = edge_res.first;

        // Get all the previous recursively
        double weight=getWeightFromBoostResult_rec(src,pre_v,pre);

        weight+=g.properties(e).weight;

        return weight;
}

void TMBoostDD::handleLinkStateUpdate

(

LSMPacket *

pkt

)

[virtual]

Handles the packets carrying link state status information. -- DUMMY

Implements TMInterface.

                                                   {
  ev << " - TMBoostDD::handleLinkStateUpdate" << endl;
  
  int replen = pkt->getRepLen();
  bool found=false;
  for (int i=0; i<replen; i++){
    Edge e = getEdge(pkt->getLid(i),found);
    if (!found){
        opp_error("TMBoostDD: LID NOT FOUND!: ");
        continue;
    }
    g.properties(e).status = pkt->getLinkStatus(i);
  }
  
  //write2gml("/tmp/top.graphml");
}

void TMBoostDD::handleMetaDataUpdate

(

MetaDataPacket *

pkt

)

[virtual]

Handles the MetaData packets received directly from the publishers.

Implements TMInterface.

                                                        {
        updateInformationItemMetaData(pkt);
}

void TMBoostDD::handleUpdate

(

TMPacket *

pkt

)

[virtual]

Handle packet function for Click Modular Router. Called by the handleMessage() function of the Omnet++ module.

Implements TMInterface.

                                            {
  
  ev << " - TMBoostDD::handleUpdate" << endl;

  //Update the Information Items in the Topology Manager and return the Information Item ID in a hex form
  string hex_id = updateInformationItems(tmpkt);

  //Call the path calculation function for all changes Information Items
  // ------------------------------------- //
  // ----- PATH CALCULATION FUNCTION ----- //
  // ------------------------------------- //
  pathCalculation();
  // ------------------------------------- //

  // Here we should be done! Update all the publishers with new FIDs
  updateAllThePublishers();
}

void TMBoostDD::initialize

(

int

stage

)

[protected, virtual]

Initialization function

Reimplemented from TMInterface.

                                    {

        TMInterface::initialize(stage);

        //The TMInterace Initialized at stage 2. To be safe
        //let's initialize on stage later.
        if(stage==3) {
                // At this stage the Topology Manager configuration is fed to Boost++
                initializeGraph();
                //write2gml("InitialGraph.gml");
        }
}

void TMBoostDD::initializeGraph

(

)

[protected, virtual]

Initialize BGraph from topology

                               {
  
        for (uint i=0; i<topology.size(); ++i){
                // Check n Add source
                Vertex src = getVertex(topology[i].src);
                if (src == UINT_MAX){
                        VertexProp vp;
                        vp.nodeid=topology[i].src;
                        src=g.addVertex(vp);
                }

                // Check n Add destination
                Vertex dst = getVertex(topology[i].dst);
                if (dst == UINT_MAX){
                        VertexProp vp;
                        vp.nodeid=topology[i].dst;
                        dst=g.addVertex(vp);
                }

                // NOTE: Avoid LOOPs !!
                if (dst==src) continue;

                // Add edge
                EdgeProp ep;
                ep.weight = 1; // FIXME:TODO Initial weight!
                ep.lid = topology[i].lid;
                g.addEdge(src,dst,ep);
        }

        //Setting the weights map
        weightmap = get(edge_weight, g.getGraph());
}

virtual int TMBoostDD::numInitStages

(

)

const [inline, protected, virtual]

Returns the number of initialization stages.

Reimplemented from TMInterface.

{return 5;};

void TMBoostDD::pathCalculation

(

)

[protected, virtual]

Call the path calculation function for the requested Information Item, as well as for all changed Information Items

                                {
  //std::cout << endl << simTime() << endl;
  ev << " - TMBoostDD::pathCalculation" << endl;

  // Search all the IItems and run algorithm for the changed
  for (InfoItems::iterator it = ii.begin(); it!=ii.end(); ++it) {
    
    ev << "   - Checking: " << it->first << " status: " << it->second.ii_updated << endl;
    // Not changed... continue
    if (!it->second.ii_updated) continue;

    IIDetails  *itd = &it->second;
    // Check that we have publishers
    if (itd->pubs.size() == 0){
      ev << "   - SHIT: No Publishers for item " << it->first << "???" << endl;
      ev << "    - What should i do??? " << endl;
      itd->ii_updated = false;
      continue;
    }
    
    // Check that we have subscribers
    if (itd->subs.size() == 0){
      ev << "   - No Subscribers for item " << it->first << endl;
      // Cancel the transmission
      itd->ii_updated = false;
      // Clear fids for all publishers of the Information Item
          for(uint i=0;i<itd->pubs.size();i++) {
                  itd->pubs[i].fid = "";
                  itd->pubs[i].fid_updated = true;
          }
      continue;
    }

    //Set the weight-map weight for the Dijkstra operation. If the II was not found, then continue to the next one
        if(!setEdgeWeights(it->first))
                  continue;

        //Save the value of weight for all of the edges and save in order to replace them after the LID calculation process is finished
        GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei)
                  weightmap[*ei] = g.properties(*ei).weight;

    // Clear fids and paths for all publishers of the Information Item
    for(uint i=0;i<itd->pubs.size();i++) {
        //Clear fids
        itd->pubs[i].fid = "";
        //Clear the link paths
        itd->pubs[i].paths.empty();
        //Update the fid_update flag for the selected publisher
        itd->pubs[i].fid_updated=true;
    }

    /*
         * The weight vector collects the link weight of every path from the examined subscriber to
         * every publisher. Therefore for it has the following format:
         *
         *                                                    Number of Pubs
         *                                      |-----------------------------------------|
         *      Number of Subs  |P1-S*|P2-S*|P3-S*|P4-S*| ... | ... | ... |
         *                                      |-----------------------------------------|
         */

    //Vector for counting the weight of the path for each publisher source
    std::vector<double> weight_vector( itd->pubs.size() );

    //std::cout << "For Information Item " << it->first << endl;

        // ---------------------------------------------------------------------------------- //
    // -------- Find path from every subscriber and check who is the best one.    ------- //
        // -------- This is a Destination-Driven algorithm, that additionally assigns ------- //
        // -------- the subscribers to the source, instead of only calculating paths. ------- //
    // ---------------------------------------------------------------------------------- //
    for(uint sindex=0;sindex<itd->subs.size();sindex++) {
    
                // Each subscriber is checked, and its shortest path will be calculated
                Vertex dst = getVertex(itd->subs[sindex]);

                // Sanity Check
                if (dst == UINT_MAX){
                  opp_error("*** What THE HELL: Check your topology parser, NO VERTEX FOR SUBSCRIBER ??? ");
                  continue;
                }

                // Yay... Do the job...
                // predecessor_map
                std::vector<Vertex> p(g.getVertexCount());
                // distance_map
                std::vector<double> d(g.getVertexCount());

                ev << "   - Going for item " << it->first << " subscribed by vertex " << dst << endl;

                dijkstra_shortest_paths(g.getGraph(), dst, predecessor_map(&p[0]).distance_map(&d[0]));

                //Compute the weight for each of the shortest paths. NOTE THAT THE PATH IS REVERSELY CALCULATED
                //FROM THE DESTINATION TO THE SOUTCE (DESTINATION-DRIVEN)!
                for (uint i=0; i<itd->pubs.size(); ++i){
                        Vertex tempsrc = getVertex(itd->pubs[i].pub);
                        weight_vector[i]=getWeightFromBoostResult_rec(dst, tempsrc, p);
                }

                //Find the shortest path with the least weight and set its weight to zero for the
                //next path calculations to use it.
                int minPos=std::min_element(weight_vector.begin(),weight_vector.end())-weight_vector.begin();

                //Select as src the best found publisher
                Vertex src = getVertex(itd->pubs[minPos].pub);

                //For all edges, compute their weights according to the QoS requirements of the Information Item
                /*GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
                for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei) {

                        //THE WEIGHTS SHOULD BE PLACED IN REVERSE BECAUSE THE ROUTE FINDING ALGORITHM IS DESTINATION DRIVEN
                        //THIS IS WHY THE EDGE FOUND WILL BE REPLACED WITH THE SAME LINK BUT WITH REVERSED END-POINTS!
                        Edge rev = *ei;
                        std::pair<Edge, bool> edge_res= g.getEdge(rev.m_target,rev.m_source);
                        if (edge_res.second == false){
                                opp_error("*** NO EDGE FOUND WHILE REVERSING: Check topology initializer, THIS SHOULD NEVER HAPPEN");
                                return;
                        }

                        //Get the edge
                        Edge e = edge_res.first;

                        //GET THE PARAMETERS OF THE INITIAL LINK, IN ORDER TO COMPUTE THE PROPER VALUES FOR THE REVERSE
                        QoSList param=g.properties(*ei).status;

                        std::cout << g.properties(rev.m_source).nodeid << "-" << g.properties(rev.m_target).nodeid << " has rate " << param.find(QoS_USEDRATE)->second << " and QoS_BW_M: " << it->second.metadata.find(QoS_BW_M)->second << endl;
                }*/

                //Set the weights of the shortest path edges to zero, so that they will preferred by future
                //path calculations.
                eliminateWeights_rec(dst, src, p, it);

                //std::cout << simTime() << endl;
                //std::cout << itd->subs[sindex] << " goes to " << itd->pubs[minPos].pub << " with weight " << weight_vector[minPos] << endl;

                // ---------------------------------------------------------- //
                // ------------- FID Calculation Process Starts ------------- //
                // ---------------------------------------------------------- //
                //Get the path lids from the specified source to the specified destination
                vector<string> boostPath=getPathFromBoostResult_rec(dst, src, p);
                itd->pubs[minPos].paths.insert(itd->pubs[minPos].paths.end(),boostPath.begin(),boostPath.end());
                // Get FID src to dst
                itd->pubs[minPos].fid = lidOR(itd->pubs[minPos].fid, getFIDFromPath(itd->pubs[minPos].paths));
                // Add the dst node internal LID! is needed
                itd->pubs[minPos].fid = lidOR(itd->pubs[minPos].fid, getNodeInternalLID(itd->subs[sindex]));
                // ---------------------------------------------------------- //
                // ------------ FID Calculation Process Finishes ------------ //
                // ---------------------------------------------------------- //
    }
    //std::cout << endl;

    // Update Flags
        //itd->fid_updated = true; // NEWFID
        itd->ii_updated = false; // UNMODIFIED SINCE LAST RUN

        //Restore the edge weights
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei)
                g.properties(*ei).weight = weightmap[*ei];
  }

  ev << " - TMBoostDD::pathCalculation - completed" << endl;
}

bool TMBoostDD::setEdgeWeights

(

string

IIID

)

[protected, virtual]

Set the weight for the specified edge, according to the report sent by the network modules.

                                          {

        //Find the Information Item, in the list of all the known ones
        InfoItems::iterator it=ii.find(IIID);

        if(it==ii.end()) {
                ev << "Unknown Information Item requested in TM, " << endl;
                return(false);
        }

        //For all edges, compute their weights according to the QoS requirements of the Information Item
        GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei) {

                //THE WEIGHTS SHOULD BE PLACED IN REVERSE BECAUSE THE ROUTE FINDING ALGORITHM IS DESTINATION DRIVEN
                //THIS IS WHY THE EDGE FOUND WILL BE REPLACED WITH THE SAME LINK BUT WITH REVERSED END-POINTS!
                //Get the reverse edge
                Edge e;
                if(!getReverseEdge(*ei,e))
                        continue;

                //GET THE PARAMETERS OF THE INITIAL LINK, IN ORDER TO COMPUTE THE PROPER VALUES FOR THE REVERSE
                QoSList param=g.properties(*ei).status;

                //Make sure we have all the necessary QoS parameters for the weight computation
                if(param.find(QoS_USEDRATE)!=param.end() && param.find(QoS_CAPACITY_M)!=param.end() /*&&  param.find(QoS_COST)!=param.end()*/ &&
                   it->second.metadata.find(QoS_BW_M)!=it->second.metadata.end() && it->second.metadata.find(QoS_FLOW)!=it->second.metadata.end()) {
                        //std::cout << "Setting "<< g.properties(rev.m_source).nodeid << "-" << g.properties(rev.m_target).nodeid << " has rate " << param.find(QoS_USEDRATE)->second << " and QoS_BW_M: " << it->second.metadata.find(QoS_BW_M)->second << endl;

                        //If the link is empty
                        if(param.find(QoS_USEDRATE)->second==0) {
                                g.properties(e).weight = 1;
                                weightmap[e]=g.properties(e).weight;
                        }
                        //If there are any links that have space for the new stream calculate with a weight given by the selected formula
                        else if( (param.find(QoS_CAPACITY_M)->second - param.find(QoS_USEDRATE)->second) > it->second.metadata.find(QoS_BW_M)->second) {
                                g.properties(e).weight = (double)pow((double)(param.find(QoS_CAPACITY_M)->second - param.find(QoS_USEDRATE)->second)/param.find(QoS_CAPACITY_M)->second,3);
                                weightmap[e]=g.properties(e).weight;
                        }
                        //If the link is full...
                        else {
                                //Check if the Information Item is currently passing through the examined link
                                bool pass=false;
                                for(uint i=0;i<it->second.pubs.size();i++) {
                                        if(find(it->second.pubs[i].paths.begin(),it->second.pubs[i].paths.end(),g.properties(e).lid) != it->second.pubs[i].paths.end())
                                                pass=true;
                                }

                                //If it is passing calculate with a weight given by the selected formula
                                if(pass) {
                                        g.properties(e).weight = (double)pow((double)(param.find(QoS_CAPACITY_M)->second - param.find(QoS_USEDRATE)->second)/param.find(QoS_CAPACITY_M)->second,3);
                                        weightmap[e]=g.properties(e).weight;
                                }
                                //Otherwise give it a big weight
                                else {
                                        g.properties(e).weight = 10;
                                        weightmap[e]=g.properties(e).weight;
                                }
                        }
                }
                //Else there are no statistic for this link, so give a big weight
                else {
                        g.properties(e).weight = 10;
                        weightmap[e]=g.properties(e).weight;
                }
        }
        //std::cout << endl;
        return(true);
}

bool TMBoostDD::vertexExists

(

string

nodeid

)

[protected, virtual]

Check that a vertex exists by nodeid

                                         {
        return (!getVertex(nodeid) == UINT_MAX);
}

void TMBoostDD::write2gml

(

string

fname

)

[virtual]

Extracts the network graph in a xml format, proving the ability of monitoring the network on runtime.

                                     {
        // Chinese Language with mixed Greek follows!
        std::ofstream fout(fname.c_str());
        if (!fout) return;

        string top="<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?> \n\
        <graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:y=\"http://www.yworks.com/xml/graphml\" xmlns:yed=\"http://www.yworks.com/xml/yed/3\" xsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd\"> \n\
        <key id=\"key0\" for=\"node\" attr.name=\"id\" attr.type=\"string\" />\n\
        <key id=\"key1\" for=\"edge\" attr.name=\"weight\" attr.type=\"int\" /> \n\
        <key id=\"key2\" for=\"edge\" attr.name=\"lid\" attr.type=\"string\" />\n\
        <key for=\"edge\" id=\"d12\" yfiles.type=\"edgegraphics\"/> \n\
        <key for=\"node\" id=\"d7\" yfiles.type=\"nodegraphics\"/>\n\
        <graph id=\"G\" edgedefault=\"directed\" parse.nodeids=\"canonical\" parse.edgeids=\"canonical\" parse.order=\"nodesfirst\">\n";

        fout.write(top.c_str(), top.length());

        GraphWrapper<VertexProp,EdgeProp>::vertex_iterator vi, vend;
        for (tie(vi, vend) = g.getVertices(); vi != vend; ++vi) {
                VertexProp p = g.properties(*vi);
                string nodestr="<node id=\""+p.nodeid+"\">\n";
                nodestr+=" <data key=\"key0\">"+p.nodeid+"</data>\n";
                nodestr+=" <data key=\"d7\">\n\
                  <y:GenericNode configuration=\"ShinyPlateNode\">\n\
                   <y:NodeLabel alignment=\"center\" autoSizePolicy=\"content\" fontFamily=\"Dialog\" fontSize=\"12\" fontStyle=\"plain\" hasBackgroundColor=\"false\" hasLineColor=\"false\" height=\"4.0\" modelName=\"internal\" modelPosition=\"s\" textColor=\"#000000\" visible=\"true\" width=\"4.0\" >"+p.nodeid+"</y:NodeLabel>\n\
                  </y:GenericNode>\n\
                 </data>\n";
                nodestr+="</node>\n";

                fout.write(nodestr.c_str(), nodestr.length());
        }

        int count=0;
        GraphWrapper<VertexProp,EdgeProp>::edge_iterator ei, eend;
        for (tie(ei, eend) = g.getEdges(); ei != eend; ++ei) {
                EdgeProp p = g.properties(*ei);
                stringstream ss;
                ss<<"e"<<count;
                count++;
                string lid=chararray_to_bin(p.lid);

                string edgestr = "<edge id=\""+ss.str()+"\" source=\""+g.getSourceProp(*ei).nodeid+
                                  "\" target=\""+g.getTargetProp(*ei).nodeid+"\">\n";
                ss.clear();
                ss.str(std::string());
                ss<<p.weight;
                edgestr += " <data key=\"key1\">"+ss.str()+"</data>\n";
                edgestr += " <data key=\"key2\">"+lid+"</data>\n";
                edgestr+=" <data key=\"d12\">\n\
                  <y:PolyLineEdge>\n\
                        <y:Arrows source=\"none\" target=\"delta\"/>\n\
                  </y:PolyLineEdge>\n\
                 </data>\n";
                edgestr += "</edge>\n";
                fout.write(edgestr.c_str(), edgestr.length());
        }

        string bottom=" </graph>\n</graphml>";
        fout.write(bottom.c_str(), bottom.length());
        fout.close();
}

---

Member Data Documentation

GraphWrapper<VertexProp, EdgeProp> TMBoostDD::g [protected]

The graph representation.

weightMap TMBoostDD::weightmap [protected]

I don't think it is used in this version.

---

The documentation for this class was generated from the following files:

• TMBoostDD.h
• TMBoostDD.cc