X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/131ea969cf91c332bd533b7e9d67c729149e9b4d..f653eea6a35035be81a9b60f6c2fa7c48292d9c4:/src/surf/sg_platf.cpp

diff --git a/src/surf/sg_platf.cpp b/src/surf/sg_platf.cpp
index 22d8507240..42f498c0aa 100644
--- a/src/surf/sg_platf.cpp
+++ b/src/surf/sg_platf.cpp
@@ -15,6 +15,7 @@
 #include "simgrid/kernel/routing/NetZoneImpl.hpp"
 #include "simgrid/kernel/routing/TorusZone.hpp"
 #include "simgrid/kernel/routing/VivaldiZone.hpp"
+#include "simgrid/kernel/routing/WifiZone.hpp"
 #include "simgrid/s4u/Engine.hpp"
 #include "src/include/simgrid/sg_config.hpp"
 #include "src/include/surf/surf.hpp"
@@ -67,9 +68,9 @@ void sg_platf_exit() {
 }
 
 /** @brief Add a host to the current AS */
-void sg_platf_new_host(simgrid::kernel::routing::HostCreationArgs* args)
+void sg_platf_new_host(const simgrid::kernel::routing::HostCreationArgs* args)
 {
-  std::map<std::string, std::string> props;
+  std::unordered_map<std::string, std::string> props;
   if (args->properties) {
     for (auto const& elm : *args->properties)
       props.insert({elm.first, elm.second});
@@ -103,7 +104,7 @@ simgrid::kernel::routing::NetPoint* sg_platf_new_router(const std::string& name,
   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());
 
-  simgrid::kernel::routing::NetPoint* netpoint =
+  auto* netpoint =
       new simgrid::kernel::routing::NetPoint(name, simgrid::kernel::routing::NetPoint::Type::Router, current_routing);
   XBT_DEBUG("Router '%s' has the id %u", netpoint->get_cname(), netpoint->id());
 
@@ -114,21 +115,23 @@ simgrid::kernel::routing::NetPoint* sg_platf_new_router(const std::string& name,
   return netpoint;
 }
 
-static void sg_platf_new_link(const simgrid::kernel::routing::LinkCreationArgs* link, const std::string& link_name)
+static void sg_platf_new_link(const simgrid::kernel::routing::LinkCreationArgs* args, const std::string& link_name)
 {
-  simgrid::kernel::resource::LinkImpl* l =
-      surf_network_model->create_link(link_name, link->bandwidths, link->latency, link->policy);
+  std::unordered_map<std::string, std::string> props;
+  if (args->properties)
+    for (auto const& elm : *args->properties)
+      props.insert({elm.first, elm.second});
 
-  if (link->properties) {
-    l->set_properties(*link->properties);
-  }
+  const simgrid::s4u::Link* link =
+      routing_get_current()->create_link(link_name, args->bandwidths, args->latency, args->policy, &props);
 
-  if (link->latency_trace)
-    l->set_latency_profile(link->latency_trace);
-  if (link->bandwidth_trace)
-    l->set_bandwidth_profile(link->bandwidth_trace);
-  if (link->state_trace)
-    l->set_state_profile(link->state_trace);
+  simgrid::kernel::resource::LinkImpl* l = link->get_impl();
+  if (args->latency_trace)
+    l->set_latency_profile(args->latency_trace);
+  if (args->bandwidth_trace)
+    l->set_bandwidth_profile(args->bandwidth_trace);
+  if (args->state_trace)
+    l->set_state_profile(args->state_trace);
 }
 
 void sg_platf_new_link(const simgrid::kernel::routing::LinkCreationArgs* link)
@@ -156,20 +159,20 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
   zone.id = cluster->id;
   switch (cluster->topology) {
     case simgrid::kernel::routing::ClusterTopology::TORUS:
-      zone.routing = A_surfxml_AS_routing_ClusterTorus;
+      zone.routing = "ClusterTorus";
       break;
     case simgrid::kernel::routing::ClusterTopology::DRAGONFLY:
-      zone.routing = A_surfxml_AS_routing_ClusterDragonfly;
+      zone.routing = "ClusterDragonfly";
       break;
     case simgrid::kernel::routing::ClusterTopology::FAT_TREE:
-      zone.routing = A_surfxml_AS_routing_ClusterFatTree;
+      zone.routing = "ClusterFatTree";
       break;
     default:
-      zone.routing = A_surfxml_AS_routing_Cluster;
+      zone.routing = "Cluster";
       break;
   }
   sg_platf_new_Zone_begin(&zone);
-  simgrid::kernel::routing::ClusterZone* current_as = static_cast<ClusterZone*>(routing_get_current());
+  auto* current_as = static_cast<ClusterZone*>(routing_get_current());
   current_as->parse_specific_arguments(cluster);
   if (cluster->properties != nullptr)
     for (auto const& elm : *cluster->properties)
@@ -231,7 +234,7 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
       linkUp   = simgrid::s4u::Link::by_name_or_null(tmp_link);
       linkDown = simgrid::s4u::Link::by_name_or_null(tmp_link);
 
-      auto* as_cluster = static_cast<ClusterZone*>(current_as);
+      ClusterZone* as_cluster = current_as;
       as_cluster->private_links_.insert({as_cluster->node_pos(rankId), {linkUp->get_impl(), linkDown->get_impl()}});
     }
 
@@ -267,12 +270,9 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
   // Add a router.
   XBT_DEBUG(" ");
   XBT_DEBUG("<router id=\"%s\"/>", cluster->router_id.c_str());
-  if (cluster->router_id.empty()) {
-    std::string newid   = std::string(cluster->prefix) + cluster->id + "_router" + cluster->suffix;
-    current_as->router_ = sg_platf_new_router(newid, NULL);
-  } else {
-    current_as->router_ = sg_platf_new_router(cluster->router_id, NULL);
-  }
+  if (cluster->router_id.empty())
+    cluster->router_id = std::string(cluster->prefix) + cluster->id + "_router" + cluster->suffix;
+  current_as->router_ = sg_platf_new_router(cluster->router_id, nullptr);
 
   //Make the backbone
   if ((cluster->bb_bw > 0) || (cluster->bb_lat > 0)) {
@@ -297,8 +297,7 @@ void sg_platf_new_cluster(simgrid::kernel::routing::ClusterCreationArgs* cluster
 
 void routing_cluster_add_backbone(simgrid::kernel::resource::LinkImpl* bb)
 {
-  simgrid::kernel::routing::ClusterZone* cluster =
-      dynamic_cast<simgrid::kernel::routing::ClusterZone*>(current_routing);
+  auto* 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->get_cname());
@@ -376,7 +375,8 @@ void sg_platf_new_storage(simgrid::kernel::routing::StorageCreationArgs* storage
             storage->id.c_str(), stype->model.c_str(), stype->id.c_str(), storage->content.c_str(),
             storage->properties);
 
-  auto s = surf_storage_model->createStorage(storage->id, stype->id, storage->content, storage->attach);
+  auto s = surf_storage_model->createStorage(storage->filename, storage->lineno, storage->id, stype->id,
+                                             storage->content, storage->attach);
 
   if (storage->properties) {
     s->set_properties(*storage->properties);
@@ -389,9 +389,9 @@ void sg_platf_new_storage_type(const simgrid::kernel::routing::StorageTypeCreati
   xbt_assert(storage_types.find(storage_type->id) == storage_types.end(),
              "Reading a storage type, processing unit \"%s\" already exists", storage_type->id.c_str());
 
-  simgrid::kernel::resource::StorageType* stype = new simgrid::kernel::resource::StorageType(
-      storage_type->id, storage_type->model, storage_type->content, storage_type->properties,
-      storage_type->model_properties, storage_type->size);
+  auto* stype = new simgrid::kernel::resource::StorageType(storage_type->id, storage_type->model, storage_type->content,
+                                                           storage_type->properties, storage_type->model_properties,
+                                                           storage_type->size);
 
   XBT_DEBUG("Create a storage type id '%s' with model '%s', content '%s'", storage_type->id.c_str(),
             storage_type->model.c_str(), storage_type->content.c_str());
@@ -444,7 +444,8 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
     }
     xbt_die("%s", msg.c_str());
   }
-  const simgrid::simix::ActorCodeFactory& factory = SIMIX_get_actor_code_factory(actor->function);
+  const simgrid::kernel::actor::ActorCodeFactory& factory =
+      simgrid::kernel::EngineImpl::get_instance()->get_function(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;
@@ -452,10 +453,10 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
   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::ActorCode code = factory(std::move(actor->args));
   std::shared_ptr<std::unordered_map<std::string, std::string>> properties(actor->properties);
 
-  simgrid::kernel::actor::ProcessArg* arg =
+  auto* arg =
       new simgrid::kernel::actor::ProcessArg(actor_name, code, nullptr, host, kill_time, properties, auto_restart);
 
   host->pimpl_->add_actor_at_boot(arg);
@@ -466,7 +467,7 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
     XBT_DEBUG("Process %s@%s will be started at time %f", arg->name.c_str(), arg->host->get_cname(), start_time);
     simgrid::simix::Timer::set(start_time, [arg, auto_restart]() {
       simgrid::kernel::actor::ActorImplPtr new_actor = simgrid::kernel::actor::ActorImpl::create(
-          arg->name.c_str(), std::move(arg->code), arg->data, arg->host, arg->properties.get(), nullptr);
+          arg->name.c_str(), arg->code, arg->data, arg->host, arg->properties.get(), nullptr);
       if (arg->kill_time >= 0)
         new_actor->set_kill_time(arg->kill_time);
       if (auto_restart)
@@ -478,7 +479,7 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
 
     try {
       simgrid::kernel::actor::ActorImplPtr new_actor = nullptr;
-      new_actor = simgrid::kernel::actor::ActorImpl::create(arg->name.c_str(), std::move(code), nullptr, host,
+      new_actor = simgrid::kernel::actor::ActorImpl::create(arg->name.c_str(), code, nullptr, host,
                                                             arg->properties.get(), nullptr);
       /* The actor creation will fail if the host is currently dead, but that's fine */
       if (arg->kill_time >= 0)
@@ -493,7 +494,7 @@ void sg_platf_new_actor(simgrid::kernel::routing::ActorCreationArgs* actor)
 
 void sg_platf_new_peer(const simgrid::kernel::routing::PeerCreationArgs* peer)
 {
-  simgrid::kernel::routing::VivaldiZone* as = dynamic_cast<simgrid::kernel::routing::VivaldiZone*>(current_routing);
+  auto* as = dynamic_cast<simgrid::kernel::routing::VivaldiZone*>(current_routing);
   xbt_assert(as, "<peer> tag can only be used in Vivaldi netzones.");
 
   std::vector<double> speed_per_pstate;
@@ -586,40 +587,30 @@ simgrid::kernel::routing::NetZoneImpl* sg_platf_new_Zone_begin(const simgrid::ke
   simgrid::kernel::routing::NetZoneImpl* new_zone = nullptr;
   simgrid::kernel::resource::NetworkModel* netmodel =
       current_routing == nullptr ? surf_network_model : current_routing->network_model_;
-  switch (zone->routing) {
-    case A_surfxml_AS_routing_Cluster:
+  if (strcasecmp(zone->routing.c_str(), "Cluster") == 0) {
       new_zone = new simgrid::kernel::routing::ClusterZone(current_routing, zone->id, netmodel);
-      break;
-    case A_surfxml_AS_routing_ClusterDragonfly:
+  } else if (strcasecmp(zone->routing.c_str(),"ClusterDragonfly") == 0) {
       new_zone = new simgrid::kernel::routing::DragonflyZone(current_routing, zone->id, netmodel);
-      break;
-    case A_surfxml_AS_routing_ClusterTorus:
+  } else if (strcasecmp(zone->routing.c_str(),"ClusterTorus") == 0) {
       new_zone = new simgrid::kernel::routing::TorusZone(current_routing, zone->id, netmodel);
-      break;
-    case A_surfxml_AS_routing_ClusterFatTree:
+  } else if (strcasecmp(zone->routing.c_str(),"ClusterFatTree") == 0) {
       new_zone = new simgrid::kernel::routing::FatTreeZone(current_routing, zone->id, netmodel);
-      break;
-    case A_surfxml_AS_routing_Dijkstra:
+  } else if (strcasecmp(zone->routing.c_str(),"Dijkstra") == 0) {
       new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, netmodel, false);
-      break;
-    case A_surfxml_AS_routing_DijkstraCache:
+  } else if (strcasecmp(zone->routing.c_str(),"DijkstraCache") == 0) {
       new_zone = new simgrid::kernel::routing::DijkstraZone(current_routing, zone->id, netmodel, true);
-      break;
-    case A_surfxml_AS_routing_Floyd:
+  } else if (strcasecmp(zone->routing.c_str(),"Floyd") == 0) {
       new_zone = new simgrid::kernel::routing::FloydZone(current_routing, zone->id, netmodel);
-      break;
-    case A_surfxml_AS_routing_Full:
+  } else if (strcasecmp(zone->routing.c_str(),"Full") == 0) {
       new_zone = new simgrid::kernel::routing::FullZone(current_routing, zone->id, netmodel);
-      break;
-    case A_surfxml_AS_routing_None:
+  } else if (strcasecmp(zone->routing.c_str(),"None") == 0) {
       new_zone = new simgrid::kernel::routing::EmptyZone(current_routing, zone->id, netmodel);
-      break;
-    case A_surfxml_AS_routing_Vivaldi:
+  } else if (strcasecmp(zone->routing.c_str(),"Vivaldi") == 0) {
       new_zone = new simgrid::kernel::routing::VivaldiZone(current_routing, zone->id, netmodel);
-      break;
-    default:
-      xbt_die("Not a valid model!");
-      break;
+  } else if (strcasecmp(zone->routing.c_str(), "Wifi") == 0) {
+    new_zone = new simgrid::kernel::routing::WifiZone(current_routing, zone->id, netmodel);
+  } else {
+    xbt_die("Not a valid model!");
   }
 
   if (current_routing == nullptr) { /* it is the first one */
@@ -658,13 +649,13 @@ void sg_platf_new_Zone_seal()
   xbt_assert(current_routing, "Cannot seal the current AS: none under construction");
   current_routing->seal();
   simgrid::s4u::NetZone::on_seal(*current_routing->get_iface());
-  current_routing = static_cast<simgrid::kernel::routing::NetZoneImpl*>(current_routing->get_father());
+  current_routing = current_routing->get_father();
 }
 
 /** @brief Add a link connecting a host to the rest of its AS (which must be cluster or vivaldi) */
 void sg_platf_new_hostlink(const simgrid::kernel::routing::HostLinkCreationArgs* hostlink)
 {
-  simgrid::kernel::routing::NetPoint* netpoint = simgrid::s4u::Host::by_name(hostlink->id)->get_netpoint();
+  const 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.");