src/surf/surf_routing.hpp

   1 /* Copyright (c) 2013-2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #ifndef NETWORK_ROUTING_HPP_
   8 #define NETWORK_ROUTING_HPP_
   9
  10 #include <xbt/base.h>
  11 #include <xbt/signal.hpp>
  12
  13 #include "surf_interface.hpp"
  14 #include "src/surf/xml/platf_private.hpp" // FIXME: including this here is pure madness. KILKILKIL XML.
  15 #include <float.h>
  16
  17 #include <vector>
  18 #include <map>
  19
  20 SG_BEGIN_DECL()
  21 XBT_PUBLIC(void) routing_model_create( void *loopback);
  22 XBT_PRIVATE xbt_node_t new_xbt_graph_node (xbt_graph_t graph, const char *name, xbt_dict_t nodes);
  23 XBT_PRIVATE xbt_edge_t new_xbt_graph_edge (xbt_graph_t graph, xbt_node_t s, xbt_node_t d, xbt_dict_t edges);
  24 SG_END_DECL()
  25
  26 namespace simgrid {
  27 namespace surf {
  28
  29 /***********
  30  * Classes *
  31  ***********/
  32
  33 class As;
  34 class XBT_PRIVATE RoutingModelDescription;
  35 class XBT_PRIVATE Onelink;
  36 class RoutingPlatf;
  37
  38 /** @ingroup SURF_routing_interface
  39  * @brief Network cards are the vertices in the graph representing the network, used to compute paths between nodes.
  40  *
  41  * @details This represents a position in the network. One can route information between two netcards
  42  */
  43 class NetCard {
  44 public:
  45   virtual ~NetCard(){};
  46   virtual int id()=0; // Our rank in the vertices_ array of our containing AS.
  47   virtual void setId(int id)=0;
  48   virtual char *name()=0;
  49   virtual As *containingAS()=0; // This is the AS in which I am
  50   virtual e_surf_network_element_type_t getRcType()=0;
  51 };
  52
  53 /** @ingroup SURF_routing_interface
  54  * @brief Network Autonomous System (AS)
  55  * @details [TODO]
  56  */
  57 class As {
  58 public:
  59   As(const char*name);
  60   /** @brief Close that AS: no more content can be added to it */
  61   virtual void Seal();
  62   virtual ~As();
  63
  64   e_surf_routing_hierarchy_t hierarchy_ = SURF_ROUTING_NULL;
  65   xbt_dynar_t upDownLinks = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
  66
  67   char *name_ = nullptr;
  68   NetCard *netcard_ = nullptr; // Our representative in the father AS
  69   As *father_ = nullptr;
  70   xbt_dict_t sons_ = xbt_dict_new_homogeneous(NULL); // sub-ASes
  71   xbt_dynar_t vertices_ = xbt_dynar_new(sizeof(char*),NULL); // our content, as known to our graph routing algorithm (maps vertexId -> vertex)
  72
  73 private:
  74   bool sealed_ = false; // We cannot add more content when sealed
  75   std::map<std::string, std::vector<Link*>*> *bypassRoutes_ = nullptr;
  76
  77 public:
  78   /**
  79    * @brief Probe the routing path between two points
  80    *
  81    * The networking model uses this function when creating a communication
  82    * to retrieve both the list of links that the create communication will use,
  83    * and the summed latency that these links represent.
  84    *
  85    * The network could recompute the latency by itself from the list, but it would
  86    * require an additional link set traversal. This operation being on the critical
  87    * path of SimGrid, the routing computes the latency in behalf of the network.
  88    *
  89    * Things are rather complex here because we have to find the path from ASes to ASes, and within each.
  90    * In addition, the different ASes may use differing routing models.
  91    * Some ASes may be routed in full, others may have only some connection information and use a shortest path on top of that, and so on.
  92    * Some ASes may even not have any predefined links and use only coordinate informations to compute the latency.
  93    *
  94    * So, the path is constructed recursively, with each traversed AS adding its information to the set.
  95    * The algorithm for that is explained in http://hal.inria.fr/hal-00650233/
  96    *
  97    * @param src Initial point of the routing path
  98    * @param dst Final point of the routing path
  99    * @param into Container into which the traversed links should be pushed
 100    * @param latency Accumulator in which the latencies should be added (caller must set it to 0)
 101    */
 102   virtual void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency)=0;
 103   /** @brief retrieves the list of all routes of size 1 (of type src x dst x Link) */
 104   virtual xbt_dynar_t getOneLinkRoutes();
 105
 106   virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)=0;
 107
 108   std::vector<Link*> *getBypassRoute(NetCard *src, NetCard *dst);
 109
 110   /* Add content to the AS, at parsing time. It should be sealed afterward. */
 111   virtual int addComponent(NetCard *elm); /* A host, a router or an AS, whatever */
 112   virtual void addRoute(sg_platf_route_cbarg_t route);
 113   void addBypassRoute(sg_platf_route_cbarg_t e_route);
 114 };
 115
 116 struct XBT_PRIVATE NetCardImpl : public NetCard {
 117 public:
 118   NetCardImpl(const char *name, e_surf_network_element_type_t componentType, As *as)
 119   : name_(xbt_strdup(name)),
 120     componentType_(componentType),
 121     containingAS_(as)
 122   {}
 123   ~NetCardImpl() { xbt_free(name_);};
 124
 125   int id()           override {return id_;}
 126   void setId(int id) override {id_ = id;}
 127   char *name()       override {return name_;}
 128   As *containingAS() override {return containingAS_;}
 129   e_surf_network_element_type_t getRcType() override {return componentType_;}
 130 private:
 131   int id_ = -1;
 132   char *name_;
 133   e_surf_network_element_type_t componentType_;
 134   As *containingAS_;
 135 };
 136
 137 /** @ingroup SURF_routing_interface
 138  * @brief Link of lenght 1, alongside with its source and destination. This is mainly usefull in the ns3 bindings
 139  */
 140 class Onelink {
 141 public:
 142   Onelink(void *link, NetCard *src, NetCard *dst)
 143     : src_(src), dst_(dst), link_(link) {};
 144   NetCard *src_;
 145   NetCard *dst_;
 146   void *link_;
 147 };
 148
 149 /** @ingroup SURF_routing_interface
 150  * @brief The class representing a whole routing platform
 151  */
 152 XBT_PUBLIC_CLASS RoutingPlatf {
 153 public:
 154   RoutingPlatf(void *loopback);
 155   ~RoutingPlatf();
 156   As *root_ = nullptr;
 157   void *loopback_;
 158   xbt_dynar_t lastRoute_ = xbt_dynar_new(sizeof(Link*),NULL);
 159   xbt_dynar_t getOneLinkRoutes(void);
 160   void getRouteAndLatency(NetCard *src, NetCard *dst, xbt_dynar_t * links, double *latency);
 161 };
 162
 163 /*************
 164  * Callbacks *
 165  *************/
 166
 167 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(NetCard*)>) netcardCreatedCallbacks;
 168 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(As*)>) asCreatedCallbacks;
 169
 170 }
 171 }
 172
 173 #endif /* NETWORK_ROUTING_HPP_ */