X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/95a02a8febe84fd1c2ed98c78c594a5e8a0116f7..b74cfd6dd5a13103459c5710a52d8a6054bada8d:/include/simgrid/kernel/routing/ClusterZone.hpp diff --git a/include/simgrid/kernel/routing/ClusterZone.hpp b/include/simgrid/kernel/routing/ClusterZone.hpp index 2e2cbfe79b..fb6a615dcf 100644 --- a/include/simgrid/kernel/routing/ClusterZone.hpp +++ b/include/simgrid/kernel/routing/ClusterZone.hpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2013-2021. 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,7 +6,7 @@ #ifndef SIMGRID_ROUTING_CLUSTER_HPP_ #define SIMGRID_ROUTING_CLUSTER_HPP_ -#include +#include #include @@ -52,7 +52,7 @@ namespace routing { * host0 host1 host2 * \endverbatim - * So, a communication from an host A to an host B goes through the following links (if they exist): + * So, a communication from a host A to a host B goes through the following links (if they exist): * limiter(A)_UP, private(A)_UP, backbone, private(B)_DOWN, limiter(B)_DOWN. * link_UP and link_DOWN usually share the exact same characteristics, but their * performance are not shared, to model the fact that TCP links are full-duplex. @@ -60,39 +60,65 @@ namespace routing { * A cluster is connected to the outer world through a router that is connected * directly to the cluster's backbone (no private link). * - * A communication from an host A to the outer world goes through the following links: + * A communication from a host A to the outer world goes through the following links: * limiter(A)_UP, private(A)_UP, backbone * (because the private router is directly connected to the cluster core). */ class ClusterZone : public NetZoneImpl { -public: - explicit ClusterZone(NetZone* father, std::string name); + /* We use a map instead of a std::vector here because that's a sparse vector. Some values may not exist */ + /* The pair is {link_up, link_down} */ + std::unordered_map> private_links_; + std::unordered_map gateways_; //!< list of gateways for leafs (if they're netzones) + resource::LinkImpl* backbone_ = nullptr; + NetPoint* router_ = nullptr; + bool has_limiter_ = false; + bool has_loopback_ = false; + unsigned int num_links_per_node_ = 1; /* may be 1 (if only a private link), 2 or 3 (if limiter and loopback) */ - void getLocalRoute(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override; - void getGraph(xbt_graph_t graph, std::map* nodes, - std::map* edges) override; +protected: + void set_num_links_per_node(unsigned int num) { num_links_per_node_ = num; } + resource::LinkImpl* get_uplink_from(unsigned int position) const { return private_links_.at(position).first; } + resource::LinkImpl* get_downlink_to(unsigned int position) const { return private_links_.at(position).second; } + +public: + explicit ClusterZone(const std::string& name); - virtual void create_links_for_node(ClusterCreationArgs* cluster, int id, int rank, unsigned int position); - virtual void parse_specific_arguments(ClusterCreationArgs* cluster) + void set_loopback(); + bool has_loopback() const { return has_loopback_; } + void set_limiter(); + bool has_limiter() const { return has_limiter_; } + void set_backbone(resource::LinkImpl* bb) { backbone_ = bb; } + bool has_backbone() const { return backbone_ != nullptr; } + void set_router(NetPoint* router) { router_ = router; } + /** @brief Sets gateway for the leaf */ + void set_gateway(unsigned int position, NetPoint* gateway); + /** @brief Gets gateway for the leaf or nullptr */ + NetPoint* get_gateway(unsigned int position); + void add_private_link_at(unsigned int position, std::pair link); + bool private_link_exists_at(unsigned int position) const { - /* this routing method does not require any specific argument */ + return private_links_.find(position) != private_links_.end(); } - /* We use a map instead of a std::vector here because that's a sparse vector. Some values may not exist */ - /* The pair is {linkUp, linkDown} */ - std::unordered_map> privateLinks_; + void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override; + void get_graph(const s_xbt_graph_t* graph, std::map>* nodes, + std::map>* edges) override; - unsigned int nodePosition(int id) { return id * linkCountPerNode_; } - unsigned int nodePositionWithLoopback(int id) { return nodePosition(id) + (hasLoopback_ ? 1 : 0); } - unsigned int nodePositionWithLimiter(int id) { return nodePositionWithLoopback(id) + (hasLimiter_ ? 1 : 0); } + void create_links_for_node(const ClusterCreationArgs* cluster, int id, int rank, unsigned int position); - surf::LinkImpl* backbone_ = nullptr; - void* loopback_ = nullptr; - NetPoint* router_ = nullptr; - bool hasLimiter_ = false; - bool hasLoopback_ = false; - unsigned int linkCountPerNode_ = 1; /* may be 1 (if only a private link), 2 or 3 (if limiter and loopback) */ + unsigned int node_pos(int id) const { return id * num_links_per_node_; } + unsigned int node_pos_with_loopback(int id) const { return node_pos(id) + (has_loopback_ ? 1 : 0); } + unsigned int node_pos_with_loopback_limiter(int id) const + { + return node_pos_with_loopback(id) + (has_limiter_ ? 1 : 0); + } + /** Fill the leaf retriving netpoint from a user's callback */ + void fill_leaf_from_cb(unsigned int position, const std::vector& dimensions, + const std::function& set_netpoint_cb, + const std::function& set_loopback_cb, + const std::function& set_limiter_cb, NetPoint** node_netpoint, + s4u::Link** lb_link, s4u::Link** limiter_link); }; } // namespace routing } // namespace kernel