X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/88fad0aaff9eb463f048bfdfe4ad6218aba44ddb..1d17c885aa26ea6c36c1fc0c6ab39ddd5d509755:/src/surf/sg_platf.cpp

diff --git a/src/surf/sg_platf.cpp b/src/surf/sg_platf.cpp
index 6718257610..9f71bc53b4 100644
--- a/src/surf/sg_platf.cpp
+++ b/src/surf/sg_platf.cpp
@@ -15,13 +15,11 @@
 #include "simgrid/kernel/routing/TorusZone.hpp"
 #include "simgrid/kernel/routing/VivaldiZone.hpp"
 #include "simgrid/s4u/Engine.hpp"
-#include "simgrid/s4u/Storage.hpp"
 #include "src/include/simgrid/sg_config.hpp"
 #include "src/kernel/EngineImpl.hpp"
+#include "src/simix/smx_host_private.hpp"
 #include "src/simix/smx_private.hpp"
 #include "src/surf/HostImpl.hpp"
-#include "src/surf/cpu_interface.hpp"
-#include "src/surf/network_interface.hpp"
 #include "src/surf/xml/platf_private.hpp"
 
 #include <string>
@@ -50,7 +48,8 @@ static simgrid::kernel::routing::NetZoneImpl* routing_get_current()
 
 /** Module management function: creates all internal data structures */
 void sg_platf_init()
-{ /* Do nothing: just for symmetry of user code */
+{
+  simgrid::s4u::onPlatformCreated.connect(check_disk_attachment);
 }
 
 /** Module management function: frees all internal data structures */
@@ -74,7 +73,7 @@ void sg_platf_new_host(simgrid::kernel::routing::HostCreationArgs* args)
   }
 
   simgrid::s4u::Host* host =
-      routing_get_current()->createHost(args->id, &args->speed_per_pstate, args->core_amount, &props);
+      routing_get_current()->create_host(args->id, &args->speed_per_pstate, args->core_amount, &props);
 
   host->pimpl_->storage_ = mount_list;
   mount_list.clear();
@@ -83,7 +82,7 @@ void sg_platf_new_host(simgrid::kernel::routing::HostCreationArgs* args)
   if (args->state_trace)
     host->pimpl_cpu->setStateTrace(args->state_trace);
   if (args->speed_trace)
-    host->pimpl_cpu->setSpeedTrace(args->speed_trace);
+    host->pimpl_cpu->set_speed_trace(args->speed_trace);
   if (args->pstate != 0)
     host->pimpl_cpu->setPState(args->pstate);
   if (args->coord && strcmp(args->coord, ""))
@@ -115,14 +114,14 @@ void sg_platf_new_link(simgrid::kernel::routing::LinkCreationArgs* link)
 {
   std::vector<std::string> names;
 
-  if (link->policy == SURF_LINK_SPLITDUPLEX) {
+  if (link->policy == simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX) {
     names.push_back(link->id+ "_UP");
     names.push_back(link->id+ "_DOWN");
   } else {
     names.push_back(link->id);
   }
   for (auto const& link_name : names) {
-    simgrid::surf::LinkImpl* l =
+    simgrid::kernel::resource::LinkImpl* l =
         surf_network_model->createLink(link_name, link->bandwidth, link->latency, link->policy);
 
     if (link->properties) {
@@ -211,8 +210,8 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
     // other columns are to store one or more link for the node
 
     //add a loopback link
-    simgrid::surf::LinkImpl* linkUp   = nullptr;
-    simgrid::surf::LinkImpl* linkDown = nullptr;
+    simgrid::kernel::resource::LinkImpl* linkUp   = nullptr;
+    simgrid::kernel::resource::LinkImpl* 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);
@@ -221,13 +220,13 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
       link.id        = tmp_link;
       link.bandwidth = cluster->loopback_bw;
       link.latency   = cluster->loopback_lat;
-      link.policy    = SURF_LINK_FATPIPE;
+      link.policy    = simgrid::s4u::Link::SharingPolicy::FATPIPE;
       sg_platf_new_link(&link);
-      linkUp   = simgrid::surf::LinkImpl::byName(tmp_link);
-      linkDown = simgrid::surf::LinkImpl::byName(tmp_link);
+      linkUp   = simgrid::kernel::resource::LinkImpl::byName(tmp_link);
+      linkDown = simgrid::kernel::resource::LinkImpl::byName(tmp_link);
 
       auto* as_cluster = static_cast<ClusterZone*>(current_as);
-      as_cluster->private_links_.insert({as_cluster->nodePosition(rankId), {linkUp, linkDown}});
+      as_cluster->private_links_.insert({as_cluster->node_pos(rankId), {linkUp, linkDown}});
     }
 
     //add a limiter link (shared link to account for maximal bandwidth of the node)
@@ -241,18 +240,18 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
       link.id        = tmp_link;
       link.bandwidth = cluster->limiter_link;
       link.latency = 0;
-      link.policy = SURF_LINK_SHARED;
+      link.policy    = simgrid::s4u::Link::SharingPolicy::SHARED;
       sg_platf_new_link(&link);
-      linkDown = simgrid::surf::LinkImpl::byName(tmp_link);
+      linkDown = simgrid::kernel::resource::LinkImpl::byName(tmp_link);
       linkUp   = linkDown;
-      current_as->private_links_.insert({current_as->nodePositionWithLoopback(rankId), {linkUp, linkDown}});
+      current_as->private_links_.insert({current_as->node_pos_with_loopback(rankId), {linkUp, linkDown}});
     }
 
     //call the cluster function that adds the others links
     if (cluster->topology == simgrid::kernel::routing::ClusterTopology::FAT_TREE) {
       static_cast<FatTreeZone*>(current_as)->add_processing_node(i);
     } else {
-      current_as->create_links_for_node(cluster, i, rankId, current_as->nodePositionWithLimiter(rankId));
+      current_as->create_links_for_node(cluster, i, rankId, current_as->node_pos_with_loopback_limiter(rankId));
     }
     rankId++;
   }
