#include "simgrid/s4u/Storage.hpp"
#include "src/kernel/EngineImpl.hpp"
-#include "src/simix/smx_private.h"
+#include "src/simix/smx_private.hpp"
#include "src/include/simgrid/sg_config.h"
if(cluster->loopback_bw > 0 || cluster->loopback_lat > 0){
current_as->linkCountPerNode_++;
- current_as->hasLoopback_ = 1;
+ current_as->hasLoopback_ = true;
}
if(cluster->limiter_link > 0){
current_as->linkCountPerNode_++;
- current_as->hasLimiter_ = 1;
+ current_as->hasLimiter_ = true;
}
for (int const& i : *cluster->radicals) {
XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id.c_str(), cluster->speeds.front());
s_sg_platf_host_cbarg_t host;
- memset(&host, 0, sizeof(host));
host.id = host_id.c_str();
if ((cluster->properties != nullptr) && (not cluster->properties->empty())) {
host.properties = new std::map<std::string, std::string>;
linkDown = simgrid::surf::LinkImpl::byName(tmp_link);
auto as_cluster = static_cast<ClusterZone*>(current_as);
- as_cluster->privateLinks_.insert({rankId * as_cluster->linkCountPerNode_, {linkUp, linkDown}});
+ as_cluster->privateLinks_.insert({as_cluster->nodePosition(rankId), {linkUp, linkDown}});
}
//add a limiter link (shared link to account for maximal bandwidth of the node)
sg_platf_new_link(&link);
linkDown = simgrid::surf::LinkImpl::byName(tmp_link);
linkUp = linkDown;
- current_as->privateLinks_.insert(
- {rankId * current_as->linkCountPerNode_ + current_as->hasLoopback_, {linkUp, linkDown}});
+ current_as->privateLinks_.insert({current_as->nodePositionWithLoopback(rankId), {linkUp, linkDown}});
}
//call the cluster function that adds the others links
if (cluster->topology == SURF_CLUSTER_FAT_TREE) {
static_cast<FatTreeZone*>(current_as)->addProcessingNode(i);
} else {
- current_as->create_links_for_node(cluster, i, rankId,
- rankId*current_as->linkCountPerNode_ + current_as->hasLoopback_ + current_as->hasLimiter_ );
+ current_as->create_links_for_node(cluster, i, rankId, current_as->nodePositionWithLimiter(rankId));
}
rankId++;
}
for (int const& radical : *cabinet->radicals) {
std::string hostname = cabinet->prefix + std::to_string(radical) + cabinet->suffix;
s_sg_platf_host_cbarg_t host;
- memset(&host, 0, sizeof(host));
host.pstate = 0;
host.core_amount = 1;
host.id = hostname.c_str();
/* Pick the right models for CPU, net and host, and call their model_init_preparse */
static void surf_config_models_setup()
{
- const char* host_model_name = xbt_cfg_get_string("host/model");
- const char* network_model_name = xbt_cfg_get_string("network/model");
- const char* cpu_model_name = xbt_cfg_get_string("cpu/model");
- const char* storage_model_name = xbt_cfg_get_string("storage/model");
+ std::string host_model_name = xbt_cfg_get_string("host/model");
+ std::string network_model_name = xbt_cfg_get_string("network/model");
+ std::string cpu_model_name = xbt_cfg_get_string("cpu/model");
+ std::string storage_model_name = xbt_cfg_get_string("storage/model");
/* The compound host model is needed when using non-default net/cpu models */
if ((not xbt_cfg_is_default_value("network/model") || not xbt_cfg_is_default_value("cpu/model")) &&
xbt_cfg_is_default_value("host/model")) {
host_model_name = "compound";
- xbt_cfg_set_string("host/model", host_model_name);
+ xbt_cfg_set_string("host/model", host_model_name.c_str());
}
- XBT_DEBUG("host model: %s", host_model_name);
- if (not strcmp(host_model_name, "compound")) {
- xbt_assert(cpu_model_name, "Set a cpu model to use with the 'compound' host model");
- xbt_assert(network_model_name, "Set a network model to use with the 'compound' host model");
+ XBT_DEBUG("host model: %s", host_model_name.c_str());
+ if (host_model_name == "compound") {
+ xbt_assert(not cpu_model_name.empty(), "Set a cpu model to use with the 'compound' host model");
+ xbt_assert(not network_model_name.empty(), "Set a network model to use with the 'compound' host model");
int cpu_id = find_model_description(surf_cpu_model_description, cpu_model_name);
surf_cpu_model_description[cpu_id].model_init_preparse();
new_zone = new simgrid::kernel::routing::FatTreeZone(current_routing, zone->id);
break;
case A_surfxml_AS_routing_Dijkstra:
- new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, 0);
+ new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, false);
break;
case A_surfxml_AS_routing_DijkstraCache:
- new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, 1);
+ new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, true);
break;
case A_surfxml_AS_routing_Floyd:
new_zone = new simgrid::kernel::routing::FloydZone(current_routing, zone->id);
if (as_cluster->privateLinks_.find(netpoint->id()) != as_cluster->privateLinks_.end())
surf_parse_error(std::string("Host_link for '") + hostlink->id.c_str() + "' is already defined!");
- XBT_DEBUG("Push Host_link for host '%s' to position %u", netpoint->cname(), netpoint->id());
+ XBT_DEBUG("Push Host_link for host '%s' to position %u", netpoint->getCname(), netpoint->id());
as_cluster->privateLinks_.insert({netpoint->id(), {linkUp, linkDown}});
}