remove a dependency on MSG from SMPI

diff --git a/src/smpi/include/private.hpp b/src/smpi/include/private.hpp
index 2556f4c..68a8108 100644 (file)
--- a/src/smpi/include/private.hpp
+++ b/src/smpi/include/private.hpp
@@ -6,7 +6,7 @@
 #ifndef SMPI_PRIVATE_HPP
 #define SMPI_PRIVATE_HPP
 
 #ifndef SMPI_PRIVATE_HPP
 #define SMPI_PRIVATE_HPP
 

-#include "simgrid/msg.h" // msg_bar_t
+#include "simgrid/s4u/Barrier.hpp"

 #include "smpi/smpi.h"
 #include "smpi/smpi_helpers_internal.h"
 #include "src/instr/instr_smpi.hpp"
 #include "smpi/smpi.h"
 #include "smpi/smpi_helpers_internal.h"
 #include "src/instr/instr_smpi.hpp"


@@ -66,7 +66,7 @@ XBT_PRIVATE int smpi_process_count();
 XBT_PRIVATE void smpi_deployment_register_process(const std::string instance_id, int rank,
                                                   simgrid::s4u::ActorPtr actor);
 XBT_PRIVATE MPI_Comm* smpi_deployment_comm_world(const std::string instance_id);
 XBT_PRIVATE void smpi_deployment_register_process(const std::string instance_id, int rank,
                                                   simgrid::s4u::ActorPtr actor);
 XBT_PRIVATE MPI_Comm* smpi_deployment_comm_world(const std::string instance_id);

-XBT_PRIVATE msg_bar_t smpi_deployment_finalization_barrier(const std::string instance_id);
+XBT_PRIVATE simgrid::s4u::Barrier* smpi_deployment_finalization_barrier(const std::string instance_id);

 XBT_PRIVATE void smpi_deployment_cleanup_instances();
 
 XBT_PRIVATE void smpi_comm_copy_buffer_callback(smx_activity_t comm, void* buff, size_t buff_size);
 XBT_PRIVATE void smpi_deployment_cleanup_instances();
 
 XBT_PRIVATE void smpi_comm_copy_buffer_callback(smx_activity_t comm, void* buff, size_t buff_size);

