X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a18117755285a374ec3d5830309c924f2830e3ba..0342cac8cbf7d74cf6efa11b33abd8cb6d87cc3c:/src/kernel/routing/NetZoneImpl.hpp diff --git a/src/kernel/routing/NetZoneImpl.hpp b/src/kernel/routing/NetZoneImpl.hpp index d442e7c1fd..fe97e732e2 100644 --- a/src/kernel/routing/NetZoneImpl.hpp +++ b/src/kernel/routing/NetZoneImpl.hpp @@ -3,77 +3,80 @@ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#ifndef SIMGRID_SURF_AS_HPP -#define SIMGRID_SURF_AS_HPP +#ifndef SIMGRID_ROUTING_NETZONEIMPL_HPP +#define SIMGRID_ROUTING_NETZONEIMPL_HPP + +#include #include "xbt/graph.h" -#include "simgrid/s4u/As.hpp" +#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 Autonomous Systems +/** @ingroup ROUTING_API + * @brief Private implementation of the Networking Zones * - * An AS is a network container, in charge of routing information between elements (hosts) and to the nearby ASes. - * In SimGrid, there is a hierarchy of ASes, ie a tree with a unique root AS, 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 AsImpl::getGlobalRoute(), called when creating a communication to + * 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 ASes, each of them - * being a full network. In addition, the routing can declare shortcuts (called bypasses), either within an AS - * at the route level or directly between ASes. Also, each AS can use a differing routing algorithm, depending - * on its class. @ref{AsFull} have a full matrix giving explicitly the path between any pair of their - * contained nodes, while @ref{AsDijkstra} or @ref{AsFloyd} rely on a shortest path algorithm. @ref{AsVivaldi} + * 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 * does not even have any link but only use only coordinate information to compute the latency. * - * So AsImpl::getGlobalRoute builds the path recursively asking its specific information to each traversed AS with - * AsImpl::getLocalRoute, that is redefined in each sub-class. - * The algorithm for that is explained in http://hal.inria.fr/hal-00650233/ + * So NetZoneImpl::getGlobalRoute builds the path recursively asking its specific information to each traversed NetZone + * with NetZoneImpl::getLocalRoute, that is redefined in each sub-class. + * The algorithm for that is explained in http://hal.inria.fr/hal-00650233/ (but for historical reasons, NetZones are + * called Autonomous Systems in this article). * */ -XBT_PUBLIC_CLASS AsImpl : public s4u::As +XBT_PUBLIC_CLASS NetZoneImpl : public s4u::NetZone { - friend simgrid::kernel::EngineImpl; // it destroys rootAs_ + friend simgrid::kernel::EngineImpl; // it destroys netRoot_ protected: - explicit AsImpl(As * father, const char* name); - virtual ~AsImpl(); + explicit NetZoneImpl(NetZone * father, const char* name); + virtual ~NetZoneImpl(); public: - /** @brief Make an host within that AS */ - simgrid::s4u::Host* createHost(const char* name, std::vector* speedPerPstate, int coreAmount); - /** @brief Creates a new route in this AS */ + /** @brief Make an host within that NetZone */ + 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; protected: /** - * @brief Probe the routing path between two points that are local to the called AS. + * @brief Probe the routing path between two points that are local to the called NetZone. * * @param src where from * @param dst where to * @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 @@ -83,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 { @@ -96,11 +99,11 @@ public: RoutingMode hierarchy_ = RoutingMode::unset; private: - std::map, BypassRoute*> bypassRoutes_; // src x dst -> route - routing::NetCard* netcard_ = nullptr; // Our representative in the father AS + std::map, BypassRoute*> bypassRoutes_; // src x dst -> route + routing::NetPoint* netpoint_ = nullptr; // Our representative in the father NetZone }; } } }; // Namespace simgrid::kernel::routing -#endif /* SIMGRID_SURF_AS_HPP */ +#endif /* SIMGRID_ROUTING_NETZONEIMPL_HPP */