X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a6ceacf3b05651e2ae5a40d47c96bdd9fc4d1416..3cd5170a6a13fdc1c15173670b9730306a66f823:/src/kernel/routing/NetZoneImpl.cpp

diff --git a/src/kernel/routing/NetZoneImpl.cpp b/src/kernel/routing/NetZoneImpl.cpp
index 11c3363828..67cf46ccc6 100644
--- a/src/kernel/routing/NetZoneImpl.cpp
+++ b/src/kernel/routing/NetZoneImpl.cpp
@@ -109,6 +109,8 @@ NetZoneImpl::~NetZoneImpl()
 void NetZoneImpl::add_child(NetZoneImpl* new_zone)
 {
   xbt_assert(not sealed_, "Cannot add a new child to the sealed zone %s", get_cname());
+  /* set the father behavior */
+  hierarchy_ = RoutingMode::recursive;
   children_.push_back(new_zone);
 }
 
@@ -138,11 +140,14 @@ int NetZoneImpl::get_host_count() const
   return count;
 }
 
-s4u::Disk* NetZoneImpl::create_disk(const std::string& name, double read_bandwidth, double write_bandwidth)
+s4u::Host* NetZoneImpl::create_host(const std::string& name, const std::vector<double>& speed_per_pstate)
 {
-  auto* l = disk_model_->create_disk(name, read_bandwidth, write_bandwidth);
+  auto* res = (new surf::HostImpl(name))->get_iface();
+  res->set_netpoint((new NetPoint(name, NetPoint::Type::Host))->set_englobing_zone(this));
 
-  return l->get_iface();
+  cpu_model_pm_->create_cpu(res, speed_per_pstate);
+
+  return res;
 }
 
 s4u::Link* NetZoneImpl::create_link(const std::string& name, const std::vector<double>& bandwidths)
@@ -150,24 +155,20 @@ s4u::Link* NetZoneImpl::create_link(const std::string& name, const std::vector<d
   return network_model_->create_link(name, bandwidths)->get_iface();
 }
 
-s4u::Link* NetZoneImpl::create_wifi_link(const std::string& name, const std::vector<double>& bandwidths)
+s4u::Disk* NetZoneImpl::create_disk(const std::string& name, double read_bandwidth, double write_bandwidth)
 {
-  return network_model_->create_wifi_link(name, bandwidths)->get_iface();
+  auto* l = disk_model_->create_disk(name, read_bandwidth, write_bandwidth);
+
+  return l->get_iface();
 }
 
-s4u::Host* NetZoneImpl::create_host(const std::string& name, const std::vector<double>& speed_per_pstate)
+NetPoint* NetZoneImpl::create_router(const std::string& name)
 {
-  if (hierarchy_ == RoutingMode::unset)
-    hierarchy_ = RoutingMode::base;
+  xbt_assert(nullptr == 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());
 
-  auto* res = (new surf::HostImpl(name))->get_iface();
-  res->set_netpoint((new NetPoint(name, NetPoint::Type::Host))->set_englobing_zone(this));
-
-  cpu_model_pm_->create_cpu(res, speed_per_pstate);
-
-  return res;
+  return (new NetPoint(name, NetPoint::Type::Router))->set_englobing_zone(this);
 }
