rocketfuel-map-reader.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
// Based on the code by Hajime Tazaki <tazaki@sfc.wide.ad.jp>
 
#ifndef ROCKETFUEL_MAP_READER_H
#define ROCKETFUEL_MAP_READER_H
 
#include "annotated-topology-reader.hpp"
 
#include "ns3/net-device-container.h"
#include "ns3/data-rate.h"
 
#include <set>
#include <boost/graph/adjacency_list.hpp>
 
using namespace std;
 
namespace ns3 {
 
struct RocketfuelParams {
  double averageRtt;
  int clientNodeDegrees;
 
  // parameters for links Backbone <->Backbone
  string minb2bBandwidth;
  string minb2bDelay;
 
  string maxb2bBandwidth;
  string maxb2bDelay;
 
  // parameters for links Backbone<->Gateway and Gateway <-> Gateway
  string minb2gBandwidth;
  string minb2gDelay;
 
  string maxb2gBandwidth;
  string maxb2gDelay;
 
  // parameters for links Gateway <-> Customer
  string ming2cBandwidth;
  string ming2cDelay;
 
  string maxg2cBandwidth;
  string maxg2cDelay;
};
 
class RocketfuelMapReader : public AnnotatedTopologyReader {
public:
  RocketfuelMapReader(const std::string& path = "", double scale = 1.0,
                      const string& referenceOspfRate = "100Mbps");
  virtual ~RocketfuelMapReader();
 
  virtual NodeContainer
  Read();
 
  virtual NodeContainer
  Read(RocketfuelParams params, bool keepOneComponent = true, bool connectBackbones = true);
 
  const NodeContainer&
  GetBackboneRouters() const;
 
  const NodeContainer&
  GetGatewayRouters() const;
 
  const NodeContainer&
  GetCustomerRouters() const;
 
  virtual void
  SaveTopology(const std::string& file);
 
  virtual void
  SaveGraphviz(const std::string& file);
 
private:
  RocketfuelMapReader(const RocketfuelMapReader&);
  RocketfuelMapReader&
  operator=(const RocketfuelMapReader&);
 
  // NodeContainer
  void
  GenerateFromMapsFile(int argc, char* argv[]);
 
  void
  CreateLink(string nodeName1, string nodeName2, double averageRtt, const string& minBw,
             const string& maxBw, const string& minDelay, const string& maxDelay);
  void
  KeepOnlyBiggestConnectedComponent();
 
  void
  AssignClients(uint32_t clientDegree, uint32_t gwDegree);
 
  void
  ConnectBackboneRouters();
 
private:
  Ptr<UniformRandomVariable> m_randVar;
 
  NodeContainer m_backboneRouters;
  NodeContainer m_gatewayRouters;
  NodeContainer m_customerRouters;
 
  typedef boost::adjacency_list_traits<boost::setS, boost::setS, boost::undirectedS> Traits;
 
  enum node_type_t { UNKNOWN = 0, CLIENT = 1, GATEWAY = 2, BACKBONE = 3 };
 
  typedef boost::
    property<boost::vertex_name_t, std::string,
             boost::property<boost::vertex_index_t, uint32_t,
                             boost::property<boost::vertex_rank_t, node_type_t,
                                             boost::property<boost::vertex_color_t, std::string>>>>
      nodeProperty;
 
  typedef boost::no_property edgeProperty;
 
  typedef boost::adjacency_list<boost::setS, boost::setS, boost::undirectedS, nodeProperty,
                                edgeProperty> Graph;
 
  typedef map<string, Traits::vertex_descriptor> node_map_t;
  node_map_t m_graphNodes;
 
  Graph m_graph;
  uint32_t m_maxNodeId;
 
  const DataRate m_referenceOspfRate; // reference rate of OSPF metric calculation
 
private:
  void
  assignGw(Traits::vertex_descriptor vertex, uint32_t degree, node_type_t nodeType);
}; // end class RocketfuelMapReader
 
}  // end namespace ns3
 
#endif /* ROCKETFUEL_MAP_READER_H */