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 <float.h>
  15
  16 XBT_PUBLIC(void) routing_model_create( void *loopback);
  17
  18 namespace simgrid {
  19 namespace surf {
  20
  21 /***********
  22  * Classes *
  23  ***********/
  24
  25 class As;
  26 class XBT_PRIVATE RoutingModelDescription;
  27 class XBT_PRIVATE Onelink;
  28 class RoutingPlatf;
  29
  30 /** @ingroup SURF_routing_interface
  31  * @brief Network cards are the vertices in the graph representing the network, used to compute paths between nodes.
  32  *
  33  * @details This represents a position in the network. One can route information between two netcards
  34  */
  35 class NetCard {
  36 public:
  37   virtual ~NetCard(){};
  38   virtual int getId()=0; // Our rank in the vertices_ array of our container AS.
  39   virtual int *getIdPtr()=0;
  40   virtual void setId(int id)=0;
  41   virtual char *getName()=0;
  42   virtual As *getRcComponent()=0;
  43   virtual e_surf_network_element_type_t getRcType()=0;
  44 };
  45
  46 /** @ingroup SURF_routing_interface
  47  * @brief The Autonomous System (AS) routing interface
  48  * @details [TODO]
  49  */
  50 class As {
  51 public:
  52   As(const char*name);
  53   /** @brief Close that AS: no more content can be added to it */
  54   virtual void Seal()=0;
  55   virtual ~As();
  56
  57   char *name_ = nullptr;
  58   NetCard *netcard_ = nullptr;
  59   As *father_ = nullptr;
  60   xbt_dict_t sons_ = xbt_dict_new_homogeneous(NULL);
  61
  62   xbt_dynar_t vertices_ = xbt_dynar_new(sizeof(char*),NULL); // our content, as known to our graph routing algorithm (maps vertexId -> vertex)
  63   xbt_dict_t bypassRoutes_ = nullptr;
  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
  68
  69   /**
  70    * @brief Probe the routing path between two points
  71    *
  72    * The networking model uses this function when creating a communication
  73    * to retrieve both the list of links that the create communication will use,
  74    * and the summed latency that these links represent.
  75    *
  76    * The network could recompute the latency by itself from the list, but it would
  77    * require an additional link set traversal. This operation being on the critical
  78    * path of SimGrid, the routing computes the latency in behalf of the network.
  79    *
  80    * Things are rather complex here because we have to find the path from ASes to ASes, and within each.
  81    * In addition, the different ASes may use differing routing models.
  82    * 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.
  83    * Some ASes may even not have any predefined links and use only coordinate informations to compute the latency.
  84    *
  85    * So, the path is constructed recursively, with each traversed AS adding its information to the set.
  86    * The algorithm for that is explained in http://hal.inria.fr/hal-00650233/
  87    *
  88    * @param src Initial point of the routing path
  89    * @param dst Final point of the routing path
  90    * @param into Container into which the traversed links should be pushed
  91    * @param latency Accumulator in which the latencies should be added (caller must set it to 0)
  92    */
  93   virtual void getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t into, double *latency)=0;
  94   /** @brief retrieves the list of all routes of size 1 (of type src x dst x Link) */
  95   virtual xbt_dynar_t getOneLinkRoutes()=0;
  96
  97   virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)=0;
  98
  99   virtual sg_platf_route_cbarg_t getBypassRoute(NetCard *src, NetCard *dst,double *lat)=0;
 100
 101   /* The parser calls the following functions to inform the routing models
 102    * that a new element is added to the AS currently built.
 103    *
 104    * Of course, only the routing model of this AS is informed, not every ones */
 105   virtual int addComponent(NetCard *elm); /* A host, a router or an AS, whatever */
 106   virtual void parseRoute(sg_platf_route_cbarg_t route)=0;
 107   virtual void parseASroute(sg_platf_route_cbarg_t route)=0;
 108   virtual void parseBypassroute(sg_platf_route_cbarg_t e_route)=0;
 109 };
 110
 111 struct XBT_PRIVATE NetCardImpl : public NetCard {
 112 public:
 113   NetCardImpl(const char *name, e_surf_network_element_type_t componentType, As *component)
 114   : component_(component),
 115     componentType_(componentType),
 116     name_(xbt_strdup(name))
 117   {}
 118   ~NetCardImpl() { xbt_free(name_);};
 119
 120   int getId() {return id_;}
 121   int *getIdPtr() {return &id_;}
 122   void setId(int id) {id_ = id;}
 123   char *getName() {return name_;}
 124   As *getRcComponent() {return component_;}
 125   e_surf_network_element_type_t getRcType() {return componentType_;}
 126 private:
 127   As *component_;
 128   e_surf_network_element_type_t componentType_;
 129   int id_ = -1;
 130   char *name_;
 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     : p_src(src), p_dst(dst), p_link(link) {};
 140   NetCard *p_src;
 141   NetCard *p_dst;
 142   void *p_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 *p_root = nullptr;
 153   void *p_loopback;
 154   xbt_dynar_t p_lastRoute = xbt_dynar_new(sizeof(sg_routing_link_t),NULL);
 155   xbt_dynar_t getOneLinkRoutes(void);
 156   xbt_dynar_t recursiveGetOneLinkRoutes(As *rc);
 157   void getRouteAndLatency(NetCard *src, NetCard *dst, xbt_dynar_t * links, double *latency);
 158 };
 159
 160 /*************
 161  * Callbacks *
 162  *************/
 163
 164 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(NetCard*)>) netcardCreatedCallbacks;
 165 XBT_PUBLIC_DATA(simgrid::xbt::signal<void(As*)>) asCreatedCallbacks;
 166
 167 }
 168 }
 169
 170 #endif /* NETWORK_ROUTING_HPP_ */