class ClusterZone : public NetZoneImpl {
public:
- explicit ClusterZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit ClusterZone(const std::string& name);
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
void get_graph(const s_xbt_graph_t* graph, std::map<std::string, xbt_node_t, std::less<>>* nodes,
xbt_node_t route_graph_new_node(int id);
xbt_node_t node_map_search(int id);
void new_edge(int src_id, int dst_id, RouteCreationArgs* e_route);
+ void do_seal() override;
public:
- DijkstraZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel, bool cached);
+ DijkstraZone(const std::string& name, bool cached);
/* For each vertex (node) already in the graph,
* make sure it also has a loopback link; this loopback
* After this function returns, any node in the graph
* will have a loopback attached to it.
*/
- void seal() override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* route, double* lat) override;
void add_route(NetPoint* src, NetPoint* dst, NetPoint* gw_src, NetPoint* gw_dst,
std::vector<resource::LinkImpl*>& link_list, bool symmetrical) override;
unsigned node;
};
- explicit DragonflyZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit DragonflyZone(const std::string& name);
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
void parse_specific_arguments(ClusterCreationArgs* cluster) override;
- void seal() override;
Coords rankId_to_coords(int rank_id) const;
XBT_ATTRIB_DEPRECATED_v330("Please use rankId_to_coords(int)") void rankId_to_coords(int rank_id,
unsigned int coords[4]) const;
private:
+ void do_seal() override;
void generate_routers();
void generate_links();
void generate_link(const std::string& id, int numlinks, resource::LinkImpl** linkup,
class XBT_PRIVATE EmptyZone : public NetZoneImpl {
public:
- explicit EmptyZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit EmptyZone(const std::string& name);
~EmptyZone() override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override
*/
class XBT_PRIVATE FatTreeZone : public ClusterZone {
public:
- explicit FatTreeZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit FatTreeZone(const std::string& name);
FatTreeZone(const FatTreeZone&) = delete;
FatTreeZone& operator=(const FatTreeZone&) = delete;
~FatTreeZone() override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
- /** @brief Generate the fat tree
- *
- * Once all processing nodes have been added, this will make sure the fat
- * tree is generated by calling generateLabels(), generateSwitches() and
- * then connection all nodes between them, using their label.
- */
- void seal() override;
/** @brief Read the parameters in topo_parameters field.
*
* It will also store the cluster for future use.
void generate_dot_file(const std::string& filename = "fat_tree.dot") const;
private:
+ /** @brief Generate the fat tree
+ *
+ * Once all processing nodes have been added, this will make sure the fat
+ * tree is generated by calling generateLabels(), generateSwitches() and
+ * then connection all nodes between them, using their label.
+ */
+ void do_seal() override;
// description of a PGFT (TODO : better doc)
unsigned long levels_ = 0;
std::vector<unsigned int> num_children_per_node_; // number of children by node
*/
class XBT_PRIVATE FloydZone : public RoutedZone {
public:
- explicit FloydZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit FloydZone(const std::string& name);
FloydZone(const FloydZone&) = delete;
FloydZone& operator=(const FloydZone&) = delete;
~FloydZone() override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
void add_route(NetPoint* src, NetPoint* dst, NetPoint* gw_src, NetPoint* gw_dst,
std::vector<resource::LinkImpl*>& link_list, bool symmetrical) override;
- void seal() override;
private:
/* vars to compute the Floyd algorithm. */
std::vector<RouteCreationArgs*> link_table_;
void init_tables(unsigned int table_size);
+ void do_seal() override;
};
} // namespace routing
} // namespace kernel
*/
class XBT_PRIVATE FullZone : public RoutedZone {
public:
- explicit FullZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit FullZone(const std::string& name);
FullZone(const FullZone&) = delete;
FullZone& operator=(const FullZone) = delete;
~FullZone() override;
- void seal() override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
void add_route(NetPoint* src, NetPoint* dst, NetPoint* gw_src, NetPoint* gw_dst,
std::vector<resource::LinkImpl*>& link_list, bool symmetrical) override;
private:
std::vector<RouteCreationArgs*> routing_table_;
+ void do_seal() override;
};
} // namespace routing
} // namespace kernel
public:
enum class Type { Host, Router, NetZone };
- NetPoint(const std::string& name, NetPoint::Type component_type, NetZoneImpl* netzone_p);
+ NetPoint(const std::string& name, NetPoint::Type component_type);
// Our rank in the vertices_ array of the netzone that contains us.
unsigned int id() const { return id_; }
const char* get_cname() const { return name_.c_str(); }
/** @brief the NetZone in which this NetPoint is included */
NetZoneImpl* get_englobing_zone() { return englobing_zone_; }
+ /** @brief Set the NetZone in which this NetPoint is included */
+ NetPoint* set_englobing_zone(NetZoneImpl* netzone_p);
bool is_netzone() const { return component_type_ == Type::NetZone; }
bool is_host() const { return component_type_ == Type::Host; }
bool operator<(const NetPoint& rhs) const { return name_ < rhs.name_; }
private:
- unsigned int id_;
+ unsigned int id_ = -1;
std::string name_;
NetPoint::Type component_type_;
NetZoneImpl* englobing_zone_;
std::map<std::pair<NetPoint*, NetPoint*>, BypassRoute*> bypass_routes_; // src x dst -> route
routing::NetPoint* netpoint_ = nullptr; // Our representative in the father NetZone
- resource::NetworkModel* network_model_;
- resource::CpuModel* cpu_model_vm_;
- resource::CpuModel* cpu_model_pm_;
- resource::DiskModel* disk_model_;
- simgrid::surf::HostModel* host_model_;
+ std::shared_ptr<resource::NetworkModel> network_model_;
+ std::shared_ptr<resource::CpuModel> cpu_model_vm_;
+ std::shared_ptr<resource::CpuModel> cpu_model_pm_;
+ std::shared_ptr<resource::DiskModel> disk_model_;
+ std::shared_ptr<simgrid::surf::HostModel> host_model_;
+ /** @brief Perform sealing procedure for derived classes, if necessary */
+ virtual void do_seal(){};
protected:
- explicit NetZoneImpl(NetZoneImpl* father, const std::string& name, resource::NetworkModel* network_model);
+ explicit NetZoneImpl(const std::string& name);
NetZoneImpl(const NetZoneImpl&) = delete;
NetZoneImpl& operator=(const NetZoneImpl&) = delete;
virtual ~NetZoneImpl();
RoutingMode hierarchy_ = RoutingMode::unset;
/** @brief Retrieves the network model associated to this NetZone */
- resource::NetworkModel* get_network_model() const { return network_model_; }
+ const std::shared_ptr<resource::NetworkModel>& get_network_model() const { return network_model_; }
/** @brief Retrieves the CPU model for virtual machines associated to this NetZone */
- resource::CpuModel* get_cpu_vm_model() const { return cpu_model_vm_; }
+ const std::shared_ptr<resource::CpuModel>& get_cpu_vm_model() const { return cpu_model_vm_; }
/** @brief Retrieves the CPU model for physical machines associated to this NetZone */
- resource::CpuModel* get_cpu_pm_model() const { return cpu_model_pm_; }
+ const std::shared_ptr<resource::CpuModel>& get_cpu_pm_model() const { return cpu_model_pm_; }
/** @brief Retrieves the disk model associated to this NetZone */
- resource::DiskModel* get_disk_model() const { return disk_model_; }
+ const std::shared_ptr<resource::DiskModel>& get_disk_model() const { return disk_model_; }
/** @brief Retrieves the host model associated to this NetZone */
- simgrid::surf::HostModel* get_host_model() const { return host_model_; }
+ const std::shared_ptr<surf::HostModel>& get_host_model() const { return host_model_; }
const s4u::NetZone* get_iface() const { return &piface_; }
s4u::NetZone* get_iface() { return &piface_; }
std::vector<resource::LinkImpl*>& link_list, bool symmetrical);
/** @brief Seal your netzone once you're done adding content, and before routing stuff through it */
- virtual void seal() { sealed_ = true; };
+ void seal();
virtual int add_component(kernel::routing::NetPoint* elm); /* A host, a router or a netzone, whatever */
virtual void add_route(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, bool symmetrical);
+ /** @brief Set parent of this Netzone */
+ void set_parent(NetZoneImpl* parent);
+ /** @brief Set network model for this Netzone */
+ void set_network_model(std::shared_ptr<resource::NetworkModel> netmodel);
+ void set_cpu_vm_model(std::shared_ptr<resource::CpuModel> cpu_model);
+ void set_cpu_pm_model(std::shared_ptr<resource::CpuModel> cpu_model);
+ void set_disk_model(std::shared_ptr<resource::DiskModel> disk_model);
+ void set_host_model(std::shared_ptr<surf::HostModel> host_model);
/* @brief get the route between two nodes in the full platform
*
class XBT_PRIVATE RoutedZone : public NetZoneImpl {
public:
- explicit RoutedZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit RoutedZone(const std::string& name);
void get_graph(const s_xbt_graph_t* graph, std::map<std::string, xbt_node_t, std::less<>>* nodes,
std::map<std::string, xbt_edge_t, std::less<>>* edges) override;
class XBT_PRIVATE TorusZone : public ClusterZone {
public:
- explicit TorusZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit TorusZone(const std::string& name);
void create_links_for_node(ClusterCreationArgs* cluster, int id, int rank, unsigned int position) override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
void parse_specific_arguments(ClusterCreationArgs* cluster) override;
class XBT_PRIVATE VivaldiZone : public ClusterZone {
public:
- explicit VivaldiZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit VivaldiZone(const std::string& name);
void set_peer_link(NetPoint* netpoint, double bw_in, double bw_out, const std::string& coord);
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
*/
class XBT_PRIVATE WifiZone : public RoutedZone {
public:
- explicit WifiZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel);
+ explicit WifiZone(const std::string& name);
WifiZone(const WifiZone&) = delete;
WifiZone& operator=(const WifiZone) = delete;
- void seal() override;
void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) override;
s4u::Link* create_link(const std::string& name, const std::vector<double>& bandwidths,
s4u::Link::SharingPolicy policy) override;
- NetPoint* get_access_point() {return access_point_;}
+ NetPoint* get_access_point() { return access_point_; }
private:
+ void do_seal() override;
resource::LinkImpl* wifi_link_ = nullptr; // Representing the air media (there is no such thing in NS-3)
NetPoint* access_point_ = nullptr; // Zone's gateway to the external world
};
/* FIXME[donassolo]: getting the network_model from the origin host
* Soon we need to change this function to first get the routes and later
* create the respective surf actions */
- auto* net_model = from_->get_netpoint()->get_englobing_zone()->get_network_model();
+ auto net_model = from_->get_netpoint()->get_englobing_zone()->get_network_model();
surf_action_ = net_model->communicate(from_, to_, size_, rate_);
surf_action_->set_activity(this);
namespace simgrid {
namespace kernel {
namespace routing {
-ClusterZone::ClusterZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : NetZoneImpl(father, name, netmodel)
-{
-}
+ClusterZone::ClusterZone(const std::string& name) : NetZoneImpl(name) {}
void ClusterZone::get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* route, double* lat)
{
}
if (not src->is_router()) { // No private link for the private router
- if (has_limiter_) { // limiter for sender
+ if (has_limiter_) { // limiter for sender
std::pair<resource::LinkImpl*, resource::LinkImpl*> info = private_links_.at(node_pos_with_loopback(src->id()));
route->link_list.push_back(info.first);
}
std::string link_id = cluster->id + "_link_" + std::to_string(id);
LinkCreationArgs link;
- link.id = link_id;
+ link.id = link_id;
link.bandwidths.push_back(cluster->bw);
- link.latency = cluster->lat;
- link.policy = cluster->sharing_policy;
+ link.latency = cluster->lat;
+ link.policy = cluster->sharing_policy;
sg_platf_new_link(&link);
const s4u::Link* linkUp;
}
private_links_.insert({position, {linkUp->get_impl(), linkDown->get_impl()}});
}
-}
-}
-}
+} // namespace routing
+} // namespace kernel
+} // namespace simgrid
int graph_id_ = -1; /* used for caching internal graph id's */
};
-DijkstraZone::DijkstraZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel, bool cached)
- : RoutedZone(father, name, netmodel), cached_(cached)
-{
-}
+DijkstraZone::DijkstraZone(const std::string& name, bool cached) : RoutedZone(name), cached_(cached) {}
void DijkstraZone::route_graph_delete(xbt_graph_t g)
{
- xbt_graph_free_graph(g, [](void* n) { delete static_cast<simgrid::kernel::routing::GraphNodeData*>(n); },
- [](void* e) { delete static_cast<simgrid::kernel::routing::RouteCreationArgs*>(e); }, nullptr);
+ xbt_graph_free_graph(
+ g, [](void* n) { delete static_cast<simgrid::kernel::routing::GraphNodeData*>(n); },
+ [](void* e) { delete static_cast<simgrid::kernel::routing::RouteCreationArgs*>(e); }, nullptr);
}
-void DijkstraZone::seal()
+void DijkstraZone::do_seal()
{
unsigned int cursor;
xbt_node_t node = nullptr;
/* Add the loopback if needed */
if (get_network_model()->loopback_ && hierarchy_ == RoutingMode::base) {
xbt_dynar_foreach (xbt_graph_get_nodes(route_graph_.get()), cursor, node) {
- bool found = false;
+ bool found = false;
xbt_edge_t edge = nullptr;
unsigned int cursor2;
xbt_dynar_foreach (xbt_graph_node_get_outedges(node), cursor2, edge) {
const_xbt_dynar_t nodes = xbt_graph_get_nodes(route_graph_.get());
xbt_dynar_foreach (nodes, cursor, node) {
- auto* data = static_cast<GraphNodeData*>(xbt_graph_node_get_data(node));
- data->graph_id_ = cursor;
+ auto* data = static_cast<GraphNodeData*>(xbt_graph_node_get_data(node));
+ data->graph_id_ = cursor;
}
}
std::vector<int>& pred_arr = elm.first->second;
if (elm.second) { /* new element was inserted (not cached mode, or cache miss) */
- int nr_nodes = xbt_dynar_length(nodes);
+ int nr_nodes = xbt_dynar_length(nodes);
std::vector<double> cost_arr(nr_nodes); /* link cost from src to other hosts */
pred_arr.resize(nr_nodes); /* predecessors in path from src */
using Qelt = std::pair<double, int>;
int v_id = pqueue.top().second;
pqueue.pop();
const s_xbt_node_t* v_node = xbt_dynar_get_as(nodes, v_id, xbt_node_t);
- xbt_edge_t edge = nullptr;
+ xbt_edge_t edge = nullptr;
unsigned int cursor;
xbt_dynar_foreach (xbt_graph_node_get_outedges(v_node), cursor, edge) {
const s_xbt_node_t* u_node = xbt_graph_edge_get_target(edge);
const GraphNodeData* data = static_cast<GraphNodeData*>(xbt_graph_node_get_data(u_node));
- int u_id = data->graph_id_;
+ int u_id = data->graph_id_;
const RouteCreationArgs* tmp_e_route = static_cast<RouteCreationArgs*>(xbt_graph_edge_get_data(edge));
- int cost_v_u = tmp_e_route->link_list.size(); /* count of links, old model assume 1 */
+ int cost_v_u = tmp_e_route->link_list.size(); /* count of links, old model assume 1 */
if (cost_v_u + cost_arr[v_id] < cost_arr[u_id]) {
pred_arr[u_id] = v_id;
const RouteCreationArgs* e_route = static_cast<RouteCreationArgs*>(xbt_graph_edge_get_data(edge));
const NetPoint* prev_gw_src = gw_src;
- gw_src = e_route->gw_src;
- NetPoint* gw_dst = e_route->gw_dst;
+ gw_src = e_route->gw_src;
+ NetPoint* gw_dst = e_route->gw_dst;
if (v == dst_node_id)
first_gw = gw_dst;
namespace kernel {
namespace routing {
-DragonflyZone::DragonflyZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : ClusterZone(father, name, netmodel)
-{
-}
+DragonflyZone::DragonflyZone(const std::string& name) : ClusterZone(name) {}
DragonflyZone::Coords DragonflyZone::rankId_to_coords(int rankId) const
{
}
/* Generate the cluster once every node is created */
-void DragonflyZone::seal()
+void DragonflyZone::do_seal()
{
if (this->num_nodes_per_blade_ == 0) {
return;
*linkdown = nullptr;
LinkCreationArgs linkTemplate;
linkTemplate.bandwidths.push_back(this->bw_ * numlinks);
- linkTemplate.latency = this->lat_;
- linkTemplate.policy = this->sharing_policy_;
- linkTemplate.id = id;
+ linkTemplate.latency = this->lat_;
+ linkTemplate.policy = this->sharing_policy_;
+ linkTemplate.id = id;
sg_platf_new_link(&linkTemplate);
XBT_DEBUG("Generating link %s", linkTemplate.id.c_str());
resource::LinkImpl* link;
for (unsigned int k = j + 1; k < this->num_chassis_per_group_; k++) {
for (unsigned int l = 0; l < this->num_blades_per_chassis_; l++) {
std::string id = "black_link_in_group_" + std::to_string(i) + "_between_chassis_" + std::to_string(j) +
- "_and_" + std::to_string(k) +"_blade_" + std::to_string(l) + "_" + std::to_string(uniqueId);
+ "_and_" + std::to_string(k) + "_blade_" + std::to_string(l) + "_" + std::to_string(uniqueId);
this->generate_link(id, this->num_links_black_, &linkup, &linkdown);
this->routers_[i * num_blades_per_chassis_ * num_chassis_per_group_ + j * num_blades_per_chassis_ + l]
// FIXME: in reality blue links may be attached to several different routers
for (unsigned int i = 0; i < this->num_groups_; i++) {
for (unsigned int j = i + 1; j < this->num_groups_; j++) {
- unsigned int routernumi = i * num_blades_per_chassis_ * num_chassis_per_group_ + j;
- unsigned int routernumj = j * num_blades_per_chassis_ * num_chassis_per_group_ + i;
- std::string id = "blue_link_between_group_"+ std::to_string(i) +"_and_" + std::to_string(j) +"_routers_" +
- std::to_string(routernumi) + "_and_" + std::to_string(routernumj) + "_" + std::to_string(uniqueId);
+ unsigned int routernumi = i * num_blades_per_chassis_ * num_chassis_per_group_ + j;
+ unsigned int routernumj = j * num_blades_per_chassis_ * num_chassis_per_group_ + i;
+ std::string id = "blue_link_between_group_" + std::to_string(i) + "_and_" + std::to_string(j) + "_routers_" +
+ std::to_string(routernumi) + "_and_" + std::to_string(routernumj) + "_" +
+ std::to_string(uniqueId);
this->generate_link(id, this->num_links_blue_, &linkup, &linkdown);
this->routers_[routernumi].blue_link_ = linkup;
XBT_DEBUG("dst : %u group, %u chassis, %u blade, %u node", targetCoords.group, targetCoords.chassis,
targetCoords.blade, targetCoords.node);
- DragonflyRouter* myRouter = &routers_[myCoords.group * (num_chassis_per_group_ * num_blades_per_chassis_) +
+ DragonflyRouter* myRouter = &routers_[myCoords.group * (num_chassis_per_group_ * num_blades_per_chassis_) +
myCoords.chassis * num_blades_per_chassis_ + myCoords.blade];
- DragonflyRouter* targetRouter = &routers_[targetCoords.group * (num_chassis_per_group_ * num_blades_per_chassis_) +
+ DragonflyRouter* targetRouter = &routers_[targetCoords.group * (num_chassis_per_group_ * num_blades_per_chassis_) +
targetCoords.chassis * num_blades_per_chassis_ + targetCoords.blade];
DragonflyRouter* currentRouter = myRouter;
*latency +=
targetRouter->my_nodes_[targetCoords.node * num_links_per_link_ + num_links_per_link_ - 1]->get_latency();
}
-}
-}
-} // namespace
+} // namespace routing
+} // namespace kernel
+} // namespace simgrid
namespace kernel {
namespace routing {
-EmptyZone::EmptyZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : NetZoneImpl(father, name, netmodel)
-{
-}
+EmptyZone::EmptyZone(const std::string& name) : NetZoneImpl(name) {}
EmptyZone::~EmptyZone() = default;
#include "src/surf/network_interface.hpp"
#include "src/surf/xml/platf_private.hpp"
-
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
namespace kernel {
namespace routing {
-FatTreeZone::FatTreeZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : ClusterZone(father, name, netmodel)
+FatTreeZone::FatTreeZone(const std::string& name) : ClusterZone(name)
{
XBT_DEBUG("Creating a new fat tree.");
}
/* This function makes the assumption that parse_specific_arguments() and
* addNodes() have already been called
*/
-void FatTreeZone::seal()
+void FatTreeZone::do_seal()
{
if (this->levels_ == 0) {
return;
int FatTreeZone::connect_node_to_parents(FatTreeNode* node)
{
- auto currentParentNode = this->nodes_.begin();
- int connectionsNumber = 0;
- const int level = node->level;
+ auto currentParentNode = this->nodes_.begin();
+ int connectionsNumber = 0;
+ const int level = node->level;
XBT_DEBUG("We are connecting node %d(%u,%u) to his parents.", node->id, node->level, node->position);
currentParentNode += this->get_level_position(level + 1);
for (unsigned int i = 0; i < this->nodes_by_level_[level + 1]; i++) {
LinkCreationArgs linkTemplate;
if (cluster->limiter_link != 0.0) {
linkTemplate.bandwidths.push_back(cluster->limiter_link);
- linkTemplate.latency = 0;
- linkTemplate.policy = s4u::Link::SharingPolicy::SHARED;
- linkTemplate.id = "limiter_"+std::to_string(id);
+ linkTemplate.latency = 0;
+ linkTemplate.policy = s4u::Link::SharingPolicy::SHARED;
+ linkTemplate.id = "limiter_" + std::to_string(id);
sg_platf_new_link(&linkTemplate);
this->limiter_link_ = s4u::Link::by_name(linkTemplate.id)->get_impl();
}
if (cluster->loopback_bw != 0.0 || cluster->loopback_lat != 0.0) {
linkTemplate.bandwidths.push_back(cluster->loopback_bw);
- linkTemplate.latency = cluster->loopback_lat;
- linkTemplate.policy = s4u::Link::SharingPolicy::FATPIPE;
- linkTemplate.id = "loopback_"+ std::to_string(id);
+ linkTemplate.latency = cluster->loopback_lat;
+ linkTemplate.policy = s4u::Link::SharingPolicy::FATPIPE;
+ linkTemplate.id = "loopback_" + std::to_string(id);
sg_platf_new_link(&linkTemplate);
this->loopback = s4u::Link::by_name(linkTemplate.id)->get_impl();
}
static int uniqueId = 0;
LinkCreationArgs linkTemplate;
linkTemplate.bandwidths.push_back(cluster->bw);
- linkTemplate.latency = cluster->lat;
- linkTemplate.policy = cluster->sharing_policy; // sthg to do with that ?
+ linkTemplate.latency = cluster->lat;
+ linkTemplate.policy = cluster->sharing_policy; // sthg to do with that ?
linkTemplate.id =
"link_from_" + std::to_string(downNode->id) + "_" + std::to_string(upNode->id) + "_" + std::to_string(uniqueId);
sg_platf_new_link(&linkTemplate);
namespace kernel {
namespace routing {
-FloydZone::FloydZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : RoutedZone(father, name, netmodel)
-{
-}
+FloydZone::FloydZone(const std::string& name) : RoutedZone(name) {}
FloydZone::~FloydZone()
{
}
}
-void FloydZone::seal()
+void FloydZone::do_seal()
{
/* set the size of table routing */
unsigned int table_size = get_table_size();
}
}
}
-}
-}
-}
+} // namespace routing
+} // namespace kernel
+} // namespace simgrid
namespace simgrid {
namespace kernel {
namespace routing {
-FullZone::FullZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : RoutedZone(father, name, netmodel)
-{
-}
+FullZone::FullZone(const std::string& name) : RoutedZone(name) {}
-void FullZone::seal()
+void FullZone::do_seal()
{
unsigned int table_size = get_table_size();
{
XBT_DEBUG("full getLocalRoute from %s[%u] to %s[%u]", src->get_cname(), src->id(), dst->get_cname(), dst->id());
- unsigned int table_size = get_table_size();
+ unsigned int table_size = get_table_size();
const RouteCreationArgs* e_route = TO_ROUTE_FULL(src->id(), dst->id());
if (e_route != nullptr) {
TO_ROUTE_FULL(dst->id(), src->id()) = new_extended_route(hierarchy_, gw_src, gw_dst, link_list, false);
}
}
-}
-}
-} // namespace
+} // namespace routing
+} // namespace kernel
+} // namespace simgrid
simgrid::xbt::signal<void(NetPoint&)> NetPoint::on_creation;
-NetPoint::NetPoint(const std::string& name, NetPoint::Type componentType, NetZoneImpl* netzone_p)
- : name_(name), component_type_(componentType), englobing_zone_(netzone_p)
+NetPoint::NetPoint(const std::string& name, NetPoint::Type componentType) : name_(name), component_type_(componentType)
{
- if (netzone_p != nullptr)
- id_ = netzone_p->add_component(this);
- else
- id_ = static_cast<decltype(id_)>(-1);
simgrid::s4u::Engine::get_instance()->netpoint_register(this);
simgrid::kernel::routing::NetPoint::on_creation(*this);
}
+
+NetPoint* NetPoint::set_englobing_zone(NetZoneImpl* netzone_p)
+{
+ englobing_zone_ = netzone_p;
+ if (netzone_p != nullptr)
+ id_ = netzone_p->add_component(this);
+ return this;
}
-}
-} // namespace simgrid::kernel::routing
+
+} // namespace routing
+} // namespace kernel
+} // namespace simgrid
/** @brief Retrieve a netpoint from its name
*
namespace kernel {
namespace routing {
-NetZoneImpl::NetZoneImpl(NetZoneImpl* father, const std::string& name, resource::NetworkModel* network_model)
- : piface_(this), father_(father), name_(name), network_model_(network_model)
+NetZoneImpl::NetZoneImpl(const std::string& name) : piface_(this), name_(name)
{
xbt_assert(nullptr == s4u::Engine::get_instance()->netpoint_by_name_or_null(get_name()),
"Refusing to create a second NetZone called '%s'.", get_cname());
-
- netpoint_ = new NetPoint(name_, NetPoint::Type::NetZone, father_);
- cpu_model_vm_ = static_cast<simgrid::kernel::resource::CpuModel*>(
- simgrid::kernel::EngineImpl::get_instance()->get_default_model(simgrid::kernel::resource::Model::Type::CPU_VM));
- cpu_model_pm_ = static_cast<simgrid::kernel::resource::CpuModel*>(
- simgrid::kernel::EngineImpl::get_instance()->get_default_model(simgrid::kernel::resource::Model::Type::CPU_PM));
- disk_model_ = static_cast<simgrid::kernel::resource::DiskModel*>(
- simgrid::kernel::EngineImpl::get_instance()->get_default_model(simgrid::kernel::resource::Model::Type::DISK));
- host_model_ = static_cast<simgrid::surf::HostModel*>(
- simgrid::kernel::EngineImpl::get_instance()->get_default_model(simgrid::kernel::resource::Model::Type::HOST));
+ netpoint_ = new NetPoint(name_, NetPoint::Type::NetZone);
XBT_DEBUG("NetZone '%s' created with the id '%u'", get_cname(), netpoint_->id());
}
hierarchy_ = RoutingMode::base;
auto* res = new s4u::Host(name);
- res->set_netpoint(new NetPoint(name, NetPoint::Type::Host, this));
+ res->set_netpoint((new NetPoint(name, NetPoint::Type::Host))->set_englobing_zone(this));
cpu_model_pm_->create_cpu(res, speed_per_pstate)->set_core_count(core_amount)->seal();
if (route.gw_dst != dst)
get_global_route(route.gw_dst, dst, links, latency);
}
+
+void NetZoneImpl::seal()
+{
+ do_seal(); // derived class' specific sealing procedure
+ sealed_ = true;
+}
+
+void NetZoneImpl::set_parent(NetZoneImpl* parent)
+{
+ xbt_assert(sealed_ == false, "Impossible to set parent to an already sealed NetZone(%s)", this->get_cname());
+ father_ = parent;
+ netpoint_->set_englobing_zone(father_);
+}
+
+void NetZoneImpl::set_network_model(std::shared_ptr<resource::NetworkModel> netmodel)
+{
+ xbt_assert(sealed_ == false, "Impossible to set network model to an already sealed NetZone(%s)", this->get_cname());
+ network_model_ = std::move(netmodel);
+}
+
+void NetZoneImpl::set_cpu_vm_model(std::shared_ptr<resource::CpuModel> cpu_model)
+{
+ xbt_assert(sealed_ == false, "Impossible to set CPU model to an already sealed NetZone(%s)", this->get_cname());
+ cpu_model_vm_ = std::move(cpu_model);
+}
+
+void NetZoneImpl::set_cpu_pm_model(std::shared_ptr<resource::CpuModel> cpu_model)
+{
+ xbt_assert(sealed_ == false, "Impossible to set CPU model to an already sealed NetZone(%s)", this->get_cname());
+ cpu_model_pm_ = std::move(cpu_model);
+}
+
+void NetZoneImpl::set_disk_model(std::shared_ptr<resource::DiskModel> disk_model)
+{
+ xbt_assert(sealed_ == false, "Impossible to set disk model to an already sealed NetZone(%s)", this->get_cname());
+ disk_model_ = std::move(disk_model);
+}
+
+void NetZoneImpl::set_host_model(std::shared_ptr<surf::HostModel> host_model)
+{
+ xbt_assert(sealed_ == false, "Impossible to set host model to an already sealed NetZone(%s)", this->get_cname());
+ host_model_ = std::move(host_model);
+}
+
} // namespace routing
} // namespace kernel
} // namespace simgrid
/* 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. */
+#include "simgrid/kernel/routing/RoutedZone.hpp"
+#include "simgrid/kernel/routing/NetPoint.hpp"
+#include "src/surf/network_interface.hpp"
+#include "src/surf/xml/platf_private.hpp"
#include "xbt/dict.h"
#include "xbt/graph.h"
#include "xbt/log.h"
#include "xbt/sysdep.h"
-#include "simgrid/kernel/routing/NetPoint.hpp"
-#include "simgrid/kernel/routing/RoutedZone.hpp"
-#include "src/surf/network_interface.hpp"
-#include "src/surf/xml/platf_private.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_routing_generic, surf_route, "Generic implementation of the surf routing");
namespace kernel {
namespace routing {
-RoutedZone::RoutedZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : NetZoneImpl(father, name, netmodel)
-{
-}
+RoutedZone::RoutedZone(const std::string& name) : NetZoneImpl(name) {}
void RoutedZone::get_graph(const s_xbt_graph_t* graph, std::map<std::string, xbt_node_t, std::less<>>* nodes,
std::map<std::string, xbt_edge_t, std::less<>>* edges)
xbt_node_t current;
xbt_node_t previous;
- const char *previous_name;
- const char *current_name;
+ const char* previous_name;
+ const char* current_name;
if (route.gw_src) {
previous = new_xbt_graph_node(graph, route.gw_src->get_cname(), nodes);
gw_dst->get_cname(), dstName);
xbt_assert(not link_list.empty(), "Empty route (between %s@%s and %s@%s) forbidden.", srcName, gw_src->get_cname(),
dstName, gw_dst->get_cname());
- s4u::NetZone::on_route_creation(symmetrical, gw_src, gw_dst, gw_src, gw_dst, link_list);
+ s4u::NetZone::on_route_creation(symmetrical, gw_src, gw_dst, gw_src, gw_dst, link_list);
}
}
} // namespace routing
namespace simgrid {
namespace kernel {
namespace routing {
-TorusZone::TorusZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : ClusterZone(father, name, netmodel)
-{
-}
+TorusZone::TorusZone(const std::string& name) : ClusterZone(name) {}
void TorusZone::create_links_for_node(ClusterCreationArgs* cluster, int id, int rank, unsigned int position)
{
// name of neighbor is not right for non contiguous cluster radicals (as id != rank in this case)
std::string link_id =
std::string(cluster->id) + "_link_from_" + std::to_string(id) + "_to_" + std::to_string(neighbor_rank_id);
- link.id = link_id;
+ link.id = link_id;
link.bandwidths.push_back(cluster->bw);
- link.latency = cluster->lat;
- link.policy = cluster->sharing_policy;
+ link.latency = cluster->lat;
+ link.policy = cluster->sharing_policy;
sg_platf_new_link(&link);
resource::LinkImpl* linkUp;
resource::LinkImpl* linkDown;
if ((current_node / dim_product) % cur_dim != (dst->id() / dim_product) % cur_dim) {
if ((targetCoords[j] > myCoords[j] &&
targetCoords[j] <= myCoords[j] + cur_dim / 2) // Is the target node on the right, without the wrap-around?
- || (myCoords[j] > cur_dim / 2 &&
- (myCoords[j] + cur_dim / 2) % cur_dim >=
- targetCoords[j])) { // Or do we need to use the wrap around to reach it?
+ ||
+ (myCoords[j] > cur_dim / 2 && (myCoords[j] + cur_dim / 2) % cur_dim >=
+ targetCoords[j])) { // Or do we need to use the wrap around to reach it?
if ((current_node / dim_product) % cur_dim == cur_dim - 1)
next_node = (current_node + dim_product - dim_product * cur_dim);
else
route->link_list.push_back(info.first);
}
- info = private_links_.at(linkOffset);
+ info = private_links_.at(linkOffset);
resource::LinkImpl* lnk = use_lnk_up ? info.first : info.second;
route->link_list.push_back(lnk);
return &coords->coords;
}
-VivaldiZone::VivaldiZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : ClusterZone(father, name, netmodel)
-{
-}
+VivaldiZone::VivaldiZone(const std::string& name) : ClusterZone(name) {}
void VivaldiZone::set_peer_link(NetPoint* netpoint, double bw_in, double bw_out, const std::string& coord)
{
new vivaldi::Coords(netpoint, coord);
- std::string link_up = "link_" + netpoint->get_name() + "_UP";
- std::string link_down = "link_" + netpoint->get_name() + "_DOWN";
+ std::string link_up = "link_" + netpoint->get_name() + "_UP";
+ std::string link_down = "link_" + netpoint->get_name() + "_DOWN";
resource::LinkImpl* linkUp =
get_network_model()->create_link(link_up, std::vector<double>(1, bw_out), s4u::Link::SharingPolicy::SHARED);
linkUp->seal();
namespace simgrid {
namespace kernel {
namespace routing {
-WifiZone::WifiZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : RoutedZone(father, name, netmodel)
-{
-}
+WifiZone::WifiZone(const std::string& name) : RoutedZone(name) {}
-void WifiZone::seal()
+void WifiZone::do_seal()
{
const char* AP_name = get_property("access_point");
if (AP_name != nullptr) {
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "cpu_cas01.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Engine.hpp"
#include "simgrid/sg_config.hpp"
#include "src/kernel/EngineImpl.hpp"
#include "src/kernel/resource/profile/Event.hpp"
algo = simgrid::kernel::resource::Model::UpdateAlgo::FULL;
auto cpu_model_pm = std::make_shared<simgrid::kernel::resource::CpuCas01Model>(algo);
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_PM,
- std::move(cpu_model_pm), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_PM, cpu_model_pm,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_cpu_pm_model(cpu_model_pm);
+
auto cpu_model_vm = std::make_shared<simgrid::kernel::resource::CpuCas01Model>(algo);
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_VM,
- std::move(cpu_model_vm), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_VM, cpu_model_vm,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_cpu_vm_model(cpu_model_vm);
}
namespace simgrid {
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "cpu_ti.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Engine.hpp"
#include "src/kernel/EngineImpl.hpp"
#include "src/kernel/resource/profile/Event.hpp"
#include "src/kernel/resource/profile/Profile.hpp"
void CpuTiModel::create_pm_vm_models()
{
auto cpu_model_pm = std::make_shared<CpuTiModel>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_PM,
- std::move(cpu_model_pm), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_PM, cpu_model_pm,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_cpu_pm_model(cpu_model_pm);
auto cpu_model_vm = std::make_shared<CpuTiModel>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_VM,
- std::move(cpu_model_vm), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_VM, cpu_model_vm,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_cpu_vm_model(cpu_model_vm);
}
-CpuTiModel::CpuTiModel() : CpuModel(Model::UpdateAlgo::FULL)
-{
-}
+CpuTiModel::CpuTiModel() : CpuModel(Model::UpdateAlgo::FULL) {}
Cpu* CpuTiModel::create_cpu(s4u::Host* host, const std::vector<double>& speed_per_pstate)
{
#include "disk_s19.hpp"
#include "simgrid/kernel/routing/NetPoint.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
#include "simgrid/s4u/Engine.hpp"
#include "simgrid/s4u/Host.hpp"
#include "src/kernel/EngineImpl.hpp"
void surf_disk_model_init_default()
{
auto disk_model = std::make_shared<simgrid::kernel::resource::DiskS19Model>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::DISK,
- std::move(disk_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::DISK, disk_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_disk_model(disk_model);
}
namespace simgrid {
#include "src/surf/host_clm03.hpp"
#include "simgrid/kernel/routing/NetPoint.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Engine.hpp"
#include "simgrid/sg_config.hpp"
#include "src/kernel/EngineImpl.hpp"
#include "surf/surf.hpp"
{
auto host_model = std::make_shared<simgrid::surf::HostCLM03Model>();
simgrid::config::set_default<bool>("network/crosstraffic", true);
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::HOST,
- std::move(host_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::HOST, host_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_host_model(host_model);
surf_cpu_model_init_Cas01();
surf_network_model_init_LegrandVelho();
}
void surf_host_model_init_compound()
{
auto host_model = std::make_shared<simgrid::surf::HostCLM03Model>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::HOST,
- std::move(host_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::HOST, host_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_host_model(host_model);
}
namespace simgrid {
/* FIXME[donassolo]: getting the network_model from the origin host
* Soon we need to change this function to first get the routes and later
* create the respective surf actions */
- auto* net_model = host_list[0]->get_netpoint()->get_englobing_zone()->get_network_model();
+ auto net_model = host_list[0]->get_netpoint()->get_englobing_zone()->get_network_model();
if ((host_list.size() == 1) && (has_cost(bytes_amount, 0) <= 0) && (has_cost(flops_amount, 0) > 0)) {
action = host_list[0]->pimpl_cpu->execution_start(flops_amount[0]);
} else if ((host_list.size() == 1) && (has_cost(flops_amount, 0) <= 0)) {
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "src/surf/network_cm02.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Engine.hpp"
#include "simgrid/s4u/Host.hpp"
#include "simgrid/sg_config.hpp"
#include "src/kernel/EngineImpl.hpp"
void surf_network_model_init_LegrandVelho()
{
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkCm02Model>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK,
- std::move(net_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK, net_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
simgrid::config::set_default<double>("network/latency-factor", 13.01);
simgrid::config::set_default<double>("network/bandwidth-factor", 0.97);
simgrid::config::set_default<double>("network/weight-S", 0.0);
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkCm02Model>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK,
- std::move(net_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK, net_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
}
namespace simgrid {
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "network_constant.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Engine.hpp"
#include "src/kernel/EngineImpl.hpp"
#include "src/surf/surf_interface.hpp"
#include "surf/surf.hpp"
void surf_network_model_init_Constant()
{
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkConstantModel>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK,
- std::move(net_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK, net_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
}
namespace simgrid {
namespace kernel {
namespace resource {
-NetworkConstantModel::NetworkConstantModel() : NetworkModel(Model::UpdateAlgo::FULL)
-{
-}
+NetworkConstantModel::NetworkConstantModel() : NetworkModel(Model::UpdateAlgo::FULL) {}
LinkImpl* NetworkConstantModel::create_link(const std::string& name, const std::vector<double>& /*bandwidth*/,
s4u::Link::SharingPolicy)
using simgrid::kernel::resource::NetworkIBModel;
static int id = 0;
- auto* ibModel = static_cast<NetworkIBModel*>(host.get_netpoint()->get_englobing_zone()->get_network_model());
+ auto* ibModel = static_cast<NetworkIBModel*>(host.get_netpoint()->get_englobing_zone()->get_network_model().get());
ibModel->active_nodes.emplace(host.get_name(), IBNode(id));
id++;
}
void surf_network_model_init_IB()
{
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkIBModel>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK,
- std::move(net_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK, net_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
simgrid::s4u::Link::on_communication_state_change.connect(IB_action_state_changed_callback);
simgrid::s4u::Link::on_communicate.connect(IB_action_init_callback);
#include "ns3/ns3_simulator.hpp"
#include "simgrid/kernel/routing/NetPoint.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
#include "simgrid/kernel/routing/WifiZone.hpp"
#include "simgrid/plugins/energy.h"
#include "simgrid/s4u/Engine.hpp"
void surf_network_model_init_NS3()
{
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkNS3Model>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK,
- std::move(net_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK, net_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
}
static simgrid::config::Flag<std::string>
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "network_smpi.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Engine.hpp"
#include "simgrid/sg_config.hpp"
#include "smpi_utils.hpp"
#include "src/kernel/EngineImpl.hpp"
void surf_network_model_init_SMPI()
{
auto net_model = std::make_shared<simgrid::kernel::resource::NetworkSmpiModel>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK,
- std::move(net_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::NETWORK, net_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
simgrid::config::set_default<double>("network/weight-S", 8775);
}
namespace kernel {
namespace resource {
-NetworkSmpiModel::NetworkSmpiModel() : NetworkCm02Model()
-{
-}
+NetworkSmpiModel::NetworkSmpiModel() : NetworkCm02Model() {}
double NetworkSmpiModel::get_bandwidth_factor(double size)
{
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "ptask_L07.hpp"
+#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Engine.hpp"
#include "src/kernel/EngineImpl.hpp"
#include "src/kernel/resource/profile/Event.hpp"
#include "surf/surf.hpp"
XBT_CINFO(xbt_cfg, "Switching to the L07 model to handle parallel tasks.");
auto host_model = std::make_shared<simgrid::surf::HostL07Model>();
- simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::HOST,
- std::move(host_model), true);
+ simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::HOST, host_model,
+ true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_host_model(host_model);
}
namespace simgrid {
auto net_model = std::make_shared<NetworkL07Model>(this, maxmin_system);
auto engine = simgrid::kernel::EngineImpl::get_instance();
- engine->add_model(simgrid::kernel::resource::Model::Type::NETWORK, std::move(net_model), true);
+ engine->add_model(simgrid::kernel::resource::Model::Type::NETWORK, net_model, true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_network_model(net_model);
auto cpu_model = std::make_shared<CpuL07Model>(this, maxmin_system);
- engine->add_model(simgrid::kernel::resource::Model::Type::CPU_PM, std::move(cpu_model), true);
+ engine->add_model(simgrid::kernel::resource::Model::Type::CPU_PM, cpu_model, true);
+ simgrid::s4u::Engine::get_instance()->get_netzone_root()->get_impl()->set_cpu_pm_model(cpu_model);
}
CpuL07Model::CpuL07Model(HostL07Model* hmodel, kernel::lmm::System* sys)
xbt_assert(nullptr == simgrid::s4u::Engine::get_instance()->netpoint_by_name_or_null(name),
"Refusing to create a router named '%s': this name already describes a node.", name.c_str());
- auto* netpoint =
- new simgrid::kernel::routing::NetPoint(name, simgrid::kernel::routing::NetPoint::Type::Router, current_routing);
+ auto* netpoint = new simgrid::kernel::routing::NetPoint(name, simgrid::kernel::routing::NetPoint::Type::Router);
+ netpoint->set_englobing_zone(current_routing);
XBT_DEBUG("Router '%s' has the id %u", netpoint->get_cname(), netpoint->id());
if (coords && strcmp(coords, ""))
}
/**
- * @brief Add a Zone to the platform
- *
- * Add a new autonomous system to the platform. Any elements (such as host, router or sub-Zone) added after this call
- * and before the corresponding call to sg_platf_new_Zone_seal() will be added to this Zone.
- *
- * Once this function was called, the configuration concerning the used models cannot be changed anymore.
+ * @brief Auxiliary function to build the object NetZoneImpl
*
+ * Builds the objects, setting its father properties and root netzone if needed
* @param zone the parameters defining the Zone to build.
+ * @return Pointer to recently created netzone
*/
-simgrid::kernel::routing::NetZoneImpl* sg_platf_new_Zone_begin(const simgrid::kernel::routing::ZoneCreationArgs* zone)
+static simgrid::kernel::routing::NetZoneImpl*
+sg_platf_create_zone(const simgrid::kernel::routing::ZoneCreationArgs* zone)
{
- if (not surf_parse_models_setup_already_called) {
- simgrid::s4u::Engine::on_platform_creation();
-
- /* Initialize the surf models. That must be done after we got all config, and before we need the models.
- * That is, after the last <config> tag, if any, and before the first of cluster|peer|zone|trace|trace_connect
- *
- * I'm not sure for <trace> and <trace_connect>, there may be a bug here
- * (FIXME: check it out by creating a file beginning with one of these tags)
- * but cluster and peer come down to zone creations, so putting this verification here is correct.
- */
- surf_parse_models_setup_already_called = 1;
- surf_config_models_setup();
- }
-
- _sg_cfg_init_status = 2; /* HACK: direct access to the global controlling the level of configuration to prevent
- * any further config now that we created some real content */
-
/* search the routing model */
simgrid::kernel::routing::NetZoneImpl* new_zone = nullptr;
- simgrid::kernel::resource::NetworkModel* netmodel =
- current_routing == nullptr ? static_cast<simgrid::kernel::resource::NetworkModel*>(
- simgrid::kernel::EngineImpl::get_instance()->get_default_model(
- simgrid::kernel::resource::Model::Type::NETWORK))
- : current_routing->get_network_model();
if (strcasecmp(zone->routing.c_str(), "Cluster") == 0) {
- new_zone = new simgrid::kernel::routing::ClusterZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::ClusterZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "ClusterDragonfly") == 0) {
- new_zone = new simgrid::kernel::routing::DragonflyZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::DragonflyZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "ClusterTorus") == 0) {
- new_zone = new simgrid::kernel::routing::TorusZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::TorusZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "ClusterFatTree") == 0) {
- new_zone = new simgrid::kernel::routing::FatTreeZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::FatTreeZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "Dijkstra") == 0) {
- new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, netmodel, false);
+ new_zone = new simgrid::kernel::routing::DijkstraZone(zone->id, false);
} else if (strcasecmp(zone->routing.c_str(), "DijkstraCache") == 0) {
- new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, netmodel, true);
+ new_zone = new simgrid::kernel::routing::DijkstraZone(zone->id, true);
} else if (strcasecmp(zone->routing.c_str(), "Floyd") == 0) {
- new_zone = new simgrid::kernel::routing::FloydZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::FloydZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "Full") == 0) {
- new_zone = new simgrid::kernel::routing::FullZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::FullZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "None") == 0) {
- new_zone = new simgrid::kernel::routing::EmptyZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::EmptyZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "Vivaldi") == 0) {
- new_zone = new simgrid::kernel::routing::VivaldiZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::VivaldiZone(zone->id);
} else if (strcasecmp(zone->routing.c_str(), "Wifi") == 0) {
- new_zone = new simgrid::kernel::routing::WifiZone(current_routing, zone->id, netmodel);
+ new_zone = new simgrid::kernel::routing::WifiZone(zone->id);
} else {
xbt_die("Not a valid model!");
}
+ new_zone->set_parent(current_routing);
if (current_routing == nullptr) { /* it is the first one */
simgrid::s4u::Engine::get_instance()->set_netzone_root(new_zone->get_iface());
current_routing->hierarchy_ = simgrid::kernel::routing::NetZoneImpl::RoutingMode::recursive;
/* add to the sons dictionary */
current_routing->get_children()->push_back(new_zone);
+ /* set models from parent netzone */
+ new_zone->set_network_model(current_routing->get_network_model());
+ new_zone->set_cpu_pm_model(current_routing->get_cpu_pm_model());
+ new_zone->set_cpu_vm_model(current_routing->get_cpu_vm_model());
+ new_zone->set_disk_model(current_routing->get_disk_model());
+ new_zone->set_host_model(current_routing->get_host_model());
+ }
+ return new_zone;
+}
+
+/**
+ * @brief Add a Zone to the platform
+ *
+ * Add a new autonomous system to the platform. Any elements (such as host, router or sub-Zone) added after this call
+ * and before the corresponding call to sg_platf_new_Zone_seal() will be added to this Zone.
+ *
+ * Once this function was called, the configuration concerning the used models cannot be changed anymore.
+ *
+ * @param zone the parameters defining the Zone to build.
+ */
+simgrid::kernel::routing::NetZoneImpl* sg_platf_new_Zone_begin(const simgrid::kernel::routing::ZoneCreationArgs* zone)
+{
+ /* First create the zone.
+ * This order is important to assure that root netzone is set when models are setting
+ * the default mode for each resource (CPU, network, etc)
+ */
+ auto* new_zone = sg_platf_create_zone(zone);
+
+ if (not surf_parse_models_setup_already_called) {
+ simgrid::s4u::Engine::on_platform_creation();
+
+ /* Initialize the surf models. That must be done after we got all config, and before we need the models.
+ * That is, after the last <config> tag, if any, and before the first of cluster|peer|zone|trace|trace_connect
+ *
+ * I'm not sure for <trace> and <trace_connect>, there may be a bug here
+ * (FIXME: check it out by creating a file beginning with one of these tags)
+ * but cluster and peer come down to zone creations, so putting this verification here is correct.
+ */
+ surf_parse_models_setup_already_called = 1;
+ surf_config_models_setup();
}
+ _sg_cfg_init_status = 2; /* HACK: direct access to the global controlling the level of configuration to prevent
+ * any further config now that we created some real content */
+
/* set the new current component of the tree */
current_routing = new_zone;
simgrid::s4u::NetZone::on_creation(*new_zone->get_iface()); // notify the signal
xbt_assert(argc > 1, "Usage: %s platform.xml\n", argv[0]);
parse_platform_file(argv[1]);
- const_sg_netzone_t as_zone = sg_zone_get_by_name("AS0");
- simgrid::kernel::resource::NetworkModel* net_model = as_zone->get_impl()->get_network_model();
- simgrid::kernel::resource::CpuModel* cpu_model_pm = as_zone->get_impl()->get_cpu_pm_model();
+ const_sg_netzone_t as_zone = sg_zone_get_by_name("AS0");
+ auto net_model = as_zone->get_impl()->get_network_model();
+ auto cpu_model_pm = as_zone->get_impl()->get_cpu_pm_model();
- XBT_DEBUG("CPU model: %p", cpu_model_pm);
- XBT_DEBUG("Network model: %p", net_model);
+ XBT_DEBUG("CPU model: %p", cpu_model_pm.get());
+ XBT_DEBUG("Network model: %p", net_model.get());
simgrid::s4u::Host* hostA = sg_host_by_name("Cpu A");
simgrid::s4u::Host* hostB = sg_host_by_name("Cpu B");
hostB->pimpl_cpu->execution_start(1000.0);
hostB->pimpl_cpu->sleep(7.32);
- const_sg_netzone_t as_zone = sg_zone_get_by_name("AS0");
- simgrid::kernel::resource::NetworkModel* net_model = as_zone->get_impl()->get_network_model();
+ const_sg_netzone_t as_zone = sg_zone_get_by_name("AS0");
+ auto net_model = as_zone->get_impl()->get_network_model();
net_model->communicate(hostA, hostB, 150.0, -1.0);
surf_solve(-1.0); /* Takes traces into account. Returns 0.0 */