pdevs/mpi: new architecture

src/tests/mpi/cluster/graph_manager.hpp

@@ -128,6 +128,78 @@ private:
   Simulators models;
 };
 
+struct LevelGraphManagerParameters
+{
+  int index;
+  std::vector <
+    std::pair <
+      std::pair < int, int >,
+      std::pair < int, int > > > connections;
+};
+	
+class LevelGraphManager :
+        public paradevs::pdevs::GraphManager < common::DoubleTime,
+                                               LevelGraphManagerParameters >
+{
+public:
+    LevelGraphManager(
+	common::Coordinator < common::DoubleTime >* coordinator,
+        const LevelGraphManagerParameters& parameters) :
+        paradevs::pdevs::GraphManager < common::DoubleTime,
+                                        LevelGraphManagerParameters >(
+						      coordinator, parameters),
+      model("m", parameters.index, false)
+    {
+      add_child(&model);
+      for (std::vector <
+	     std::pair < std::pair < int, int >,
+	     std::pair < int, int > > >::const_iterator it2 =
+	     parameters.connections.begin();
+	   it2 != parameters.connections.end(); ++it2) {
+	std::stringstream out_ss;
+	std::stringstream in_ss;
+
+	if (it2->first.first == parameters.index) {
+	  out_ss << "out_" << it2->first.second;
+	  if (not model.exist_out_port(out_ss.str())) {
+	    model.add_out_port(out_ss.str());
+	  }
+	  if (not exist_link(&model, out_ss.str(), coordinator, out_ss.str())) {
+	    add_link(&model, out_ss.str(), coordinator, out_ss.str());
+	  }
+	}
+	if (it2->second.first == parameters.index) {
+	  in_ss << "in_" << it2->second.second;
+	  if (not model.exist_in_port(in_ss.str())) {
+	    model.add_in_port(in_ss.str());
+	  }
+	  if (not exist_link(coordinator, in_ss.str(), &model, in_ss.str())) {
+	    add_link(coordinator, in_ss.str(), &model, in_ss.str());
+	  }
+	}
+      }
+    }
+
+    void init()
+    { }
+
+    void start(common::DoubleTime::type /* t */)
+    { }
+
+    void transition(
+        const common::Models < common::DoubleTime >& /* receivers */,
+        common::DoubleTime::type /* t */)
+    { }
+
+    virtual ~LevelGraphManager()
+    { }
+
+private:
+  typedef paradevs::pdevs::mpi::ModelProxy < common::DoubleTime > ModelProxy;
+
+  ModelProxy model;
+};
+	
 struct RootGraphManagerParameters
 {
   std::vector <
@@ -136,13 +208,13 @@ struct RootGraphManagerParameters
 	std::pair < int, int >,
 	std::pair < int, int > > > > parents;
 };
-
-class LevelGraphManager :
+	
+class RootGraphManager :
         public paradevs::pdevs::GraphManager < common::DoubleTime,
                                                RootGraphManagerParameters >
 {
 public:
-    LevelGraphManager(
+    RootGraphManager(
 	common::Coordinator < common::DoubleTime >* coordinator,
         const RootGraphManagerParameters& parameters) :
         paradevs::pdevs::GraphManager < common::DoubleTime,
@@ -157,10 +229,13 @@ public:
 	     parameters.parents.begin(); it != parameters.parents.end();
 	   ++it) {
 	std::stringstream ss;
-	ModelProxy* model = 0;
-	
+	Coordinator* model = 0;
+	LevelGraphManagerParameters p;
+
+	p.index = index;
+	p.connections = parameters.parents[index];
 	ss << "S_" << index;
-	model = new ModelProxy(ss.str(), index + 1, false);
+	model = new Coordinator(ss.str(), common::NoParameters(), p);
 	models.push_back(model);
 	add_child(model);
 	++index;
@@ -196,78 +271,56 @@ public:
     }
 
     void init()
-    { }
-
-    void start(common::DoubleTime::type /* t */)
-    { }
-
-    void transition(
-        const common::Models < common::DoubleTime >& /* receivers */,
-        common::DoubleTime::type /* t */)
-    { }
-  
-    virtual ~LevelGraphManager()
     {
-        std::for_each(models.begin(), models.end(),
-                      std::default_delete < ModelProxy >());
-    }
-
-private:
-    typedef paradevs::pdevs::mpi::ModelProxy < common::DoubleTime > ModelProxy;
-    typedef std::vector < ModelProxy* > ModelProxies;
-
-    ModelProxies models;
-};
-
-class RootGraphManager :
-    public paradevs::pdevs::GraphManager < common::DoubleTime,
-					   RootGraphManagerParameters >
-{
-public:
-    RootGraphManager(
-        common::Coordinator < common::DoubleTime >* coordinator,
-        const RootGraphManagerParameters& parameters) :
-      paradevs::pdevs::GraphManager < common::DoubleTime,
-				      RootGraphManagerParameters >(
-					      coordinator, parameters),
-        S("S", paradevs::common::NoParameters(), parameters)
-    {
-        add_child(&S);
-    }
-
-    void init()
-    {
-        S.set_sender(
+      for (Coordinators::iterator it = models.begin(); it != models.end();
+	   ++it) {
+        (*it)->set_sender(
             dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
                 common::DoubleTime,
 	        paradevs::tests::mpi::cluster::RootGraphManager,
                 paradevs::common::NoParameters,
                 paradevs::tests::mpi::cluster::RootGraphManagerParameters >*
             >(get_coordinator())->get_sender());
+      }
     }
 
     void start(common::DoubleTime::type t)
     {
-        S.get_sender().send(
+      for (Coordinators::iterator it = models.begin(); it != models.end();
+	   ++it) {
+        (*it)->get_sender().send(
             paradevs::pdevs::multithreading::start_message <
                 common::DoubleTime >(t));
+      }
     }
 
     void transition(const common::Models < common::DoubleTime >& receivers,
                     common::DoubleTime::type t)
     {
-        S.get_sender().send(
+      for (Coordinators::iterator it = models.begin(); it != models.end();
+	   ++it) {
+        (*it)->get_sender().send(
 	    paradevs::pdevs::multithreading::transition_message <
 	        common::DoubleTime >(t));
+      }
     }
 
     virtual ~RootGraphManager()
-    { }
+    {
+        std::for_each(models.begin(), models.end(),
+                      std::default_delete < Coordinator >());
+    }
 
 private:
-    paradevs::pdevs::Coordinator <
-  common::DoubleTime, LevelGraphManager, paradevs::common::NoParameters, RootGraphManagerParameters > S;
-};	
+  typedef paradevs::pdevs::multithreading::Coordinator <
+    common::DoubleTime,
+    LevelGraphManager,
+    common::NoParameters,
+    LevelGraphManagerParameters > Coordinator;
+  typedef std::vector < Coordinator* > Coordinators;
+
+  Coordinators models;
+};
 
 } } } } // namespace paradevs tests mpi cluster