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