Extends the work done in previous commit for other NetZone classes.
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,
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
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;
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;
*/
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;
*/
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;
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 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;
namespace simgrid {
namespace kernel {
namespace routing {
-ClusterZone::ClusterZone(NetZoneImpl* father, const std::string& name, resource::NetworkModel* netmodel)
- : NetZoneImpl(name)
-{
-}
+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::do_seal()
/* 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
{
*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(name)
-{
-}
+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.");
}
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()
{
}
}
}
-}
-}
-}
+} // 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::do_seal()
{
{
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
void NetZoneImpl::set_parent(NetZoneImpl* parent)
{
- xbt_assert(sealed_ == false, "Impossible to set father to an already sealed NetZone(%s)", this->get_cname());
+ 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(simgrid::kernel::resource::NetworkModel* netmodel)
{
+ xbt_assert(sealed_ == false, "Impossible to set network model to an already sealed NetZone(%s)", this->get_cname());
network_model_ = netmodel;
}
/* 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(name)
-{
-}
+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::do_seal()
{
: 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!");
}
