- std::vector<kernel::resource::LinkImpl*>& link_list, bool symmetrical);
-
- /*** Called on each newly created regular route (not on bypass routes) */
- static simgrid::xbt::signal<void(bool symmetrical, kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst,
- kernel::routing::NetPoint* gw_src, kernel::routing::NetPoint* gw_dst,
- std::vector<kernel::resource::LinkImpl*>& link_list)>
- on_route_creation;
- static simgrid::xbt::signal<void(NetZone&)> on_creation;
- static simgrid::xbt::signal<void(NetZone&)> on_seal;
-
-public: // Deprecation wrappers
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_father()") NetZone* getFather() { return get_father(); }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_name()") const std::string& getName() const { return get_name(); }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_cname()") const char* getCname() const { return get_cname(); }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::add_route()") void addRoute(
- kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst, kernel::routing::NetPoint* gw_src,
- kernel::routing::NetPoint* gw_dst, std::vector<simgrid::kernel::resource::LinkImpl*>& link_list, bool symmetrical)
- {
- add_route(src, dst, gw_src, gw_dst, link_list, symmetrical);
- }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::add_bypass_route()") void addBypassRoute(
- kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst, kernel::routing::NetPoint* gw_src,
- kernel::routing::NetPoint* gw_dst, std::vector<simgrid::kernel::resource::LinkImpl*>& link_list, bool symmetrical)
- {
- add_bypass_route(src, dst, gw_src, gw_dst, link_list, symmetrical);
- }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_properties()") std::unordered_map<std::string, std::string>* getProperties()
- {
- return get_properties();
- }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_property()") const char* getProperty(const char* key)
- {
- return get_property(key);
- }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::set_property()") void setProperty(const char* key, const char* value)
- {
- set_property(key, value);
- }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::add_component()") int addComponent(kernel::routing::NetPoint* elm)
- {
- return add_component(elm);
- }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_vertices()") std::vector<kernel::routing::NetPoint*> getVertices();
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_host_count()") int getHostCount() { return get_host_count(); }
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_all_hosts()") void getHosts(
- std::vector<s4u::Host*>* whereto); // retrieve my content as a vector of hosts
- XBT_ATTRIB_DEPRECATED_v323("Please use NetZone::get_children()") std::vector<NetZone*>* getChildren()
- {
- std::vector<NetZone*>* res = new std::vector<NetZone*>();
- for (auto child : get_children())
- res->push_back(child);
- return res;
- }
+ const std::vector<LinkInRoute>& link_list);
+
+private:
+#ifndef DOXYGEN
+ static xbt::signal<void(NetZone const&)> on_creation;
+ static xbt::signal<void(NetZone const&)> on_seal;
+#endif
+
+public:
+ /** \static Add a callback fired on each newly created NetZone */
+ static void on_creation_cb(const std::function<void(NetZone const&)>& cb) { on_creation.connect(cb); }
+ /** \static Add a callback fired on each newly sealed NetZone */
+ static void on_seal_cb(const std::function<void(NetZone const&)>& cb) { on_seal.connect(cb); }
+
+ /**
+ * @brief Create a host
+ *
+ * @param name Host name
+ * @param speed_per_pstate Vector of CPU's speeds
+ */
+ s4u::Host* create_host(const std::string& name, const std::vector<double>& speed_per_pstate);
+ s4u::Host* create_host(const std::string& name, double speed);
+ /**
+ * @brief Create a Host (string version)
+ *
+ * @throw std::invalid_argument if speed format is incorrect.
+ */
+ s4u::Host* create_host(const std::string& name, const std::vector<std::string>& speed_per_pstate);
+ s4u::Host* create_host(const std::string& name, const std::string& speed);
+
+ /**
+ * @brief Create a link
+ *
+ * @param name Link name
+ * @param bandwidths Link's speed (vector for wifi links)
+ * @throw std::invalid_argument if bandwidth format is incorrect.
+ */
+ s4u::Link* create_link(const std::string& name, const std::vector<double>& bandwidths);
+ s4u::Link* create_link(const std::string& name, double bandwidth);
+
+ /** @brief Create a link (string version) */
+ s4u::Link* create_link(const std::string& name, const std::vector<std::string>& 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
+ *
+ * @param name Router name
+ */
+ kernel::routing::NetPoint* create_router(const std::string& name);
+
+ /** @brief Seal this netzone configuration */
+ NetZone* seal();
+
+ void
+ set_latency_factor_cb(std::function<double(double size, const s4u::Host* src, const s4u::Host* dst,
+ const std::vector<s4u::Link*>& /*links*/,
+ const std::unordered_set<s4u::NetZone*>& /*netzones*/)> const& cb) const;
+ void
+ set_bandwidth_factor_cb(std::function<double(double size, const s4u::Host* src, const s4u::Host* dst,
+ const std::vector<s4u::Link*>& /*links*/,
+ const std::unordered_set<s4u::NetZone*>& /*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_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);
+
+// 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<NetPoint*, NetPoint*>: returns a pair of netpoint and gateway.
+ */
+ // XBT_ATTRIB_DEPRECATED_v339
+ using ClusterNetPointCb = std::pair<kernel::routing::NetPoint*, kernel::routing::NetPoint*>(
+ NetZone* zone, const std::vector<unsigned long>& 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<unsigned long>& 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<unsigned long>& 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<unsigned long>& 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<ClusterNetPointCb> netpoint; // XBT_ATTRIB_DEPRECATED_v339
+ std::function<ClusterHostCb> host;
+ std::function<ClusterNetZoneCb> netzone;
+ std::function<ClusterLinkCb> loopback = {};
+ std::function<ClusterLinkCb> limiter = {};
+ explicit ClusterCallbacks(const std::function<ClusterNetZoneCb>& set_netzone)
+ : by_netzone_(true), netzone(set_netzone){/* nothing to do */};
+
+ ClusterCallbacks(const std::function<ClusterNetZoneCb>& set_netzone,
+ const std::function<ClusterLinkCb>& set_loopback, const std::function<ClusterLinkCb>& set_limiter)
+ : by_netzone_(true), netzone(set_netzone), loopback(set_loopback), limiter(set_limiter){/* nothing to do */};
+
+ explicit ClusterCallbacks(const std::function<ClusterHostCb>& set_host)
+ : host(set_host) {/* nothing to do */};
+
+ ClusterCallbacks(const std::function<ClusterHostCb>& set_host,
+ const std::function<ClusterLinkCb>& set_loopback, const std::function<ClusterLinkCb>& 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<ClusterNetPointCb>& 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<ClusterNetPointCb>& set_netpoint,
+ const std::function<ClusterLinkCb>& set_loopback, const std::function<ClusterLinkCb>& set_limiter)
+ : by_netpoint_(true), netpoint(set_netpoint), loopback(set_loopback), limiter(set_limiter){/* nothing to do */};