X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/6e835f0ea3cd49e0c025a416ab3af54375f91401..fcf6c25b7dc7f9074b1f2d83948f4ceeb45c228c:/include/simgrid/s4u/NetZone.hpp diff --git a/include/simgrid/s4u/NetZone.hpp b/include/simgrid/s4u/NetZone.hpp index 179b087c5a..9daaf7b750 100644 --- a/include/simgrid/s4u/NetZone.hpp +++ b/include/simgrid/s4u/NetZone.hpp @@ -129,6 +129,8 @@ 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); + kernel::resource::NetworkModelIntf* get_network_model() const; + /** * @brief Make a router within that NetZone * @@ -141,40 +143,61 @@ public: private: /** @brief Auxiliary function to get list of LinkImpl */ - static std::vector get_link_list_impl(const std::vector link_list); + static std::vector get_link_list_impl(const std::vector& link_list); }; // 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. + */ + 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) + * + * 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, int id); + + std::function netpoint; + std::function loopback = {}; + std::function limiter = {}; + explicit ClusterCallbacks(const std::function& set_netpoint) + : netpoint(set_netpoint){/*nothing to do */}; + ClusterCallbacks(const std::function& set_netpoint, + const std::function& set_loopback, const std::function& set_limiter) + : netpoint(set_netpoint), loopback(set_loopback), limiter(set_limiter){/*nothing to do */}; +}; /** * @brief Create a torus zone * @@ -183,48 +206,109 @@ using ClusterLinkCb = Link*(NetZone* zone, const std::vector& coor * elements * - inter-node communication: (bandwidth, latency, sharing_policy) the elements are connected through regular links * with these characteristics + * More details in: Torus + * Cluster * * Moreover, this method accepts 3 callbacks to populate the cluster: set_netpoint, set_loopback and set_limiter . * - * Note that the all elements in Torus cluster must have (or not) the same elements (loopback and limiter) + * Note that the all elements in a Torus cluster must have (or not) the same elements (loopback and limiter) * * @param name NetZone's name - * @param parent Pointer to parent's netzone (nullptr if rootnetzone). Needed to be able to create the resources inside + * @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 { 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 + * + * Fat-Tree clusters are characterized by: + * - levels: number of levels in the cluster, e.g. 2 (the final tree will have n+1 levels) + * - downlinks: for each level, how many connections between elements below them, e.g. 2, 3: level 1 nodes are connected + * to 2 nodes in level 2, which are connected to 3 nodes below. Determines the number total of leaves in the tree. + * - uplinks: for each level, how nodes are connected, e.g. 1, 2 + * - link count: for each level, number of links connecting the nodes, e.g. 1, 1 + * + * The best way to understand it is looking to the doc available in: Fat Tree Cluster + * + * Moreover, this method accepts 3 callbacks to populate the cluster: set_netpoint, set_loopback and set_limiter . + * + * Note that the all elements in a Fat-Tree cluster must have (or not) the same elements (loopback and limiter) + * + * @param name NetZone's name + * @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 + * @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); -XBT_PUBLIC NetZone* create_dragonfly_zone(const std::string& name); +/** @brief Aggregates the parameters necessary to build a Dragonfly zone */ +struct DragonflyParams { + std::pair groups; + std::pair chassis; + std::pair routers; + unsigned int nodes; + DragonflyParams(const std::pair& groups, + const std::pair& chassis, + const std::pair& routers, unsigned int nodes); +}; +/** + * @brief Create a Dragonfly zone + * + * Dragonfly clusters are characterized by: + * - groups: number of groups and links between each group, e.g. 2,2. + * - chassis: number of chassis in each group and the number of links used to connect the chassis, e.g. 2,3 + * - routers: number of routers in each chassis and their links, e.g. 3,1 + * - nodes: number of nodes connected to each router using a single link, e.g. 2 + * + * In total, the cluster will have groups * chassis * routers * nodes elements/leaves. + * + * The best way to understand it is looking to the doc available in: Dragonfly Cluster + * + * Moreover, this method accepts 3 callbacks to populate the cluster: set_netpoint, set_loopback and set_limiter . + * + * Note that the all elements in a Dragonfly cluster must have (or not) the same elements (loopback and limiter) + * + * @param name NetZone's name + * @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 + * @return Pointer to new netzone + */ +XBT_PUBLIC NetZone* create_dragonfly_zone(const std::string& name, const NetZone* parent, + const DragonflyParams& parameters, const ClusterCallbacks& set_callbacks, + double bandwidth, double latency, Link::SharingPolicy sharing_policy); } // namespace s4u } // namespace simgrid