X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b8df87e176f27b25534f27d7e240defa32ca35bc..955310e4fe48139407cabfd6cae815a287932291:/src/surf/network_ns3.cpp

diff --git a/src/surf/network_ns3.cpp b/src/surf/network_ns3.cpp
index a2ddc80587..b481aae544 100644
--- a/src/surf/network_ns3.cpp
+++ b/src/surf/network_ns3.cpp
@@ -64,32 +64,32 @@ NetPointNs3::NetPointNs3()
  * Callbacks *
  *************/
 
-static void clusterCreation_cb(simgrid::kernel::routing::ClusterCreationArgs* cluster)
+static void clusterCreation_cb(simgrid::kernel::routing::ClusterCreationArgs const& cluster)
 {
-  for (int const& i : *cluster->radicals) {
+  for (int const& i : *cluster.radicals) {
     // Routers don't create a router on the other end of the private link by themselves.
     // We just need this router to be given an ID so we create a temporary NetPointNS3 so that it gets one
     NetPointNs3* host_dst = new NetPointNs3();
 
     // Create private link
-    std::string host_id   = cluster->prefix + std::to_string(i) + cluster->suffix;
-    NetPointNs3* host_src = sg_host_by_name(host_id.c_str())->pimpl_netpoint->extension<NetPointNs3>();
+    std::string host_id   = cluster.prefix + std::to_string(i) + cluster.suffix;
+    NetPointNs3* host_src = simgrid::s4u::Host::by_name(host_id)->pimpl_netpoint->extension<NetPointNs3>();
     xbt_assert(host_src, "Cannot find a NS3 host of name %s", host_id.c_str());
 
     // Any NS3 route is symmetrical
-    ns3_add_link(host_src, host_dst, cluster->bw, cluster->lat);
+    ns3_add_link(host_src, host_dst, cluster.bw, cluster.lat);
 
     delete host_dst;
   }
 
   //Create link backbone
-  ns3_add_cluster(cluster->id.c_str(), cluster->bb_bw, cluster->bb_lat);
+  ns3_add_cluster(cluster.id.c_str(), cluster.bb_bw, cluster.bb_lat);
 }
 
 static void routeCreation_cb(bool symmetrical, simgrid::kernel::routing::NetPoint* src,
                              simgrid::kernel::routing::NetPoint* dst, simgrid::kernel::routing::NetPoint* gw_src,
                              simgrid::kernel::routing::NetPoint* gw_dst,
-                             std::vector<simgrid::kernel::resource::LinkImpl*>& link_list)
+                             std::vector<simgrid::kernel::resource::LinkImpl*> const& link_list)
 {
   if (link_list.size() == 1) {
     simgrid::kernel::resource::LinkNS3* link = static_cast<simgrid::kernel::resource::LinkNS3*>(link_list[0]);
@@ -155,18 +155,18 @@ NetworkNS3Model::NetworkNS3Model() : NetworkModel(Model::UpdateAlgo::FULL)
 
   all_existing_models.push_back(this);
 
-  NetPointNs3::EXTENSION_ID = simgrid::kernel::routing::NetPoint::extension_create<NetPointNs3>();
+  NetPointNs3::EXTENSION_ID = routing::NetPoint::extension_create<NetPointNs3>();
 
   ns3_initialize(ns3_tcp_model.get().c_str());
 
-  simgrid::kernel::routing::NetPoint::on_creation.connect([](simgrid::kernel::routing::NetPoint* pt) {
-    pt->extension_set<NetPointNs3>(new NetPointNs3());
-    XBT_VERB("SimGrid's %s is known as node %d within NS3", pt->get_cname(), pt->extension<NetPointNs3>()->node_num);
+  routing::NetPoint::on_creation.connect([](routing::NetPoint& pt) {
+    pt.extension_set<NetPointNs3>(new NetPointNs3());
+    XBT_VERB("SimGrid's %s is known as node %d within NS3", pt.get_cname(), pt.extension<NetPointNs3>()->node_num);
   });
-  simgrid::surf::on_cluster.connect(&clusterCreation_cb);
+  surf::on_cluster.connect(&clusterCreation_cb);
 
-  simgrid::s4u::on_platform_created.connect(&postparse_cb);
-  simgrid::s4u::NetZone::on_route_creation.connect(&routeCreation_cb);
+  s4u::on_platform_created.connect(&postparse_cb);
+  s4u::NetZone::on_route_creation.connect(&routeCreation_cb);
 }
 
 NetworkNS3Model::~NetworkNS3Model() {
@@ -179,7 +179,7 @@ LinkImpl* NetworkNS3Model::create_link(const std::string& name, double bandwidth
   return new LinkNS3(this, name, bandwidth, latency);
 }
 
-kernel::resource::Action* NetworkNS3Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
+Action* NetworkNS3Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
 {
   return new NetworkNS3Action(this, size, src, dst);
 }
@@ -277,24 +277,24 @@ LinkNS3::LinkNS3(NetworkNS3Model* model, const std::string& name, double bandwid
 
 LinkNS3::~LinkNS3() = default;
 
-void LinkNS3::apply_event(tmgr_trace_event_t event, double value)
+void LinkNS3::apply_event(profile::Event* event, double value)
 {
   THROW_UNIMPLEMENTED;
 }
-void LinkNS3::set_bandwidth_trace(tmgr_trace_t trace)
+void LinkNS3::set_bandwidth_profile(profile::Profile* profile)
 {
-  xbt_die("The NS3 network model doesn't support bandwidth traces");
+  xbt_die("The NS3 network model doesn't support bandwidth profiles");
 }
-void LinkNS3::set_latency_trace(tmgr_trace_t trace)
+void LinkNS3::set_latency_profile(profile::Profile* profile)
 {
-  xbt_die("The NS3 network model doesn't support latency traces");
+  xbt_die("The NS3 network model doesn't support latency profiles");
 }
 
 /**********
  * Action *
  **********/
 
-NetworkNS3Action::NetworkNS3Action(kernel::resource::Model* model, double totalBytes, s4u::Host* src, s4u::Host* dst)
+NetworkNS3Action::NetworkNS3Action(Model* model, double totalBytes, s4u::Host* src, s4u::Host* dst)
     : NetworkAction(model, totalBytes, false), src_(src), dst_(dst)
 {
   XBT_DEBUG("Communicate from %s to %s", src->get_cname(), dst->get_cname());
@@ -328,7 +328,7 @@ NetworkNS3Action::NetworkNS3Action(kernel::resource::Model* model, double totalB
   port_number++;
   xbt_assert(port_number <= 65000, "Too many connections! Port number is saturated.");
 
-  s4u::Link::on_communicate(this, src, dst);
+  s4u::Link::on_communicate(*this, src, dst);
 }
 
 void NetworkNS3Action::suspend() {
@@ -339,7 +339,7 @@ void NetworkNS3Action::resume() {
   THROW_UNIMPLEMENTED;
 }
 
-std::list<LinkImpl*> NetworkNS3Action::links()
+std::list<LinkImpl*> NetworkNS3Action::links() const
 {
   THROW_UNIMPLEMENTED;
 }
@@ -349,8 +349,8 @@ void NetworkNS3Action::update_remains_lazy(double /*now*/)
 }
 
 } // namespace resource
-}
-}
+} // namespace kernel
+} // namespace simgrid
 
 void ns3_simulator(double maxSeconds)
 {