X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/55e3e5942266691da7914fc1e9fdc894a802a966..8f8bd4e0654bdeadb3653e14cd6f3ee8aa465443:/src/kernel/routing/NetZoneImpl.hpp diff --git a/src/kernel/routing/NetZoneImpl.hpp b/src/kernel/routing/NetZoneImpl.hpp index 4e1aa5876a..fe97e732e2 100644 --- a/src/kernel/routing/NetZoneImpl.hpp +++ b/src/kernel/routing/NetZoneImpl.hpp @@ -13,34 +13,33 @@ #include "simgrid/s4u/NetZone.hpp" #include "simgrid/s4u/forward.hpp" -#include "src/surf/xml/platf_private.hpp" // FIXME: kill sg_platf_route_cbarg_t to remove that UGLY include - namespace simgrid { namespace kernel { class EngineImpl; namespace routing { class BypassRoute; -/** @brief Networking Zones +/** @ingroup ROUTING_API + * @brief Private implementation of the Networking Zones * - * A netzone is a network container, in charge of routing information between elements (hosts) and to the nearby - * netzones. In SimGrid, there is a hierarchy of netzones, ie a tree with a unique root NetZone, that you can retrieve - * from the s4u::Engine. + * A netzone is a network container, in charge of routing information between elements (hosts and sub-netzones) + * and to the nearby netzones. In SimGrid, there is a hierarchy of netzones, ie a tree with a unique root + * NetZone, that you can retrieve with simgrid::s4u::Engine::netRoot(). * * The purpose of the kernel::routing module is to retrieve the routing path between two points in a time- and * space-efficient manner. This is done by NetZoneImpl::getGlobalRoute(), called when creating a communication to * retrieve both the list of links that the create communication will use, and the summed latency that these * links represent. * - * The network could recompute the latency by itself from the list, but it would require an additional link - * set traversal. This operation being on the critical path of SimGrid, the routing computes the latency on the - * behalf of the network. + * The network model could recompute the latency by itself from the list, but it would require an additional + * traversal of the link set. This operation being on the critical path of SimGrid, the routing computes the + * latency on the behalf of the network while constructing the link set. * * Finding the path between two nodes is rather complex because we navigate a hierarchy of netzones, each of them * being a full network. In addition, the routing can declare shortcuts (called bypasses), either within a NetZone * at the route level or directly between NetZones. Also, each NetZone can use a differing routing algorithm, depending - * on its class. @ref{FullZone} have a full matrix giving explicitly the path between any pair of their - * contained nodes, while @ref{DijkstraZone} or @ref{FloydZone} rely on a shortest path algorithm. @ref{VivaldiZone} + * on its class. @ref FullZone have a full matrix giving explicitly the path between any pair of their + * contained nodes, while @ref DijkstraZone or @ref FloydZone rely on a shortest path algorithm. @ref VivaldiZone * does not even have any link but only use only coordinate information to compute the latency. * * So NetZoneImpl::getGlobalRoute builds the path recursively asking its specific information to each traversed NetZone @@ -59,7 +58,8 @@ protected: public: /** @brief Make an host within that NetZone */ - simgrid::s4u::Host* createHost(const char* name, std::vector* speedPerPstate, int coreAmount); + simgrid::s4u::Host* createHost(const char* name, std::vector* speedPerPstate, int coreAmount, + std::unordered_map* props); /** @brief Creates a new route in this NetZone */ void addBypassRoute(sg_platf_route_cbarg_t e_route) override; @@ -72,11 +72,11 @@ protected: * @param into Container into which the traversed links and gateway informations should be pushed * @param latency Accumulator in which the latencies should be added (caller must set it to 0) */ - virtual void getLocalRoute(NetCard * src, NetCard * dst, sg_platf_route_cbarg_t into, double* latency) = 0; + virtual void getLocalRoute(NetPoint * src, NetPoint * dst, sg_platf_route_cbarg_t into, double* latency) = 0; /** @brief retrieves the list of all routes of size 1 (of type src x dst x Link) */ /* returns whether we found a bypass path */ - bool getBypassRoute(routing::NetCard * src, routing::NetCard * dst, - /* OUT */ std::vector * links, double* latency); + bool getBypassRoute(routing::NetPoint * src, routing::NetPoint * dst, + /* OUT */ std::vector * links, double* latency); public: /* @brief get the route between two nodes in the full platform @@ -86,8 +86,8 @@ public: * @param links Accumulator in which all traversed links should be pushed (caller must empty it) * @param latency Accumulator in which the latencies should be added (caller must set it to 0) */ - static void getGlobalRoute(routing::NetCard * src, routing::NetCard * dst, - /* OUT */ std::vector * links, double* latency); + static void getGlobalRoute(routing::NetPoint * src, routing::NetPoint * dst, + /* OUT */ std::vector * links, double* latency); virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges) = 0; enum class RoutingMode { @@ -99,8 +99,8 @@ public: RoutingMode hierarchy_ = RoutingMode::unset; private: - std::map, BypassRoute*> bypassRoutes_; // src x dst -> route - routing::NetCard* netcard_ = nullptr; // Our representative in the father NetZone + std::map, BypassRoute*> bypassRoutes_; // src x dst -> route + routing::NetPoint* netpoint_ = nullptr; // Our representative in the father NetZone }; } }