pdevs/mpi: add multithreading simple example for comparison

src/tests/mpi/CMakeLists.txt

@@ -23,6 +23,7 @@ ADD_EXECUTABLE(pdevs-mpi-main graph_manager.hpp main.cpp
   ../boost_graph/partitioning/graph_build.hpp)
 
 TARGET_LINK_LIBRARIES(pdevs-mpi-main
+  ${CMAKE_THREAD_LIBS_INIT}
   ${Boost_SERIALIZATION_LIBRARY}
   ${Boost_MPI_LIBRARY}
   ${MPI_CXX_LIBRARIES})

src/tests/mpi/graph_manager.hpp

@@ -324,6 +324,119 @@ private:
     Nexts nexts;
 };
 
+class RootMultithreadingGraphManager :
+        public paradevs::pdevs::GraphManager < common::DoubleTime,
+                                               RootLocalGraphManagerParameters >
+{
+public:
+    RootMultithreadingGraphManager(
+        common::Coordinator < common::DoubleTime >* coordinator,
+        const RootLocalGraphManagerParameters& parameters) :
+        paradevs::pdevs::GraphManager < common::DoubleTime,
+                                        RootLocalGraphManagerParameters >(
+                                            coordinator, parameters),
+        first("S0", paradevs::common::NoParameters(),
+              paradevs::common::NoParameters())
+    {
+        Next* previous = 0;
+
+        add_child(&first);
+        for (std::vector < int >::const_iterator it = parameters.ranks.begin();
+             it != parameters.ranks.end(); ++it) {
+            std::stringstream ss;
+            Next* model = 0;
+
+            ss << "S" << *it;
+            model = new Next(ss.str(), paradevs::common::NoParameters(),
+                             paradevs::common::NoParameters());
+            nexts.push_back(model);
+            add_child(model);
+            if (it != parameters.ranks.begin()) {
+                add_link(previous, "out", model, "in");
+            }
+            previous = model;
+        }
+        add_link(&first, "out", nexts[0], "in");
+    }
+
+    virtual ~RootMultithreadingGraphManager()
+    {
+        std::for_each(nexts.begin(), nexts.end(),
+                      std::default_delete < Next >());
+    }
+
+    void init()
+    {
+        first.set_sender(
+            dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
+            common::DoubleTime,
+            RootMultithreadingGraphManager,
+            paradevs::common::NoParameters,
+            RootLocalGraphManagerParameters >*
+            >(get_coordinator())->get_sender());
+        for (Nexts::const_iterator it = nexts.begin(); it != nexts.end();
+             ++it) {
+            (*it)->set_sender(
+                dynamic_cast < paradevs::pdevs::multithreading::Coordinator <
+                    common::DoubleTime,
+                    RootMultithreadingGraphManager,
+                    paradevs::common::NoParameters,
+                    RootLocalGraphManagerParameters >*
+                >(get_coordinator())->get_sender());
+        }
+    }
+
+    void start(common::DoubleTime::type t)
+    {
+        first.get_sender().send(
+            paradevs::pdevs::multithreading::start_message <
+            paradevs::common::DoubleTime >(t));
+        for (Nexts::const_iterator it = nexts.begin(); it != nexts.end();
+             ++it) {
+            (*it)->get_sender().send(
+                paradevs::pdevs::multithreading::start_message <
+                    paradevs::common::DoubleTime >(t));
+        }
+    }
+
+    void transition(const common::Models < common::DoubleTime >& receivers,
+                    paradevs::common::DoubleTime::type t)
+    {
+        common::Models < common::DoubleTime >::const_iterator it =
+            receivers.begin();
+
+        while (it != receivers.end()) {
+            if (not (*it)->is_atomic()) {
+                Nexts::const_iterator itc =
+                    std::find(nexts.begin(), nexts.end(), *it);
+
+                if (itc != nexts.end()) {
+                    (*itc)->get_sender().send(
+                        paradevs::pdevs::multithreading::transition_message <
+                        paradevs::common::DoubleTime >(t));
+                } else {
+                    first.get_sender().send(
+                        paradevs::pdevs::multithreading::transition_message <
+                        paradevs::common::DoubleTime >(t));
+                }
+            }
+            ++it;
+        }
+    }
+
+private:
+    typedef paradevs::pdevs::multithreading::Coordinator <
+    common::DoubleTime,
+    S1LocalGraphManager > First;
+    typedef paradevs::pdevs::multithreading::Coordinator <
+        common::DoubleTime,
+        S2LocalGraphManager > Next;
+    typedef std::vector < Next* > Nexts;
+
+    First first;
+    Nexts nexts;
+};
+
 /******************************************************************************/
 
 struct GridGraphManagerParameters

src/tests/mpi/main.cpp

@@ -36,6 +36,7 @@
 
 #include <paradevs/common/time/DoubleTime.hpp>
 #include <paradevs/kernel/pdevs/mpi/LogicalProcessor.hpp>
+#include <paradevs/kernel/pdevs/multithreading/Coordinator.hpp>
 #include <tests/mpi/graph_manager.hpp>
 
 #include <chrono>
@@ -147,6 +148,40 @@ void example_simple_local()
     std::cout << "CHAIN = " << time_span.count() << std::endl;
 }
 
+void example_simple_multithreading()
+{
+    paradevs::tests::mpi::RootLocalGraphManagerParameters parameters;
+
+    parameters.ranks.push_back(1);
+    parameters.ranks.push_back(2);
+    parameters.ranks.push_back(3);
+    parameters.ranks.push_back(4);
+    parameters.ranks.push_back(5);
+    parameters.ranks.push_back(6);
+    parameters.ranks.push_back(7);
+    parameters.ranks.push_back(8);
+
+    paradevs::common::RootCoordinator <
+        DoubleTime,
+        paradevs::pdevs::multithreading::Coordinator <
+            DoubleTime,
+            paradevs::tests::mpi::RootMultithreadingGraphManager,
+            paradevs::common::NoParameters,
+            paradevs::tests::mpi::RootLocalGraphManagerParameters >
+        > rc(0, 1000, "root", paradevs::common::NoParameters(), parameters);
+
+    steady_clock::time_point t1 = steady_clock::now();
+
+    rc.run();
+
+    steady_clock::time_point t2 = steady_clock::now();
+
+    duration < double > time_span = duration_cast <
+        duration < double > >(t2 - t1);
+
+    std::cout << "CHAIN = " << time_span.count() << std::endl;
+}
+
 #define SUB_GRID_SIZE 32
 #define SUB_GRID_NUMBER 8
 
@@ -248,7 +283,8 @@ void example_grid(int argc, char *argv[])
 
 int main(int argc, char *argv[])
 {
-    example_simple(argc, argv);
+    example_simple_multithreading();
+    // example_simple(argc, argv);
 //    example_simple_local();
 //    example_grid(argc, argv);
     return 0;