Issue#71: add check in add_route for gw_src/gw_dst

[simgrid.git] / include / simgrid / kernel / routing / NetZoneImpl.hpp

diff --git a/include/simgrid/kernel/routing/NetZoneImpl.hpp b/include/simgrid/kernel/routing/NetZoneImpl.hpp
index f829d7f..257c8e7 100644 (file)
--- a/include/simgrid/kernel/routing/NetZoneImpl.hpp
+++ b/include/simgrid/kernel/routing/NetZoneImpl.hpp
@@ -13,12 +13,27 @@
 #include <xbt/graph.h>
 
 #include <map>
+#include <unordered_set>
 #include <vector>
 
 namespace simgrid {
 namespace kernel {
 namespace routing {
 
+class Route {
+public:
+  Route() = default;
+  explicit Route(NetPoint* src, NetPoint* dst, NetPoint* gwSrc, NetPoint* gwDst)
+      : src_(src), dst_(dst), gw_src_(gwSrc), gw_dst_(gwDst)
+  {
+  }
+  NetPoint* src_    = nullptr;
+  NetPoint* dst_    = nullptr;
+  NetPoint* gw_src_ = nullptr;
+  NetPoint* gw_dst_ = nullptr;
+  std::vector<resource::LinkImpl*> link_list_;
+};
+
 class BypassRoute {
 public:
   explicit BypassRoute(NetPoint* gwSrc, NetPoint* gwDst) : gw_src(gwSrc), gw_dst(gwDst) {}
@@ -85,11 +100,15 @@ protected:
    * @param into Container into which the traversed links and gateway information should be pushed
    * @param latency Accumulator in which the latencies should be added (caller must set it to 0)
    */
-  virtual void get_local_route(NetPoint* src, NetPoint* dst, RouteCreationArgs* into, double* latency) = 0;
+  virtual void get_local_route(NetPoint* src, NetPoint* dst, Route* into, double* latency) = 0;
   /** @brief retrieves the list of all routes of size 1 (of type src x dst x Link) */
   /* returns whether we found a bypass path */
   bool get_bypass_route(routing::NetPoint* src, routing::NetPoint* dst,
-                        /* OUT */ std::vector<resource::LinkImpl*>& links, double* latency);
+                        /* OUT */ std::vector<resource::LinkImpl*>& links, double* latency,
+                        std::unordered_set<NetZoneImpl*>& netzones);
+
+  /** @brief Get the NetZone that is represented by the netpoint */
+  const NetZoneImpl* get_netzone_recursive(const NetPoint* netpoint) const;
 
 public:
   enum class RoutingMode {
@@ -125,6 +144,9 @@ public:
   /** @brief Retrieves the name of that netzone as a C string */
   const char* get_cname() const { return name_.c_str(); };
 
+  /** @brief Gets the netpoint associated to this netzone */
+  kernel::routing::NetPoint* get_netpoint() const { return netpoint_; }
+
   std::vector<s4u::Host*> get_all_hosts() const;
   int get_host_count() const;
 
@@ -134,12 +156,16 @@ public:
   s4u::Disk* create_disk(const std::string& name, double read_bandwidth, double write_bandwidth);
   /** @brief Make a link within that NetZone */
   virtual s4u::Link* create_link(const std::string& name, const std::vector<double>& bandwidths);
+  /** @brief Make a router within that NetZone */
+  NetPoint* create_router(const std::string& name);
   /** @brief Creates a new route in this NetZone */
   virtual void add_bypass_route(NetPoint* src, NetPoint* dst, NetPoint* gw_src, NetPoint* gw_dst,
                                 std::vector<resource::LinkImpl*>& link_list, bool symmetrical);
 
   /** @brief Seal your netzone once you're done adding content, and before routing stuff through it */
   void seal();
+  /** @brief Check if netpoint is a member of this NetZone or some of the childrens */
+  bool is_component_recursive(const NetPoint* netpoint) const;
   virtual int add_component(kernel::routing::NetPoint* elm); /* A host, a router or a netzone, whatever */
   virtual void add_route(kernel::routing::NetPoint* src, kernel::routing::NetPoint* dst,
                          kernel::routing::NetPoint* gw_src, kernel::routing::NetPoint* gw_dst,
@@ -153,7 +179,7 @@ public:
   void set_disk_model(std::shared_ptr<resource::DiskModel> disk_model);
   void set_host_model(std::shared_ptr<surf::HostModel> host_model);
 
-  /* @brief get the route between two nodes in the full platform
+  /** @brief get the route between two nodes in the full platform
    *
    * @param src where from
    * @param dst where to
@@ -163,6 +189,11 @@ public:
   static void get_global_route(routing::NetPoint* src, routing::NetPoint* dst,
                                /* OUT */ std::vector<resource::LinkImpl*>& links, double* latency);
 
+  /** @brief Similar to get_global_route but get the NetZones traversed by route */
+  static void get_global_route_with_netzones(routing::NetPoint* src, routing::NetPoint* dst,
+                                             /* OUT */ std::vector<resource::LinkImpl*>& links, double* latency,
+                                             std::unordered_set<NetZoneImpl*>& netzones);
+
   virtual void get_graph(const s_xbt_graph_t* graph, std::map<std::string, xbt_node_t, std::less<>>* nodes,
                          std::map<std::string, xbt_edge_t, std::less<>>* edges) = 0;
 
@@ -174,7 +205,9 @@ private:
   std::shared_ptr<resource::DiskModel> disk_model_;
   std::shared_ptr<simgrid::surf::HostModel> host_model_;
   /** @brief Perform sealing procedure for derived classes, if necessary */
-  virtual void do_seal(){};
+  virtual void do_seal()
+  { /* obviously nothing to do by default */
+  }
   void add_child(NetZoneImpl* new_zone);
 };
 } // namespace routing