@@ -280,7 +279,7 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
     XBT_DEBUG("<link\tid=\"%s\" bw=\"%f\" lat=\"%f\"/>", link.id.c_str(), cluster->bb_bw, cluster->bb_lat);
     sg_platf_new_link(&link);
 
-    routing_cluster_add_backbone(simgrid::surf::LinkImpl::byName(link.id));
+    routing_cluster_add_backbone(simgrid::kernel::resource::LinkImpl::byName(link.id));
   }
 
   XBT_DEBUG("</AS>");
@@ -290,16 +289,16 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
   delete cluster->radicals;
 }
 
-void routing_cluster_add_backbone(simgrid::surf::LinkImpl* bb)
+void routing_cluster_add_backbone(simgrid::kernel::resource::LinkImpl* bb)
 {
   simgrid::kernel::routing::ClusterZone* cluster =
       dynamic_cast<simgrid::kernel::routing::ClusterZone*>(current_routing);
 
   xbt_assert(cluster, "Only hosts from Cluster can get a backbone.");
-  xbt_assert(nullptr == cluster->backbone_, "Cluster %s already has a backbone link!", cluster->getCname());
+  xbt_assert(nullptr == cluster->backbone_, "Cluster %s already has a backbone link!", cluster->get_cname());
 
   cluster->backbone_ = bb;
-  XBT_DEBUG("Add a backbone to AS '%s'", current_routing->getCname());
+  XBT_DEBUG("Add a backbone to AS '%s'", current_routing->get_cname());
 }
 
 void sg_platf_new_cabinet(simgrid::kernel::routing::CabinetCreationArgs* cabinet)
@@ -314,7 +313,7 @@ void sg_platf_new_cabinet(simgrid::kernel::routing::CabinetCreationArgs* cabinet
     sg_platf_new_host(&host);
 
     simgrid::kernel::routing::LinkCreationArgs link;
-    link.policy    = SURF_LINK_SPLITDUPLEX;
+    link.policy    = simgrid::s4u::Link::SharingPolicy::SPLITDUPLEX;
     link.latency   = cabinet->lat;
     link.bandwidth = cabinet->bw;
     link.id        = "link_" + hostname;
@@ -393,19 +392,19 @@ void sg_platf_new_mount(simgrid::kernel::routing::MountCreationArgs* mount)
 
   if (mount_list.empty())
     XBT_DEBUG("Create a Mount list for %s", A_surfxml_host_id);
-  mount_list.insert({mount->name, simgrid::s4u::Engine::getInstance()->storageByName(mount->storageId)->getImpl()});
+  mount_list.insert({mount->name, simgrid::s4u::Engine::getInstance()->storage_by_name(mount->storageId)->getImpl()});
 }
 
 void sg_platf_new_route(simgrid::kernel::routing::RouteCreationArgs* route)
 {
-  routing_get_current()->addRoute(route->src, route->dst, route->gw_src, route->gw_dst, route->link_list,
-                                  route->symmetrical);
+  routing_get_current()->add_route(route->src, route->dst, route->gw_src, route->gw_dst, route->link_list,
+                                   route->symmetrical);
 }
 
 void sg_platf_new_bypassRoute(simgrid::kernel::routing::RouteCreationArgs* bypassRoute)
 {
-  routing_get_current()->addBypassRoute(bypassRoute->src, bypassRoute->dst, bypassRoute->gw_src, bypassRoute->gw_dst,
-                                        bypassRoute->link_list, bypassRoute->symmetrical);
+  routing_get_current()->add_bypass_route(bypassRoute->src, bypassRoute->dst, bypassRoute->gw_src, bypassRoute->gw_dst,
+                                          bypassRoute->link_list, bypassRoute->symmetrical);
 }
 
 void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
