X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2f3c9cf811c7c608eb49a3ee14411a887b6a99c8..302c1c4ddcf29390c1845adc161264e96d8a9a44:/src/smpi/mpi/smpi_win.cpp

diff --git a/src/smpi/mpi/smpi_win.cpp b/src/smpi/mpi/smpi_win.cpp
index 588e5cfea7..73bd32d6cc 100644
--- a/src/smpi/mpi/smpi_win.cpp
+++ b/src/smpi/mpi/smpi_win.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2020. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -22,13 +22,20 @@ namespace smpi{
 std::unordered_map<int, smpi_key_elem> Win::keyvals_;
 int Win::keyval_id_=0;
 
-Win::Win(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, int allocated, int dynamic): base_(base), size_(size), disp_unit_(disp_unit), assert_(0), info_(info), comm_(comm), allocated_(allocated), dynamic_(dynamic){
-  int comm_size = comm->size();
-  rank_         = comm->rank();
+Win::Win(void* base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, int allocated, int dynamic)
+    : base_(base)
+    , size_(size)
+    , disp_unit_(disp_unit)
+    , info_(info)
+    , comm_(comm)
+    , rank_(comm->rank())
+    , allocated_(allocated)
+    , dynamic_(dynamic)
+{
   XBT_DEBUG("Creating window");
   if(info!=MPI_INFO_NULL)
     info->ref();
-  name_                  = nullptr;
+  int comm_size          = comm->size();
   opened_                = 0;
   group_                 = MPI_GROUP_NULL;
   requests_              = new std::vector<MPI_Request>();
@@ -43,6 +50,7 @@ Win::Win(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm,
   }
   mode_=0;
   errhandler_=MPI_ERRORS_ARE_FATAL;
+  errhandler_->ref();
   comm->add_rma_win(this);
   comm->ref();
 
@@ -63,11 +71,10 @@ Win::~Win(){
 
   delete requests_;
   delete[] connected_wins_;
-  if (name_ != nullptr){
-    xbt_free(name_);
-  }
   if (info_ != MPI_INFO_NULL)
     simgrid::smpi::Info::unref(info_);
+  if (errhandler_ != MPI_ERRHANDLER_NULL)
+    simgrid::smpi::Errhandler::unref(errhandler_);
 
   comm_->remove_rma_win(this);
 
@@ -85,9 +92,9 @@ Win::~Win(){
 
 int Win::attach(void* /*base*/, MPI_Aint size)
 {
-  if (not(base_ == MPI_BOTTOM || base_ == 0))
+  if (not(base_ == MPI_BOTTOM || base_ == nullptr))
     return MPI_ERR_ARG;
-  base_=0;//actually the address will be given in the RMA calls, as being the disp.
+  base_ = nullptr; // actually the address will be given in the RMA calls, as being the disp.
   size_+=size;
   return MPI_SUCCESS;
 }
@@ -99,14 +106,13 @@ int Win::detach(const void* /*base*/)
   return MPI_SUCCESS;
 }
 
-void Win::get_name(char* name, int* length){
-  if(name_==nullptr){
-    *length=0;
-    name=nullptr;
-    return;
+void Win::get_name(char* name, int* length) const
+{
+  *length = name_.length();
+  if (not name_.empty()) {
+    name_.copy(name, *length);
+    name[*length] = '\0';
   }
-  *length = strlen(name_);
-  strncpy(name, name_, *length+1);
 }
 
 void Win::get_group(MPI_Group* group){
@@ -125,23 +131,28 @@ MPI_Info Win::info()
   return info_;
 }
 
-int Win::rank(){
+int Win::rank() const
+{
   return rank_;
 }
 
-MPI_Aint Win::size(){
+MPI_Aint Win::size() const
+{
   return size_;
 }
 
-void* Win::base(){
+void* Win::base() const
+{
   return base_;
 }
 
-int Win::disp_unit(){
+int Win::disp_unit() const
+{
   return disp_unit_;
 }
 
-int Win::dynamic(){
+int Win::dynamic() const
+{
   return dynamic_;
 }
 
@@ -155,7 +166,7 @@ void Win::set_info(MPI_Info info)
 }
 
 void Win::set_name(const char* name){
-  name_ = xbt_strdup(name);
+  name_ = name;
 }
 
 int Win::fence(int assert)
@@ -196,7 +207,7 @@ int Win::put(const void *origin_addr, int origin_count, MPI_Datatype origin_data
               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Request* request)
 {
   //get receiver pointer
-  MPI_Win recv_win = connected_wins_[target_rank];
+  const Win* recv_win = connected_wins_[target_rank];
 
   if(opened_==0){//check that post/start has been done
     // no fence or start .. lock ok ?
@@ -211,7 +222,7 @@ int Win::put(const void *origin_addr, int origin_count, MPI_Datatype origin_data
   if(target_count*target_datatype->get_extent()>recv_win->size_)
     return MPI_ERR_ARG;
 
-  void* recv_addr = static_cast<void*> ( static_cast<char*>(recv_win->base_) + target_disp * recv_win->disp_unit_);
+  void* recv_addr = static_cast<char*>(recv_win->base_) + target_disp * recv_win->disp_unit_;
 
   if (target_rank != comm_->rank()) { // This is not for myself, so we need to send messages
     XBT_DEBUG("Entering MPI_Put to remote rank %d", target_rank);
@@ -256,7 +267,7 @@ int Win::get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Request* request)
 {
   //get sender pointer
-  MPI_Win send_win = connected_wins_[target_rank];
+  const Win* send_win = connected_wins_[target_rank];
 
   if(opened_==0){//check that post/start has been done
     // no fence or start .. lock ok ?
@@ -271,7 +282,7 @@ int Win::get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
   if(target_count*target_datatype->get_extent()>send_win->size_)
     return MPI_ERR_ARG;
 
-  void* send_addr = static_cast<void*>(static_cast<char*>(send_win->base_) + target_disp * send_win->disp_unit_);
+  const void* send_addr = static_cast<void*>(static_cast<char*>(send_win->base_) + target_disp * send_win->disp_unit_);
   XBT_DEBUG("Entering MPI_Get from %d", target_rank);
 
   if(target_rank != comm_->rank()){
@@ -315,7 +326,7 @@ int Win::accumulate(const void *origin_addr, int origin_count, MPI_Datatype orig
 {
   XBT_DEBUG("Entering MPI_Win_Accumulate");
   //get receiver pointer
-  MPI_Win recv_win = connected_wins_[target_rank];
+  const Win* recv_win = connected_wins_[target_rank];
 
   if(opened_==0){//check that post/start has been done
     // no fence or start .. lock ok ?
@@ -331,7 +342,7 @@ int Win::accumulate(const void *origin_addr, int origin_count, MPI_Datatype orig
   if(target_count*target_datatype->get_extent()>recv_win->size_)
     return MPI_ERR_ARG;
 
-  void* recv_addr = static_cast<void*>(static_cast<char*>(recv_win->base_) + target_disp * recv_win->disp_unit_);
+  void* recv_addr = static_cast<char*>(recv_win->base_) + target_disp * recv_win->disp_unit_;
   XBT_DEBUG("Entering MPI_Accumulate to %d", target_rank);
   // As the tag will be used for ordering of the operations, subtract count from it (to avoid collisions with other
   // SMPI tags, SMPI_RMA_TAG is set below all the other ones we use)
@@ -371,7 +382,7 @@ int Win::get_accumulate(const void* origin_addr, int origin_count, MPI_Datatype
                         int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Request*)
 {
   //get sender pointer
-  MPI_Win send_win = connected_wins_[target_rank];
+  const Win* send_win = connected_wins_[target_rank];
 
   if(opened_==0){//check that post/start has been done
     // no fence or start .. lock ok ?
@@ -403,11 +414,11 @@ int Win::get_accumulate(const void* origin_addr, int origin_count, MPI_Datatype
   return MPI_SUCCESS;
 }
 
-int Win::compare_and_swap(const void *origin_addr, void *compare_addr,
-        void *result_addr, MPI_Datatype datatype, int target_rank,
-        MPI_Aint target_disp){
+int Win::compare_and_swap(const void* origin_addr, const void* compare_addr, void* result_addr, MPI_Datatype datatype,
+                          int target_rank, MPI_Aint target_disp)
+{
   //get sender pointer
-  MPI_Win send_win = connected_wins_[target_rank];
+  const Win* send_win = connected_wins_[target_rank];
 
   if(opened_==0){//check that post/start has been done
     // no fence or start .. lock ok ?
@@ -452,7 +463,7 @@ int Win::start(MPI_Group group, int /*assert*/)
   int i             = 0;
   int j             = 0;
   int size          = group->size();
-  MPI_Request* reqs = xbt_new0(MPI_Request, size);
+  std::vector<MPI_Request> reqs(size);
 
   XBT_DEBUG("Entering MPI_Win_Start");
   while (j != size) {
@@ -464,12 +475,11 @@ int Win::start(MPI_Group group, int /*assert*/)
     j++;
   }
   size = i;
-  Request::startall(size, reqs);
-  Request::waitall(size, reqs, MPI_STATUSES_IGNORE);
+  Request::startall(size, reqs.data());
+  Request::waitall(size, reqs.data(), MPI_STATUSES_IGNORE);
   for (i = 0; i < size; i++) {
     Request::unref(&reqs[i]);
   }
-  xbt_free(reqs);
   opened_++; //we're open for business !
   group_=group;
   group->ref();
@@ -483,7 +493,7 @@ int Win::post(MPI_Group group, int /*assert*/)
   int i             = 0;
   int j             = 0;
   int size = group->size();
-  MPI_Request* reqs = xbt_new0(MPI_Request, size);
+  std::vector<MPI_Request> reqs(size);
 
   XBT_DEBUG("Entering MPI_Win_Post");
   while(j!=size){
@@ -496,12 +506,11 @@ int Win::post(MPI_Group group, int /*assert*/)
   }
   size=i;
 
-  Request::startall(size, reqs);
-  Request::waitall(size, reqs, MPI_STATUSES_IGNORE);
+  Request::startall(size, reqs.data());
+  Request::waitall(size, reqs.data(), MPI_STATUSES_IGNORE);
   for(i=0;i<size;i++){
     Request::unref(&reqs[i]);
   }
-  xbt_free(reqs);
   opened_++; //we're open for business !
   group_=group;
   group->ref();
@@ -517,7 +526,7 @@ int Win::complete(){
   int i             = 0;
   int j             = 0;
   int size          = group_->size();
-  MPI_Request* reqs = xbt_new0(MPI_Request, size);
+  std::vector<MPI_Request> reqs(size);
 
   while(j!=size){
     int dst = comm_->group()->rank(group_->actor(j));
@@ -529,13 +538,12 @@ int Win::complete(){
   }
   size=i;
   XBT_DEBUG("Win_complete - Sending sync messages to %d processes", size);
-  Request::startall(size, reqs);
-  Request::waitall(size, reqs, MPI_STATUSES_IGNORE);
+  Request::startall(size, reqs.data());
+  Request::waitall(size, reqs.data(), MPI_STATUSES_IGNORE);
 
   for(i=0;i<size;i++){
     Request::unref(&reqs[i]);
   }
-  xbt_free(reqs);
 
   int finished = finish_comms();
   XBT_DEBUG("Win_complete - Finished %d RMA calls", finished);
@@ -551,7 +559,7 @@ int Win::wait(){
   int i             = 0;
   int j             = 0;
   int size          = group_->size();
-  MPI_Request* reqs = xbt_new0(MPI_Request, size);
+  std::vector<MPI_Request> reqs(size);
 
   while(j!=size){
     int src = comm_->group()->rank(group_->actor(j));
@@ -563,12 +571,11 @@ int Win::wait(){
   }
   size=i;
   XBT_DEBUG("Win_wait - Receiving sync messages from %d processes", size);
-  Request::startall(size, reqs);
-  Request::waitall(size, reqs, MPI_STATUSES_IGNORE);
+  Request::startall(size, reqs.data());
+  Request::waitall(size, reqs.data(), MPI_STATUSES_IGNORE);
   for(i=0;i<size;i++){
     Request::unref(&reqs[i]);
   }
-  xbt_free(reqs);
   int finished = finish_comms();
   XBT_DEBUG("Win_wait - Finished %d RMA calls", finished);
 
@@ -600,12 +607,11 @@ int Win::lock(int lock_type, int rank, int /*assert*/)
 }
 
 int Win::lock_all(int assert){
-  int i=0;
   int retval = MPI_SUCCESS;
-  for (i=0; i<comm_->size();i++){
-      int ret = this->lock(MPI_LOCK_SHARED, i, assert);
-      if(ret != MPI_SUCCESS)
-        retval = ret;
+  for (int i = 0; i < comm_->size(); i++) {
+    int ret = this->lock(MPI_LOCK_SHARED, i, assert);
+    if (ret != MPI_SUCCESS)
+      retval = ret;
   }
   return retval;
 }
@@ -627,9 +633,8 @@ int Win::unlock(int rank){
 }
 
 int Win::unlock_all(){
-  int i=0;
   int retval = MPI_SUCCESS;
-  for (i=0; i<comm_->size();i++){
+  for (int i = 0; i < comm_->size(); i++) {
     int ret = this->unlock(i);
     if (ret != MPI_SUCCESS)
       retval = ret;
@@ -694,7 +699,7 @@ int Win::finish_comms(int rank){
   if (size > 0) {
     size = 0;
     std::vector<MPI_Request> myreqqs;
-    std::vector<MPI_Request>::iterator iter = reqqs->begin();
+    auto iter                               = reqqs->begin();
     int proc_id                             = comm_->group()->actor(rank)->get_pid();
     while (iter != reqqs->end()){
       // Let's see if we're either the destination or the sender of this request
@@ -719,9 +724,9 @@ int Win::finish_comms(int rank){
   return size;
 }
 
-int Win::shared_query(int rank, MPI_Aint* size, int* disp_unit, void* baseptr)
+int Win::shared_query(int rank, MPI_Aint* size, int* disp_unit, void* baseptr) const
 {
-  MPI_Win target_win = rank != MPI_PROC_NULL ? connected_wins_[rank] : nullptr;
+  const Win* target_win = rank != MPI_PROC_NULL ? connected_wins_[rank] : nullptr;
   for (int i = 0; not target_win && i < comm_->size(); i++) {
     if (connected_wins_[i]->size_ > 0)
       target_win = connected_wins_[i];
@@ -732,21 +737,25 @@ int Win::shared_query(int rank, MPI_Aint* size, int* disp_unit, void* baseptr)
     *static_cast<void**>(baseptr) = target_win->base_;
   } else {
     *size                         = 0;
-    *static_cast<void**>(baseptr) = xbt_malloc(0);
+    *static_cast<void**>(baseptr) = nullptr;
   }
   return MPI_SUCCESS;
 }
 
 MPI_Errhandler Win::errhandler()
 {
+  if (errhandler_ != MPI_ERRHANDLER_NULL)
+    errhandler_->ref();
   return errhandler_;
 }
 
 void Win::set_errhandler(MPI_Errhandler errhandler)
 {
+  if (errhandler_ != MPI_ERRHANDLER_NULL)
+    simgrid::smpi::Errhandler::unref(errhandler_);
   errhandler_ = errhandler;
   if (errhandler_ != MPI_ERRHANDLER_NULL)
-    errhandler->ref();
+    errhandler_->ref();
 }
 } // namespace smpi
 } // namespace simgrid