diff --git a/src/smpi/include/smpi_process.hpp b/src/smpi/include/smpi_process.hpp
index e7c6772..eaa3ed1 100644 (file)
--- a/src/smpi/include/smpi_process.hpp
+++ b/src/smpi/include/smpi_process.hpp
@@ -32,7 +32,7 @@ class Process {
     int sampling_                   = 0; /* inside an SMPI_SAMPLE_ block? */
     std::string instance_id_;
     bool replaying_                 = false; /* is the process replaying a trace */
     int sampling_                   = 0; /* inside an SMPI_SAMPLE_ block? */
     std::string instance_id_;
     bool replaying_                 = false; /* is the process replaying a trace */

-    msg_bar_t finalization_barrier_;
+    simgrid::s4u::Barrier* finalization_barrier_;

     smpi_trace_call_location_t trace_call_loc_;
     simgrid::s4u::ActorPtr actor_ = nullptr;
     smpi_privatization_region_t privatized_region_;
     smpi_trace_call_location_t trace_call_loc_;
     simgrid::s4u::ActorPtr actor_ = nullptr;
     smpi_privatization_region_t privatized_region_;


@@ -43,7 +43,7 @@ class Process {
     papi_counter_t papi_counter_data_;
 #endif
   public:
     papi_counter_t papi_counter_data_;
 #endif
   public:

-    explicit Process(simgrid::s4u::ActorPtr actor, msg_bar_t barrier);
+    explicit Process(simgrid::s4u::ActorPtr actor, simgrid::s4u::Barrier* barrier);

     ~Process();
     void set_data(int* argc, char*** argv);
     void finalize();
     ~Process();
     void set_data(int* argc, char*** argv);
     void finalize();

diff --git a/src/smpi/include/smpi_win.hpp b/src/smpi/include/smpi_win.hpp
index d29f96a..ec89c1d 100644 (file)
--- a/src/smpi/include/smpi_win.hpp
+++ b/src/smpi/include/smpi_win.hpp
@@ -7,10 +7,10 @@
 #ifndef SMPI_WIN_HPP_INCLUDED
 #define SMPI_WIN_HPP_INCLUDED
 
 #ifndef SMPI_WIN_HPP_INCLUDED
 #define SMPI_WIN_HPP_INCLUDED
 

+#include "simgrid/s4u/Barrier.hpp"

 #include "smpi_f2c.hpp"
 #include "smpi_keyvals.hpp"
 #include "xbt/synchro.h"
 #include "smpi_f2c.hpp"
 #include "smpi_keyvals.hpp"
 #include "xbt/synchro.h"

-#include <simgrid/msg.h>

 
 #include <vector>
 #include <list>
 
 #include <vector>
 #include <list>


@@ -28,7 +28,7 @@ class Win : public F2C, public Keyval {
   MPI_Comm comm_;
   std::vector<MPI_Request> *requests_;
   xbt_mutex_t mut_;
   MPI_Comm comm_;
   std::vector<MPI_Request> *requests_;
   xbt_mutex_t mut_;

-  msg_bar_t bar_;
+  simgrid::s4u::Barrier* bar_;

   MPI_Win* connected_wins_;
   char* name_;
   int opened_;
   MPI_Win* connected_wins_;
   char* name_;
   int opened_;

diff --git a/src/smpi/internals/smpi_deployment.cpp b/src/smpi/internals/smpi_deployment.cpp
index 6c1c75c..ccf7148 100644 (file)
--- a/src/smpi/internals/smpi_deployment.cpp
+++ b/src/smpi/internals/smpi_deployment.cpp
@@ -6,7 +6,6 @@
 
 #include "smpi_host.hpp"
 #include "private.hpp"
 
 #include "smpi_host.hpp"
 #include "private.hpp"

-#include "simgrid/msg.h" /* barrier */

 #include "simgrid/s4u/Engine.hpp"
 #include "smpi_comm.hpp"
 #include <map>
 #include "simgrid/s4u/Engine.hpp"
 #include "smpi_comm.hpp"
 #include <map>


@@ -18,7 +17,7 @@ namespace app {
 class Instance {
 public:
   Instance(const std::string name, int max_no_processes, int process_count, MPI_Comm comm,
 class Instance {
 public:
   Instance(const std::string name, int max_no_processes, int process_count, MPI_Comm comm,

-           msg_bar_t finalization_barrier)
+           simgrid::s4u::Barrier* finalization_barrier)

       : name(name)
       , size(max_no_processes)
       , present_processes(0)
       : name(name)
       , size(max_no_processes)
       , present_processes(0)


@@ -30,7 +29,7 @@ public:
   int size;
   int present_processes;
   MPI_Comm comm_world;
   int size;
   int present_processes;
   MPI_Comm comm_world;

-  msg_bar_t finalization_barrier;
+  simgrid::s4u::Barrier* finalization_barrier;

 };
 }
 }
 };
 }
 }


@@ -63,7 +62,8 @@ void SMPI_app_instance_register(const char *name, xbt_main_func_t code, int num_
     }
   }
 
     }
   }
 

-  Instance instance(std::string(name), num_processes, process_count, MPI_COMM_NULL, MSG_barrier_init(num_processes));
+  Instance instance(std::string(name), num_processes, process_count, MPI_COMM_NULL,
+                    new simgrid::s4u::Barrier(num_processes));

   MPI_Group group     = new simgrid::smpi::Group(instance.size);
   instance.comm_world = new simgrid::smpi::Comm(group, nullptr);
   MPI_Attr_put(instance.comm_world, MPI_UNIVERSE_SIZE, reinterpret_cast<void*>(instance.size));
   MPI_Group group     = new simgrid::smpi::Group(instance.size);
   instance.comm_world = new simgrid::smpi::Comm(group, nullptr);
   MPI_Attr_put(instance.comm_world, MPI_UNIVERSE_SIZE, reinterpret_cast<void*>(instance.size));


@@ -90,7 +90,7 @@ MPI_Comm* smpi_deployment_comm_world(const std::string instance_id)
   return &instance.comm_world;
 }
 
   return &instance.comm_world;
 }
 