@@ -416,10 +415,10 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
     std::string msg = std::string("Cannot create actor '") + actor->function + "': host '" + actor->host +
                       "' does not exist\nExisting hosts: '";
 
-    std::vector<simgrid::s4u::Host*> list = simgrid::s4u::Engine::getInstance()->getAllHosts();
+    std::vector<simgrid::s4u::Host*> list = simgrid::s4u::Engine::getInstance()->get_all_hosts();
 
     for (auto const& host : list) {
-      msg += host->getName();
+      msg += host->get_name();
       msg += "', '";
       if (msg.length() > 1024) {
         msg.pop_back(); // remove trailing quote
@@ -449,7 +448,7 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
 
     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->getCname(), start_time);
+    XBT_DEBUG("Process %s@%s will be started at time %f", arg->name.c_str(), arg->host->get_cname(), start_time);
     SIMIX_timer_set(start_time, [arg, auto_restart]() {
       smx_actor_t actor = simix_global->create_process_function(arg->name.c_str(), std::move(arg->code), arg->data,
                                                                 arg->host, arg->properties.get(), nullptr);
@@ -460,7 +459,7 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
       delete arg;
     });
   } else {                      // start_time <= SIMIX_get_clock()
-    XBT_DEBUG("Starting Process %s(%s) right now", arg->name.c_str(), host->getCname());
+    XBT_DEBUG("Starting Process %s(%s) right now", arg->name.c_str(), host->get_cname());
 
     smx_actor_t actor = simix_global->create_process_function(arg->name.c_str(), std::move(code), nullptr, host,
                                                               arg->properties.get(), nullptr);
@@ -482,7 +481,7 @@ void sg_platf_new_peer(simgrid::kernel::routing::PeerCreationArgs* peer)
 
   std::vector<double> speedPerPstate;
   speedPerPstate.push_back(peer->speed);
-  simgrid::s4u::Host* host = as->createHost(peer->id.c_str(), &speedPerPstate, 1, nullptr);
+  simgrid::s4u::Host* host = as->create_host(peer->id.c_str(), &speedPerPstate, 1, nullptr);
 
   as->setPeerLink(host->pimpl_netpoint, peer->bw_in, peer->bw_out, peer->coord);
 
@@ -490,7 +489,7 @@ void sg_platf_new_peer(simgrid::kernel::routing::PeerCreationArgs* peer)
   if (peer->state_trace)
     host->pimpl_cpu->setStateTrace(peer->state_trace);
   if (peer->speed_trace)
-    host->pimpl_cpu->setSpeedTrace(peer->speed_trace);
+    host->pimpl_cpu->set_speed_trace(peer->speed_trace);
 }
 
 void sg_platf_begin() { /* Do nothing: just for symmetry of user code */ }
@@ -502,16 +501,16 @@ void sg_platf_end() {
 /* Pick the right models for CPU, net and host, and call their model_init_preparse */
 static void surf_config_models_setup()
 {
-  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");
+  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 storage_model_name = simgrid::config::get_value<std::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")) {
+  if ((not simgrid::config::is_default("network/model") || not simgrid::config::is_default("cpu/model")) &&
+      simgrid::config::is_default("host/model")) {
     host_model_name = "compound";
-    xbt_cfg_set_string("host/model", host_model_name.c_str());
+    simgrid::config::set_value("host/model", host_model_name);
   }
 
   XBT_DEBUG("host model: %s", host_model_name.c_str());
@@ -646,8 +645,8 @@ void sg_platf_new_hostlink(simgrid::kernel::routing::HostLinkCreationArgs* hostl
   xbt_assert(dynamic_cast<simgrid::kernel::routing::ClusterZone*>(current_routing),
              "Only hosts from Cluster and Vivaldi ASes can get an host_link.");
 
-  simgrid::surf::LinkImpl* linkUp   = simgrid::surf::LinkImpl::byName(hostlink->link_up);
-  simgrid::surf::LinkImpl* linkDown = simgrid::surf::LinkImpl::byName(hostlink->link_down);
+  simgrid::kernel::resource::LinkImpl* linkUp   = simgrid::kernel::resource::LinkImpl::byName(hostlink->link_up);
+  simgrid::kernel::resource::LinkImpl* linkDown = simgrid::kernel::resource::LinkImpl::byName(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());
@@ -657,7 +656,7 @@ void sg_platf_new_hostlink(simgrid::kernel::routing::HostLinkCreationArgs* hostl
   if (as_cluster->private_links_.find(netpoint->id()) != as_cluster->private_links_.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->getCname(), netpoint->id());
+  XBT_DEBUG("Push Host_link for host '%s' to position %u", netpoint->get_cname(), netpoint->id());
   as_cluster->private_links_.insert({netpoint->id(), {linkUp, linkDown}});
 }