include/simgrid/s4u/as.hpp

   1 /* Copyright (c) 2016. The SimGrid Team. All rights reserved.               */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #ifndef SIMGRID_S4U_AS_HPP
   7 #define SIMGRID_S4U_AS_HPP
   8
   9 #include "xbt/base.h"
  10 #include "xbt/graph.h"
  11
  12 #include "simgrid/s4u/forward.hpp"
  13 #include <vector>
  14 #include <map>
  15
  16 #include "src/surf/xml/platf_private.hpp" // FIXME: kill sg_platf_route_cbarg_t to remove that UGLY include
  17
  18 namespace simgrid {
  19
  20 namespace surf {
  21   class Link;
  22   class NetCard;
  23   class RoutingPlatf; // FIXME: KILLME
  24 }
  25 namespace s4u {
  26
  27 /** @brief Autonomous Systems
  28  *
  29  * An AS is a network container, in charge of routing information between elements (hosts) and to the nearby ASes.
  30  * In SimGrid, there is a hierarchy of ASes, with a unique root AS (that you can retrieve from the s4u::Engine).
  31  */
  32 XBT_PUBLIC_CLASS As {
  33 protected:
  34   As(const char *name);
  35   virtual ~As();
  36
  37 public:
  38   /** @brief Seal your AS once you're done adding content, and before routing stuff through it */
  39   virtual void Seal();
  40   char *name();
  41   As *father();;
  42   xbt_dict_t children(); // Sub AS
  43   xbt_dynar_t hosts();   // my content
  44
  45
  46 public:
  47   /**
  48    * @brief Probe the routing path between two points
  49    *
  50    * The networking model uses this function when creating a communication
  51    * to retrieve both the list of links that the create communication will use,
  52    * and the summed latency that these links represent.
  53    *
  54    * The network could recompute the latency by itself from the list, but it would
  55    * require an additional link set traversal. This operation being on the critical
  56    * path of SimGrid, the routing computes the latency in behalf of the network.
  57    *
  58    * Things are rather complex here because we have to find the path from ASes to ASes, and within each.
  59    * In addition, the different ASes may use differing routing models.
  60    * 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.
  61    * Some ASes may even not have any predefined links and use only coordinate informations to compute the latency.
  62    *
  63    * So, the path is constructed recursively, with each traversed AS adding its information to the set.
  64    * The algorithm for that is explained in http://hal.inria.fr/hal-00650233/
  65    *
  66    * @param src Initial point of the routing path
  67    * @param dst Final point of the routing path
  68    * @param into Container into which the traversed links should be pushed
  69    * @param latency Accumulator in which the latencies should be added (caller must set it to 0)
  70    */
  71   virtual void getRouteAndLatency(surf::NetCard *src, surf::NetCard *dst, sg_platf_route_cbarg_t into, double *latency)=0;
  72   /** @brief retrieves the list of all routes of size 1 (of type src x dst x Link) */
  73   virtual xbt_dynar_t getOneLinkRoutes();
  74
  75   virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)=0;
  76
  77   /* Add content to the AS, at parsing time. It should be sealed afterward. */
  78   virtual int addComponent(surf::NetCard *elm); /* A host, a router or an AS, whatever */
  79   virtual void addRoute(sg_platf_route_cbarg_t route);
  80   void addBypassRoute(sg_platf_route_cbarg_t e_route);
  81
  82
  83   enum RoutingKind {
  84     ROUTING_NULL = 0,   /**< Undefined type                                   */
  85     ROUTING_BASE,       /**< Base case: use simple link lists for routing     */
  86     ROUTING_RECURSIVE   /**< Recursive case: also return gateway informations */
  87   };
  88   /* FIXME: protect the following fields once the construction madness is sorted out */
  89   RoutingKind hierarchy_ = ROUTING_NULL;
  90   xbt_dynar_t upDownLinks = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
  91   As *father_ = nullptr;
  92   surf::NetCard *netcard_ = nullptr; // Our representative in the father AS
  93
  94 protected:
  95   char *name_ = nullptr;
  96   xbt_dict_t children_ = xbt_dict_new_homogeneous(NULL); // sub-ASes
  97   xbt_dynar_t vertices_ = xbt_dynar_new(sizeof(char*),NULL); // our content, as known to our graph routing algorithm (maps vertexId -> vertex)
  98
  99 private:
 100   bool sealed_ = false; // We cannot add more content when sealed
 101
 102   friend surf::RoutingPlatf;
 103   std::map<std::pair<std::string, std::string>, std::vector<surf::Link*>*> bypassRoutes_; // srcName x dstName -> route
 104   static void getRouteRecursive(surf::NetCard *src, surf::NetCard *dst, /* OUT */ std::vector<surf::Link*> * links, double *latency);
 105   std::vector<surf::Link*> *getBypassRoute(surf::NetCard *src, surf::NetCard *dst);
 106
 107 };
 108
 109 }}; // Namespace simgrid::s4u
 110
 111 #endif /* SIMGRID_S4U_AS_HPP */