XBT_PRIVATE std::vector<std::string> known_storages;
namespace simgrid {
-namespace surf {
-
-simgrid::xbt::signal<void(kernel::routing::ClusterCreationArgs const&)> on_cluster;
-}
-}
+namespace kernel {
+namespace routing {
+xbt::signal<void(ClusterCreationArgs const&)> on_cluster_creation;
+} // namespace routing
+} // namespace kernel
+} // namespace simgrid
static int surf_parse_models_setup_already_called = 0;
std::map<std::string, simgrid::kernel::resource::StorageType*> storage_types;
/** Module management function: creates all internal data structures */
void sg_platf_init()
{
- simgrid::s4u::on_platform_created.connect(check_disk_attachment);
+ simgrid::s4u::Engine::on_platform_created.connect(check_disk_attachment);
}
/** Module management function: frees all internal data structures */
void sg_platf_exit() {
- simgrid::surf::on_cluster.disconnect_slots();
- simgrid::s4u::on_platform_created.disconnect_slots();
+ simgrid::kernel::routing::on_cluster_creation.disconnect_slots();
+ simgrid::s4u::Engine::on_platform_created.disconnect_slots();
/* make sure that we will reinit the models while loading the platf once reinited */
surf_parse_models_setup_already_called = 0;
host->pimpl_->storage_ = mount_list;
mount_list.clear();
+ host->pimpl_->disks_ = std::move(args->disks);
+ for (auto d : host->pimpl_->disks_)
+ d->set_host(host);
+
/* Change from the defaults */
if (args->state_trace)
- host->pimpl_cpu->set_state_profile(args->state_trace);
+ host->set_state_profile(args->state_trace);
if (args->speed_trace)
- host->pimpl_cpu->set_speed_profile(args->speed_trace);
+ host->set_speed_profile(args->speed_trace);
if (args->pstate != 0)
- host->pimpl_cpu->set_pstate(args->pstate);
+ host->set_pstate(args->pstate);
if (not args->coord.empty())
- new simgrid::kernel::routing::vivaldi::Coords(host->pimpl_netpoint, args->coord);
+ new simgrid::kernel::routing::vivaldi::Coords(host->get_netpoint(), args->coord);
}
/** @brief Add a "router" to the network element list */
XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id.c_str(), cluster->speeds.front());
simgrid::kernel::routing::HostCreationArgs host;
- host.id = host_id.c_str();
+ host.id = host_id;
if ((cluster->properties != nullptr) && (not cluster->properties->empty())) {
- host.properties = new std::unordered_map<std::string, std::string>;
+ host.properties = new std::unordered_map<std::string, std::string>();
for (auto const& elm : *cluster->properties)
host.properties->insert({elm.first, elm.second});
// other columns are to store one or more link for the node
//add a loopback link
- simgrid::s4u::Link* linkUp = nullptr;
- simgrid::s4u::Link* linkDown = nullptr;
+ const simgrid::s4u::Link* linkUp = nullptr;
+ const simgrid::s4u::Link* linkDown = nullptr;
if(cluster->loopback_bw > 0 || cluster->loopback_lat > 0){
std::string tmp_link = link_id + "_loopback";
XBT_DEBUG("<loopback\tid=\"%s\"\tbw=\"%f\"/>", tmp_link.c_str(), cluster->loopback_bw);
//Make the backbone
if ((cluster->bb_bw > 0) || (cluster->bb_lat > 0)) {
-
simgrid::kernel::routing::LinkCreationArgs link;
link.id = std::string(cluster->id)+ "_backbone";
link.bandwidths.push_back(cluster->bb_bw);
XBT_DEBUG("</AS>");
sg_platf_new_Zone_seal();
- simgrid::surf::on_cluster(*cluster);
+ simgrid::kernel::routing::on_cluster_creation(*cluster);
delete cluster->radicals;
}
simgrid::kernel::routing::HostCreationArgs host;
host.pstate = 0;
host.core_amount = 1;
- host.id = hostname.c_str();
+ host.id = hostname;
host.speed_per_pstate.push_back(cabinet->speed);
sg_platf_new_host(&host);
delete cabinet->radicals;
}
-void sg_platf_new_disk(simgrid::kernel::routing::DiskCreationArgs* disk)
+simgrid::kernel::resource::DiskImpl* sg_platf_new_disk(simgrid::kernel::routing::DiskCreationArgs* disk)
{
- auto s = surf_disk_model->createDisk(disk->id, disk->read_bw, disk->write_bw);
-
+ simgrid::kernel::resource::DiskImpl* d = surf_disk_model->createDisk(disk->id, disk->read_bw, disk->write_bw);
if (disk->properties) {
- s->set_properties(*disk->properties);
+ d->set_properties(*disk->properties);
delete disk->properties;
}
+ simgrid::s4u::Disk::on_creation(*d->get_iface());
+ return d;
}
void sg_platf_new_storage(simgrid::kernel::routing::StorageCreationArgs* storage)
xbt_assert(std::find(known_storages.begin(), known_storages.end(), storage->id) == known_storages.end(),
"Refusing to add a second storage named \"%s\"", storage->id.c_str());
- simgrid::kernel::resource::StorageType* stype;
+ const simgrid::kernel::resource::StorageType* stype;
auto st = storage_types.find(storage->type_id);
if (st != storage_types.end()) {
stype = st->second;
}
xbt_die("%s", msg.c_str());
}
- simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(actor->function);
+ const simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(actor->function);
xbt_assert(factory, "Error while creating an actor from the XML file: Function '%s' not registered", actor->function);
double start_time = actor->start_time;
double kill_time = actor->kill_time;
- bool auto_restart = actor->on_failure != simgrid::kernel::routing::ActorOnFailure::DIE;
+ bool auto_restart = actor->restart_on_failure;
std::string actor_name = actor->args[0];
simgrid::simix::ActorCode code = factory(std::move(actor->args));
simgrid::kernel::actor::ProcessArg* arg =
new simgrid::kernel::actor::ProcessArg(actor_name, code, nullptr, host, kill_time, properties, auto_restart);
- host->pimpl_->actors_at_boot_.emplace_back(arg);
+ host->pimpl_->add_actor_at_boot(arg);
if (start_time > SIMIX_get_clock()) {
-
arg = new simgrid::kernel::actor::ProcessArg(actor_name, code, nullptr, host, kill_time, properties, auto_restart);
XBT_DEBUG("Process %s@%s will be started at time %f", arg->name.c_str(), arg->host->get_cname(), start_time);
std::vector<double> speed_per_pstate;
speed_per_pstate.push_back(peer->speed);
- simgrid::s4u::Host* host = as->create_host(peer->id.c_str(), speed_per_pstate, 1, nullptr);
+ simgrid::s4u::Host* host = as->create_host(peer->id, speed_per_pstate, 1, nullptr);
- as->set_peer_link(host->pimpl_netpoint, peer->bw_in, peer->bw_out, peer->coord);
+ as->set_peer_link(host->get_netpoint(), peer->bw_in, peer->bw_out, peer->coord);
/* Change from the defaults */
if (peer->state_trace)
- host->pimpl_cpu->set_state_profile(peer->state_trace);
+ host->set_state_profile(peer->state_trace);
if (peer->speed_trace)
- host->pimpl_cpu->set_speed_profile(peer->speed_trace);
+ host->set_speed_profile(peer->speed_trace);
}
/* Pick the right models for CPU, net and host, and call their model_init_preparse */
std::string host_model_name = simgrid::config::get_value<std::string>("host/model");
std::string network_model_name = simgrid::config::get_value<std::string>("network/model");
std::string cpu_model_name = simgrid::config::get_value<std::string>("cpu/model");
+ std::string disk_model_name = simgrid::config::get_value<std::string>("disk/model");
std::string storage_model_name = simgrid::config::get_value<std::string>("storage/model");
/* The compound host model is needed when using non-default net/cpu models */
XBT_DEBUG("Call vm_model_init");
surf_vm_model_init_HL13();
+ XBT_DEBUG("Call disk_model_init");
+ int disk_id = find_model_description(surf_disk_model_description, disk_model_name);
+ surf_disk_model_description[disk_id].model_init_preparse();
+
XBT_DEBUG("Call storage_model_init");
int storage_id = find_model_description(surf_storage_model_description, storage_model_name);
surf_storage_model_description[storage_id].model_init_preparse();
simgrid::kernel::routing::NetZoneImpl* sg_platf_new_Zone_begin(simgrid::kernel::routing::ZoneCreationArgs* zone)
{
if (not surf_parse_models_setup_already_called) {
- simgrid::s4u::on_platform_creation();
+ 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
return new_zone;
}
+void sg_platf_new_Zone_set_properties(std::unordered_map<std::string, std::string>* props)
+{
+ xbt_assert(current_routing, "Cannot set properties of the current Zone: none under construction");
+
+ if (props)
+ current_routing->set_properties(*props);
+}
+
/**
* @brief Specify that the description of the current AS is finished
*
/** @brief Add a link connecting a host to the rest of its AS (which must be cluster or vivaldi) */
void sg_platf_new_hostlink(simgrid::kernel::routing::HostLinkCreationArgs* hostlink)
{
- simgrid::kernel::routing::NetPoint* netpoint = simgrid::s4u::Host::by_name(hostlink->id)->pimpl_netpoint;
+ simgrid::kernel::routing::NetPoint* netpoint = simgrid::s4u::Host::by_name(hostlink->id)->get_netpoint();
xbt_assert(netpoint, "Host '%s' not found!", hostlink->id.c_str());
xbt_assert(dynamic_cast<simgrid::kernel::routing::ClusterZone*>(current_routing),
"Only hosts from Cluster and Vivaldi ASes can get a host_link.");
- simgrid::s4u::Link* linkUp = simgrid::s4u::Link::by_name_or_null(hostlink->link_up);
- simgrid::s4u::Link* linkDown = simgrid::s4u::Link::by_name_or_null(hostlink->link_down);
+ const simgrid::s4u::Link* linkUp = simgrid::s4u::Link::by_name_or_null(hostlink->link_up);
+ const simgrid::s4u::Link* linkDown = simgrid::s4u::Link::by_name_or_null(hostlink->link_down);
xbt_assert(linkUp, "Link '%s' not found!", hostlink->link_up.c_str());
xbt_assert(linkDown, "Link '%s' not found!", hostlink->link_down.c_str());