-
 int NetZoneImpl::add_component(NetPoint* elm)
 {
   vertices_.push_back(elm);
@@ -366,39 +367,29 @@ bool NetZoneImpl::get_bypass_route(NetPoint* src, NetPoint* dst,
     path_dst.pop_back();
   }
 
-  int max_index_src = path_src.size() - 1;
-  int max_index_dst = path_dst.size() - 1;
-
-  int max_index = std::max(max_index_src, max_index_dst);
-
   /* (3) Search for a bypass making the path up to the ancestor useless */
   const BypassRoute* bypassedRoute = nullptr;
   std::pair<kernel::routing::NetPoint*, kernel::routing::NetPoint*> key;
-  for (int max = 0; max <= max_index && not bypassedRoute; max++) {
-    for (int i = 0; i < max && not bypassedRoute; i++) {
-      if (i <= max_index_src && max <= max_index_dst) {
-        key      = {path_src.at(i)->netpoint_, path_dst.at(max)->netpoint_};
-        auto bpr = bypass_routes_.find(key);
-        if (bpr != bypass_routes_.end()) {
-          bypassedRoute = bpr->second;
-        }
-      }
-      if (not bypassedRoute && max <= max_index_src && i <= max_index_dst) {
-        key      = {path_src.at(max)->netpoint_, path_dst.at(i)->netpoint_};
-        auto bpr = bypass_routes_.find(key);
-        if (bpr != bypass_routes_.end()) {
-          bypassedRoute = bpr->second;
-        }
-      }
-    }
-
-    if (not bypassedRoute && max <= max_index_src && max <= max_index_dst) {
-      key      = {path_src.at(max)->netpoint_, path_dst.at(max)->netpoint_};
+  // Search for a bypass with the given indices. Returns true if found. Initialize variables `bypassedRoute' and `key'.
+  auto lookup = [&bypassedRoute, &key, &path_src, &path_dst, this](unsigned src_index, unsigned dst_index) {
+    if (src_index < path_src.size() && dst_index <= path_dst.size()) {
+      key      = {path_src[src_index]->netpoint_, path_dst[dst_index]->netpoint_};
       auto bpr = bypass_routes_.find(key);
       if (bpr != bypass_routes_.end()) {
         bypassedRoute = bpr->second;
+        return true;
       }
     }
+    return false;
+  };
+
+  for (unsigned max = 0, max_index = std::max(path_src.size(), path_dst.size()); max < max_index; max++) {
+    for (unsigned i = 0; i < max; i++) {
+      if (lookup(i, max) || lookup(max, i))
+        break;
+    }
+    if (bypassedRoute || lookup(max, max))
+      break;
   }
 
   /* (4) If we have the bypass, use it. If not, caller will do the Right Thing. */
@@ -476,7 +467,7 @@ void NetZoneImpl::seal()
   for (auto* host : get_all_hosts()) {
     host->seal();
   }
-  for (auto* sub_net : *get_children()) {
+  for (auto* sub_net : get_children()) {
     sub_net->seal();
   }
   sealed_ = true;
@@ -484,38 +475,48 @@ void NetZoneImpl::seal()
 
 void NetZoneImpl::set_parent(NetZoneImpl* parent)
 {
-  xbt_assert(sealed_ == false, "Impossible to set parent to an already sealed NetZone(%s)", this->get_cname());
+  xbt_assert(not sealed_, "Impossible to set parent to an already sealed NetZone(%s)", this->get_cname());
   parent_ = parent;
   netpoint_->set_englobing_zone(parent_);
+  if (parent) {
+    /* adding this class as child */
+    parent->add_child(this);
+    /* copying models from parent host, to be reviewed when we allow multi-models */
+    set_network_model(parent->get_network_model());
+    set_cpu_pm_model(parent->get_cpu_pm_model());
+    set_cpu_vm_model(parent->get_cpu_vm_model());
+    set_disk_model(parent->get_disk_model());
+    set_host_model(parent->get_host_model());
+  }
 }
 
 void NetZoneImpl::set_network_model(std::shared_ptr<resource::NetworkModel> netmodel)
 {
-  xbt_assert(sealed_ == false, "Impossible to set network model to an already sealed NetZone(%s)", this->get_cname());
+  xbt_assert(not sealed_, "Impossible to set network model to an already sealed NetZone(%s)", this->get_cname());
   network_model_ = std::move(netmodel);
 }
 
 void NetZoneImpl::set_cpu_vm_model(std::shared_ptr<resource::CpuModel> cpu_model)
 {
-  xbt_assert(sealed_ == false, "Impossible to set CPU model to an already sealed NetZone(%s)", this->get_cname());
+  xbt_assert(not sealed_, "Impossible to set CPU model to an already sealed NetZone(%s)", this->get_cname());
   cpu_model_vm_ = std::move(cpu_model);
 }
 
 void NetZoneImpl::set_cpu_pm_model(std::shared_ptr<resource::CpuModel> cpu_model)
 {
-  xbt_assert(sealed_ == false, "Impossible to set CPU model to an already sealed NetZone(%s)", this->get_cname());
+  xbt_assert(not sealed_, "Impossible to set CPU model to an already sealed NetZone(%s)", this->get_cname());
   cpu_model_pm_ = std::move(cpu_model);
 }
 
 void NetZoneImpl::set_disk_model(std::shared_ptr<resource::DiskModel> disk_model)
 {
-  xbt_assert(sealed_ == false, "Impossible to set disk model to an already sealed NetZone(%s)", this->get_cname());
+  xbt_assert(not sealed_, "Impossible to set disk model to an already sealed NetZone(%s)", this->get_cname());
   disk_model_ = std::move(disk_model);
 }
 
 void NetZoneImpl::set_host_model(std::shared_ptr<surf::HostModel> host_model)
 {
-  xbt_assert(sealed_ == false, "Impossible to set host model to an already sealed NetZone(%s)", this->get_cname());
+  xbt_assert(not sealed_, "Impossible to set host model to an already sealed NetZone(%s)", this->get_cname());
   host_model_ = std::move(host_model);
 }