X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/e0e78e5fd1f74efdc62ed85e5b20d4cb70838a8f..3f9b311ec56db95ec539001a860ae3c838c48312:/include/simgrid/s4u/NetZone.hpp diff --git a/include/simgrid/s4u/NetZone.hpp b/include/simgrid/s4u/NetZone.hpp index 1014aff3c6..ab535fa289 100644 --- a/include/simgrid/s4u/NetZone.hpp +++ b/include/simgrid/s4u/NetZone.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2016-2021. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2016-2023. The SimGrid Team. All rights reserved. */ /* 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. */ @@ -6,6 +6,7 @@ #ifndef SIMGRID_S4U_NETZONE_HPP #define SIMGRID_S4U_NETZONE_HPP +#include "simgrid/s4u/Host.hpp" #include #include #include @@ -14,11 +15,11 @@ #include #include #include +#include #include #include -namespace simgrid { -namespace s4u { +namespace simgrid::s4u { /** @brief Networking Zones * @@ -27,11 +28,13 @@ namespace s4u { * s4u::Engine). */ class XBT_PUBLIC NetZone { +#ifndef DOXYGEN + friend kernel::routing::NetZoneImpl; +#endif + kernel::routing::NetZoneImpl* const pimpl_; protected: - friend kernel::routing::NetZoneImpl; - explicit NetZone(kernel::routing::NetZoneImpl* impl) : pimpl_(impl) {} public: @@ -40,12 +43,12 @@ public: /** @brief Retrieves the name of that netzone as a C string */ const char* get_cname() const; - XBT_ATTRIB_DEPRECATED_v331("Please use get_parent()") NetZone* get_father(); NetZone* get_parent() const; NetZone* set_parent(const NetZone* parent); + std::vector get_children() const; std::vector get_all_hosts() const; - int get_host_count() const; + size_t get_host_count() const; kernel::routing::NetZoneImpl* get_impl() const { return pimpl_; } @@ -55,18 +58,38 @@ public: const char* get_property(const std::string& key) const; void set_property(const std::string& key, const std::string& value); /** @brief Get the netpoint associated to this netzone */ - kernel::routing::NetPoint* get_netpoint(); - - std::vector get_children() const; - XBT_ATTRIB_DEPRECATED_v332("Please use set_parent() to manage NetZone's relationship") NetZone* add_child( - NetZone* new_zone); + kernel::routing::NetPoint* get_netpoint() const; + /** @brief Get the gateway associated to this netzone */ + kernel::routing::NetPoint* get_gateway() const; + kernel::routing::NetPoint* get_gateway(const std::string& name) const; + void set_gateway(const s4u::Host* router) { set_gateway(router->get_netpoint()); } + void set_gateway(kernel::routing::NetPoint* router); + void set_gateway(const std::string& name, kernel::routing::NetPoint* router); void extract_xbt_graph(const s_xbt_graph_t* graph, std::map>* nodes, std::map>* edges); /* Add content to the netzone, at parsing time. It should be sealed afterward. */ - int add_component(kernel::routing::NetPoint* elm); /* A host, a router or a netzone, whatever */ + unsigned long add_component(kernel::routing::NetPoint* elm); /* A host, a router or a netzone, whatever */ + /** + * @brief Add a route between 2 netzones, and same in other direction + * @param src Source netzone + * @param dst Destination netzone + * @param links List of links + */ + void add_route(const NetZone* src, const NetZone* dst, const std::vector& links); + +/** + * @brief Add a route between 2 netzones, and same in other direction + * @param src Source netzone + * @param dst Destination netzone + * @param link_list List of links and their direction used in this communication + * @param symmetrical Bi-directional communication + */ + void add_route(const NetZone* src, const NetZone* dst, const std::vector& link_list, bool symmetrical = true); + +#ifndef DOXYGEN /** * @brief Add a route between 2 netpoints * @@ -76,34 +99,72 @@ public: * * @param src Source netzone's netpoint * @param dst Destination netzone' netpoint - * @param src_gw Netpoint of the gateway in the source netzone - * @param dst_gw Netpoint of the gateway in the destination netzone - * @param link_list List of links used in this communication + * @param gw_src Netpoint of the gateway in the source netzone + * @param gw_dst Netpoint of the gateway in the destination netzone + * @param link_list List of links and their direction used in this communication * @param symmetrical Bi-directional communication */ + //(we should first remove the Python binding in v3.35) XBT_ATTRIB_DEPRECATED_v339("Please call add_route either from + // Host to Host or NetZone to NetZone") void add_route(kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst, kernel::routing::NetPoint* gw_src, - kernel::routing::NetPoint* gw_dst, const std::vector& link_list, bool symmetrical = true); - - XBT_ATTRIB_DEPRECATED_v332("Please use add_route() method which uses s4u::Link instead of LinkImpl") void add_route( + kernel::routing::NetPoint* gw_dst, const std::vector& link_list, bool symmetrical = true); + /** + * @brief Add a route between 2 netpoints, and same in other direction + * + * Create a route: + * - route between 2 hosts/routers in same netzone, no gateway is needed + * - route between 2 netzones, connecting 2 gateways. + * + * @param src Source netzone's netpoint + * @param dst Destination netzone' netpoint + * @param gw_src Netpoint of the gateway in the source netzone + * @param gw_dst Netpoint of the gateway in the destination netzone + * @param link_list List of links + */ + XBT_ATTRIB_DEPRECATED_v339("Please call add_route either from Host to Host or NetZone to NetZone") void add_route( kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst, kernel::routing::NetPoint* gw_src, - kernel::routing::NetPoint* gw_dst, const std::vector& link_list, bool symmetrical); + kernel::routing::NetPoint* gw_dst, const std::vector& links); +#endif + + /** + * @brief Add a route between 2 hosts + * + * @param src Source host + * @param dst Destination host + * @param link_list List of links and their direction used in this communication + * @param symmetrical Bi-directional communication + */ + void add_route(const Host* src, const Host* dst, const std::vector& link_list, bool symmetrical = true); + /** + * @brief Add a route between 2 hosts + * + * @param src Source host + * @param dst Destination host + * @param links List of links. The UP direction will be used on src->dst and DOWN direction on dst->src + */ + void add_route(const Host* src, const Host* dst, const std::vector& links); + void add_bypass_route(kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst, kernel::routing::NetPoint* gw_src, kernel::routing::NetPoint* gw_dst, - std::vector& link_list, bool symmetrical); + const std::vector& link_list); - /*** Called on each newly created regular route (not on bypass routes) */ - static xbt::signal const& link_list)> - on_route_creation; +private: +#ifndef DOXYGEN static xbt::signal on_creation; static xbt::signal on_seal; +#endif + +public: + /** \static Add a callback fired on each newly created NetZone */ + static void on_creation_cb(const std::function& cb) { on_creation.connect(cb); } + /** \static Add a callback fired on each newly sealed NetZone */ + static void on_seal_cb(const std::function& cb) { on_seal.connect(cb); } /** * @brief Create a host * * @param name Host name - * @param speed_per_state Vector of CPU's speeds + * @param speed_per_pstate Vector of CPU's speeds */ s4u::Host* create_host(const std::string& name, const std::vector& speed_per_pstate); s4u::Host* create_host(const std::string& name, double speed); @@ -129,6 +190,24 @@ public: s4u::Link* create_link(const std::string& name, const std::vector& bandwidths); s4u::Link* create_link(const std::string& name, const std::string& bandwidth); + /** + * @brief Create a split-duplex link + * + * In SimGrid, split-duplex links are a composition of 2 regular (shared) links (up/down). + * + * This function eases its utilization by creating the 2 links for you. We append a suffix + * "_UP" and "_DOWN" to your link name to identify each of them. + * + * Both up/down links have exactly the same bandwidth + * + * @param name Name of the link + * @param bandwidth Speed + */ + s4u::SplitDuplexLink* create_split_duplex_link(const std::string& name, const std::string& bandwidth); + s4u::SplitDuplexLink* create_split_duplex_link(const std::string& name, double bandwidth); + + kernel::resource::NetworkModel* get_network_model() const; + /** * @brief Make a router within that NetZone * @@ -139,42 +218,111 @@ public: /** @brief Seal this netzone configuration */ NetZone* seal(); -private: - /** @brief Auxiliary function to get list of LinkImpl */ - static std::vector get_link_list_impl(const std::vector link_list); + void + set_latency_factor_cb(std::function& /*links*/, + const std::unordered_set& /*netzones*/)> const& cb) const; + void + set_bandwidth_factor_cb(std::function& /*links*/, + const std::unordered_set& /*netzones*/)> const& cb) const; }; // External constructors so that the types (and the types of their content) remain hidden XBT_PUBLIC NetZone* create_full_zone(const std::string& name); -XBT_PUBLIC NetZone* create_cluster_zone(const std::string& name); XBT_PUBLIC NetZone* create_star_zone(const std::string& name); XBT_PUBLIC NetZone* create_dijkstra_zone(const std::string& name, bool cache); XBT_PUBLIC NetZone* create_empty_zone(const std::string& name); XBT_PUBLIC NetZone* create_floyd_zone(const std::string& name); XBT_PUBLIC NetZone* create_vivaldi_zone(const std::string& name); XBT_PUBLIC NetZone* create_wifi_zone(const std::string& name); -/** - * @brief Callback used to set the netpoint and gateway located at some leaf of clusters (Torus, FatTree, etc) - * - * The netpoint can be either a host, router or another netzone. - * Gateway must be non-null if netpoint is a netzone - * - * @param zone: The newly create zone, needed for creating new resources (hosts, links) - * @param coord: the coordinates of the element - * @param id: Internal identifier of the element - * @return pair: returns a pair of netpoint and gateway. - */ -using ClusterNetPointCb = std::pair( - NetZone* zone, const std::vector& coord, int id); -/** - * @brief Callback used to set the links for some leaf of the cluster (Torus, FatTree, etc) - * - * @param zone: The newly create zone, needed for creating new resources (hosts, links) - * @param coord: the coordinates of the element - * @param id: Internal identifier of the element - * @return Pointer to the Link - */ -using ClusterLinkCb = Link*(NetZone* zone, const std::vector& coord, int id); + +// Extra data structure for complex constructors + +/** @brief Aggregates the callbacks used to build clusters netzones (Torus/Dragronfly/Fat-Tree) */ +struct ClusterCallbacks { + /** + * @brief Callback used to set the netpoint and gateway located at some leaf of clusters (Torus, FatTree, etc) + * + * The netpoint can be either a host, router or another netzone. + * Gateway must be non-null if netpoint is a netzone + * + * @param zone: The newly create zone, needed for creating new resources (hosts, links) + * @param coord: the coordinates of the element + * @param id: Internal identifier of the element + * @return pair: returns a pair of netpoint and gateway. + */ + // XBT_ATTRIB_DEPRECATED_v339 + using ClusterNetPointCb = std::pair( + NetZone* zone, const std::vector& coord, unsigned long id); + + /** + * @brief Callback used to set the NetZone located at some leaf of clusters (Torus, FatTree, etc) + * + * @param zone: The parent zone, needed for creating new resources (hosts, links) + * @param coord: the coordinates of the element + * @param id: Internal identifier of the element + * @return NetZone*: returns newly created netzone + */ + using ClusterNetZoneCb = NetZone*(NetZone* zone, const std::vector& coord, unsigned long id); + /** + * @brief Callback used to set the Host located at some leaf of clusters (Torus, FatTree, etc) + * + * @param zone: The parent zone, needed for creating new resources (hosts, links) + * @param coord: the coordinates of the element + * @param id: Internal identifier of the element + * @return Host*: returns newly created host + */ + using ClusterHostCb = Host*(NetZone* zone, const std::vector& coord, unsigned long id); + + /** + * @brief Callback used to set the links for some leaf of the cluster (Torus, FatTree, etc) + * + * The coord parameter depends on the cluster being created: + * - Torus: Direct translation of the Torus' dimensions, e.g. (0, 0, 0) for a 3-D Torus + * - Fat-Tree: A pair (level in the tree, id), e.g. (0, 0): first leaf and (1,0): first switch at level 1. + * - Dragonfly: a tuple (group, chassis, blades/routers, nodes), e.g. (0, 0, 0, 0) for first node in the cluster. + * Important: To identify the router inside a "group, chassis, blade", we use MAX_UINT in the last parameter (e.g. 0, + * 0, 0, 4294967295). + * + * @param zone: The newly create zone, needed for creating new resources (hosts, links) + * @param coord: the coordinates of the element + * @param id: Internal identifier of the element + * @return Pointer to the Link + */ + using ClusterLinkCb = Link*(NetZone* zone, const std::vector& coord, unsigned long id); + + bool by_netzone_ = false; + bool is_by_netzone() const { return by_netzone_; } + bool by_netpoint_ = false; // XBT_ATTRIB_DEPRECATED_v339 + bool is_by_netpoint() const { return by_netpoint_; } // XBT_ATTRIB_DEPRECATED_v339 + std::function netpoint; // XBT_ATTRIB_DEPRECATED_v339 + std::function host; + std::function netzone; + std::function loopback = {}; + std::function limiter = {}; + explicit ClusterCallbacks(const std::function& set_netzone) + : by_netzone_(true), netzone(set_netzone){/* nothing to do */}; + + ClusterCallbacks(const std::function& set_netzone, + const std::function& set_loopback, const std::function& set_limiter) + : by_netzone_(true), netzone(set_netzone), loopback(set_loopback), limiter(set_limiter){/* nothing to do */}; + + explicit ClusterCallbacks(const std::function& set_host) + : host(set_host) {/* nothing to do */}; + + ClusterCallbacks(const std::function& set_host, + const std::function& set_loopback, const std::function& set_limiter) + : host(set_host), loopback(set_loopback), limiter(set_limiter){/* nothing to do */}; + + XBT_ATTRIB_DEPRECATED_v339("Please use callback with either a Host/NetZone creation function as first parameter") + explicit ClusterCallbacks(const std::function& set_netpoint) + : by_netpoint_(true), netpoint(set_netpoint){/* nothing to do */}; + XBT_ATTRIB_DEPRECATED_v339("Please use callback with either a Host/NetZone creation function as first parameter") + ClusterCallbacks(const std::function& set_netpoint, + const std::function& set_loopback, const std::function& set_limiter) + : by_netpoint_(true), netpoint(set_netpoint), loopback(set_loopback), limiter(set_limiter){/* nothing to do */}; +}; /** * @brief Create a torus zone * @@ -194,32 +342,25 @@ using ClusterLinkCb = Link*(NetZone* zone, const std::vector& coor * @param parent Pointer to parent's netzone (nullptr if root netzone). Needed to be able to create the resources inside * the netzone * @param dimensions List of positive integers (> 0) which determines the torus' dimensions + * @param set_callbacks Callbacks to set properties from cluster elements (netpoint, loopback and limiter) * @param bandwidth Characteristics of the inter-nodes link * @param latency Characteristics of the inter-nodes link * @param sharing_policy Characteristics of the inter-nodes link - * @param set_netpoint Callback to set the netpoint of an element in the torus - * @param set_loopback Callback to set the loopback - * @param set_limiter Callback to set the limiter * @return Pointer to new netzone */ XBT_PUBLIC NetZone* create_torus_zone(const std::string& name, const NetZone* parent, - const std::vector& dimensions, double bandwidth, double latency, - Link::SharingPolicy sharing_policy, - const std::function& set_netpoint, - const std::function& set_loopback = {}, - const std::function& set_limiter = {}); + const std::vector& dimensions, + const ClusterCallbacks& set_callbacks, double bandwidth, double latency, + Link::SharingPolicy sharing_policy); /** @brief Aggregates the parameters necessary to build a Fat-tree zone */ -struct FatTreeParams { +struct XBT_PUBLIC FatTreeParams { unsigned int levels; std::vector down; std::vector up; std::vector number; FatTreeParams(unsigned int n_levels, const std::vector& down_links, - const std::vector& up_links, const std::vector& links_number) - : levels(n_levels), down(down_links), up(up_links), number(links_number) - { /* nothing to do */ - } + const std::vector& up_links, const std::vector& links_number); }; /** * @brief Create a Fat-Tree zone @@ -242,22 +383,18 @@ struct FatTreeParams { * @param parent Pointer to parent's netzone (nullptr if root netzone). Needed to be able to create the resources inside * the netzone * @param parameters Characteristics of this Fat-Tree + * @param set_callbacks Callbacks to set properties from cluster elements (netpoint, loopback and limiter) * @param bandwidth Characteristics of the inter-nodes link * @param latency Characteristics of the inter-nodes link * @param sharing_policy Characteristics of the inter-nodes link - * @param set_netpoint Callback to set the netpoint of an element in the torus - * @param set_loopback Callback to set the loopback - * @param set_limiter Callback to set the limiter * @return Pointer to new netzone */ XBT_PUBLIC NetZone* create_fatTree_zone(const std::string& name, const NetZone* parent, const FatTreeParams& parameters, - double bandwidth, double latency, Link::SharingPolicy sharing_policy, - const std::function& set_netpoint, - const std::function& set_loopback = {}, - const std::function& set_limiter = {}); + const ClusterCallbacks& set_callbacks, double bandwidth, double latency, + Link::SharingPolicy sharing_policy); /** @brief Aggregates the parameters necessary to build a Dragonfly zone */ -struct DragonflyParams { +struct XBT_PUBLIC DragonflyParams { std::pair groups; std::pair chassis; std::pair routers; @@ -288,22 +425,16 @@ struct DragonflyParams { * @param parent Pointer to parent's netzone (nullptr if root netzone). Needed to be able to create the resources inside * the netzone * @param parameters Characteristics of this Dragonfly + * @param set_callbacks Callbacks to set properties from cluster elements (netpoint, loopback and limiter) * @param bandwidth Characteristics of the inter-nodes link * @param latency Characteristics of the inter-nodes link * @param sharing_policy Characteristics of the inter-nodes link - * @param set_netpoint Callback to set the netpoint of an element in the torus - * @param set_loopback Callback to set the loopback - * @param set_limiter Callback to set the limiter * @return Pointer to new netzone */ XBT_PUBLIC NetZone* create_dragonfly_zone(const std::string& name, const NetZone* parent, - const DragonflyParams& parameters, double bandwidth, double latency, - Link::SharingPolicy sharing_policy, - const std::function& set_netpoint, - const std::function& set_loopback = {}, - const std::function& set_limiter = {}); - -} // namespace s4u -} // namespace simgrid + const DragonflyParams& parameters, const ClusterCallbacks& set_callbacks, + double bandwidth, double latency, Link::SharingPolicy sharing_policy); + +} // namespace simgrid::s4u #endif /* SIMGRID_S4U_NETZONE_HPP */