-msg_bar_t smpi_deployment_finalization_barrier(const std::string instance_id)
+simgrid::s4u::Barrier* smpi_deployment_finalization_barrier(const std::string instance_id)

 {
   if (smpi_instances.empty()) { // no instance registered, we probably used smpirun.
     return nullptr;
 {
   if (smpi_instances.empty()) { // no instance registered, we probably used smpirun.
     return nullptr;


@@ -102,7 +102,7 @@ msg_bar_t smpi_deployment_finalization_barrier(const std::string instance_id)
 void smpi_deployment_cleanup_instances(){
   for (auto const& item : smpi_instances) {
     Instance instance = item.second;
 void smpi_deployment_cleanup_instances(){
   for (auto const& item : smpi_instances) {
     Instance instance = item.second;

-    MSG_barrier_destroy(instance.finalization_barrier);
+    delete instance.finalization_barrier;

     simgrid::smpi::Comm::destroy(instance.comm_world);
   }
   smpi_instances.clear();
     simgrid::smpi::Comm::destroy(instance.comm_world);
   }
   smpi_instances.clear();

diff --git a/src/smpi/internals/smpi_process.cpp b/src/smpi/internals/smpi_process.cpp
index d5edd03..2bf2d11 100644 (file)
--- a/src/smpi/internals/smpi_process.cpp
+++ b/src/smpi/internals/smpi_process.cpp
@@ -18,7 +18,7 @@ namespace smpi{
 using simgrid::s4u::Actor;
 using simgrid::s4u::ActorPtr;
 
 using simgrid::s4u::Actor;
 using simgrid::s4u::ActorPtr;
 

-Process::Process(ActorPtr actor, msg_bar_t finalization_barrier)
+Process::Process(ActorPtr actor, simgrid::s4u::Barrier* finalization_barrier)

     : finalization_barrier_(finalization_barrier), actor_(actor)
 {
   mailbox_         = simgrid::s4u::Mailbox::by_name("SMPI-" + std::to_string(actor_->get_pid()));
     : finalization_barrier_(finalization_barrier), actor_(actor)
 {
   mailbox_         = simgrid::s4u::Mailbox::by_name("SMPI-" + std::to_string(actor_->get_pid()));


@@ -61,7 +61,7 @@ void Process::set_data(int* argc, char*** argv)
 {
   instance_id_      = std::string((*argv)[1]);
   comm_world_       = smpi_deployment_comm_world(instance_id_);
 {
   instance_id_      = std::string((*argv)[1]);
   comm_world_       = smpi_deployment_comm_world(instance_id_);

-  msg_bar_t barrier = smpi_deployment_finalization_barrier(instance_id_);
+  simgrid::s4u::Barrier* barrier = smpi_deployment_finalization_barrier(instance_id_);

   if (barrier != nullptr) // don't overwrite the current one if the instance has none
     finalization_barrier_ = barrier;
 
   if (barrier != nullptr) // don't overwrite the current one if the instance has none
     finalization_barrier_ = barrier;
 


@@ -91,7 +91,7 @@ void Process::finalize()
   if(MC_is_active() || MC_record_replay_is_active())
     return;
   // wait for all pending asynchronous comms to finish
   if(MC_is_active() || MC_record_replay_is_active())
     return;
   // wait for all pending asynchronous comms to finish

-  MSG_barrier_wait(finalization_barrier_);
+  finalization_barrier_->wait();

 }
 
 /** @brief Check if a process is finalized */
 }
 
 /** @brief Check if a process is finalized */

diff --git a/src/smpi/mpi/smpi_win.cpp b/src/smpi/mpi/smpi_win.cpp
index c082e48..5e00ce5 100644 (file)
--- a/src/smpi/mpi/smpi_win.cpp
+++ b/src/smpi/mpi/smpi_win.cpp
@@ -39,7 +39,7 @@ Win::Win(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm,
   connected_wins_[rank_] = this;
   count_                 = 0;
   if(rank_==0){
   connected_wins_[rank_] = this;
   count_                 = 0;
   if(rank_==0){

-    bar_ = MSG_barrier_init(comm_size);
+    bar_ = new simgrid::s4u::Barrier(comm_size);

   }
   mode_=0;
 
   }
   mode_=0;
 


@@ -49,14 +49,14 @@ Win::Win(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm,
   Colls::allgather(&(connected_wins_[rank_]), sizeof(MPI_Win), MPI_BYTE, connected_wins_, sizeof(MPI_Win),
                          MPI_BYTE, comm);
 
   Colls::allgather(&(connected_wins_[rank_]), sizeof(MPI_Win), MPI_BYTE, connected_wins_, sizeof(MPI_Win),
                          MPI_BYTE, comm);
 

-  Colls::bcast(&(bar_), sizeof(msg_bar_t), MPI_BYTE, 0, comm);
+  Colls::bcast(&(bar_), sizeof(simgrid::s4u::Barrier*), MPI_BYTE, 0, comm);

 
   Colls::barrier(comm);
 }
 
 Win::~Win(){
   //As per the standard, perform a barrier to ensure every async comm is finished
 
   Colls::barrier(comm);
 }
 
 Win::~Win(){
   //As per the standard, perform a barrier to ensure every async comm is finished

-  MSG_barrier_wait(bar_);
+  bar_->wait();

 
   int finished = finish_comms();
   XBT_DEBUG("Win destructor - Finished %d RMA calls", finished);
 
   int finished = finish_comms();
   XBT_DEBUG("Win destructor - Finished %d RMA calls", finished);


@@ -76,7 +76,7 @@ Win::~Win(){
   Comm::unref(comm_);
   
   if (rank_ == 0)
   Comm::unref(comm_);
   
   if (rank_ == 0)

-    MSG_barrier_destroy(bar_);
+    delete bar_;

   xbt_mutex_destroy(mut_);
   xbt_mutex_destroy(lock_mut_);
   xbt_mutex_destroy(atomic_mut_);
   xbt_mutex_destroy(mut_);
   xbt_mutex_destroy(lock_mut_);
   xbt_mutex_destroy(atomic_mut_);


@@ -163,7 +163,7 @@ int Win::fence(int assert)
     opened_=1;
   if (assert != MPI_MODE_NOPRECEDE) {
     // This is not the first fence => finalize what came before
     opened_=1;
   if (assert != MPI_MODE_NOPRECEDE) {
     // This is not the first fence => finalize what came before

-    MSG_barrier_wait(bar_);
+    bar_->wait();

     xbt_mutex_acquire(mut_);
     // This (simulated) mutex ensures that no process pushes to the vector of requests during the waitall.
     // Without this, the vector could get redimensionned when another process pushes.
     xbt_mutex_acquire(mut_);
     // This (simulated) mutex ensures that no process pushes to the vector of requests during the waitall.
     // Without this, the vector could get redimensionned when another process pushes.


@@ -184,7 +184,7 @@ int Win::fence(int assert)
     opened_=0;
   assert_ = assert;
 
     opened_=0;
   assert_ = assert;
 

-  MSG_barrier_wait(bar_);
+  bar_->wait();

   XBT_DEBUG("Leaving fence");
 
   return MPI_SUCCESS;
   XBT_DEBUG("Leaving fence");
 
   return MPI_SUCCESS;


@@ -629,9 +629,9 @@ int Win::unlock_all(){
   int i=0;
   int retval = MPI_SUCCESS;
   for (i=0; i<comm_->size();i++){
   int i=0;
   int retval = MPI_SUCCESS;
   for (i=0; i<comm_->size();i++){

-      int ret = this->unlock(i);
-      if(ret != MPI_SUCCESS)
-        retval = ret;
+    int ret = this->unlock(i);
+    if (ret != MPI_SUCCESS)
+      retval = ret;

   }
   return retval;
 }
   }
   return retval;
 }


@@ -652,11 +652,9 @@ int Win::flush_local(int rank){
 }
 
 int Win::flush_all(){
 }
 
 int Win::flush_all(){

-  int i=0;
-  int finished = 0;
-  finished = finish_comms();
+  int finished = finish_comms();

   XBT_DEBUG("Win_flush_all on local - Finished %d RMA calls", finished);
   XBT_DEBUG("Win_flush_all on local - Finished %d RMA calls", finished);

-  for (i=0; i<comm_->size();i++){
+  for (int i = 0; i < comm_->size(); i++) {

     finished = connected_wins_[i]->finish_comms(rank_);
     XBT_DEBUG("Win_flush_all on %d - Finished %d RMA calls", i, finished);
   }
     finished = connected_wins_[i]->finish_comms(rank_);
     XBT_DEBUG("Win_flush_all on %d - Finished %d RMA calls", i, finished);
   }


@@ -673,7 +671,6 @@ Win* Win::f2c(int id){
   return static_cast<Win*>(F2C::f2c(id));
 }
 
   return static_cast<Win*>(F2C::f2c(id));
 }
 

-

 int Win::finish_comms(){
   xbt_mutex_acquire(mut_);
   //Finish own requests
 int Win::finish_comms(){
   xbt_mutex_acquire(mut_);
   //Finish own requests