X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1bd7cbc6f7c9069a69935f33ab7867de949babe7..2a7d4780fb29f8e689819f284389fbc7f9ce8543:/src/smpi/mpi/smpi_win.cpp?ds=sidebyside diff --git a/src/smpi/mpi/smpi_win.cpp b/src/smpi/mpi/smpi_win.cpp index 5e00ce5143..84d748ac51 100644 --- a/src/smpi/mpi/smpi_win.cpp +++ b/src/smpi/mpi/smpi_win.cpp @@ -1,21 +1,21 @@ -/* Copyright (c) 2007-2018. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2007-2019. 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. */ #include "smpi_win.hpp" + #include "private.hpp" #include "smpi_coll.hpp" #include "smpi_comm.hpp" #include "smpi_datatype.hpp" #include "smpi_info.hpp" #include "smpi_keyvals.hpp" -#include "smpi_process.hpp" #include "smpi_request.hpp" +#include "src/smpi/include/smpi_actor.hpp" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_rma, smpi, "Logging specific to SMPI (RMA operations)"); -using simgrid::s4u::Actor; namespace simgrid{ namespace smpi{ @@ -32,14 +32,14 @@ Win::Win(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, opened_ = 0; group_ = MPI_GROUP_NULL; requests_ = new std::vector(); - mut_ = xbt_mutex_init(); - lock_mut_ = xbt_mutex_init(); - atomic_mut_ = xbt_mutex_init(); + mut_ = s4u::Mutex::create(); + lock_mut_ = s4u::Mutex::create(); + atomic_mut_ = s4u::Mutex::create(); connected_wins_ = new MPI_Win[comm_size]; connected_wins_[rank_] = this; count_ = 0; if(rank_==0){ - bar_ = new simgrid::s4u::Barrier(comm_size); + bar_ = new s4u::Barrier(comm_size); } mode_=0; @@ -49,7 +49,7 @@ 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::bcast(&(bar_), sizeof(simgrid::s4u::Barrier*), MPI_BYTE, 0, comm); + Colls::bcast(&(bar_), sizeof(s4u::Barrier*), MPI_BYTE, 0, comm); Colls::barrier(comm); } @@ -77,9 +77,6 @@ Win::~Win(){ if (rank_ == 0) delete bar_; - xbt_mutex_destroy(mut_); - xbt_mutex_destroy(lock_mut_); - xbt_mutex_destroy(atomic_mut_); if(allocated_ !=0) xbt_free(base_); @@ -164,7 +161,7 @@ int Win::fence(int assert) if (assert != MPI_MODE_NOPRECEDE) { // This is not the first fence => finalize what came before bar_->wait(); - xbt_mutex_acquire(mut_); + mut_->lock(); // 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. // This would result in the array used by Request::waitall() to be invalidated. @@ -177,7 +174,7 @@ int Win::fence(int assert) Request::waitall(size, treqs, MPI_STATUSES_IGNORE); } count_=0; - xbt_mutex_release(mut_); + mut_->unlock(); } if(assert==MPI_MODE_NOSUCCEED)//there should be no ops after this one, tell we are closed. @@ -230,16 +227,16 @@ int Win::put( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, if(request!=nullptr){ *request=sreq; }else{ - xbt_mutex_acquire(mut_); + mut_->lock(); requests_->push_back(sreq); - xbt_mutex_release(mut_); + mut_->unlock(); } //push request to receiver's win - xbt_mutex_acquire(recv_win->mut_); + recv_win->mut_->lock(); recv_win->requests_->push_back(rreq); rreq->start(); - xbt_mutex_release(recv_win->mut_); + recv_win->mut_->unlock(); }else{ XBT_DEBUG("Entering MPI_Put from myself to myself, rank %d", target_rank); @@ -287,9 +284,9 @@ int Win::get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, //start the send, with another process than us as sender. sreq->start(); //push request to receiver's win - xbt_mutex_acquire(send_win->mut_); + send_win->mut_->lock(); send_win->requests_->push_back(sreq); - xbt_mutex_release(send_win->mut_); + send_win->mut_->unlock(); //start recv rreq->start(); @@ -297,9 +294,9 @@ int Win::get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, if(request!=nullptr){ *request=rreq; }else{ - xbt_mutex_acquire(mut_); + mut_->lock(); requests_->push_back(rreq); - xbt_mutex_release(mut_); + mut_->unlock(); } }else{ @@ -350,17 +347,17 @@ int Win::accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_da // start send sreq->start(); // push request to receiver's win - xbt_mutex_acquire(recv_win->mut_); + recv_win->mut_->lock(); recv_win->requests_->push_back(rreq); rreq->start(); - xbt_mutex_release(recv_win->mut_); + recv_win->mut_->unlock(); if (request != nullptr) { *request = sreq; } else { - xbt_mutex_acquire(mut_); + mut_->lock(); requests_->push_back(sreq); - xbt_mutex_release(mut_); + mut_->unlock(); } XBT_DEBUG("Leaving MPI_Win_Accumulate"); @@ -390,7 +387,7 @@ int Win::get_accumulate( void *origin_addr, int origin_count, MPI_Datatype origi XBT_DEBUG("Entering MPI_Get_accumulate from %d", target_rank); //need to be sure ops are correctly ordered, so finish request here ? slow. MPI_Request req; - xbt_mutex_acquire(send_win->atomic_mut_); + send_win->atomic_mut_->lock(); get(result_addr, result_count, result_datatype, target_rank, target_disp, target_count, target_datatype, &req); if (req != MPI_REQUEST_NULL) @@ -400,7 +397,7 @@ int Win::get_accumulate( void *origin_addr, int origin_count, MPI_Datatype origi target_disp, target_count, target_datatype, op, &req); if (req != MPI_REQUEST_NULL) Request::wait(&req, MPI_STATUS_IGNORE); - xbt_mutex_release(send_win->atomic_mut_); + send_win->atomic_mut_->unlock(); return MPI_SUCCESS; } @@ -423,7 +420,7 @@ int Win::compare_and_swap(void *origin_addr, void *compare_addr, XBT_DEBUG("Entering MPI_Compare_and_swap with %d", target_rank); MPI_Request req = MPI_REQUEST_NULL; - xbt_mutex_acquire(send_win->atomic_mut_); + send_win->atomic_mut_->lock(); get(result_addr, 1, datatype, target_rank, target_disp, 1, datatype, &req); if (req != MPI_REQUEST_NULL) @@ -432,7 +429,7 @@ int Win::compare_and_swap(void *origin_addr, void *compare_addr, put(origin_addr, 1, datatype, target_rank, target_disp, 1, datatype); } - xbt_mutex_release(send_win->atomic_mut_); + send_win->atomic_mut_->unlock(); return MPI_SUCCESS; } @@ -581,10 +578,10 @@ int Win::lock(int lock_type, int rank, int assert){ MPI_Win target_win = connected_wins_[rank]; if ((lock_type == MPI_LOCK_EXCLUSIVE && target_win->mode_ != MPI_LOCK_SHARED)|| target_win->mode_ == MPI_LOCK_EXCLUSIVE){ - xbt_mutex_acquire(target_win->lock_mut_); + target_win->lock_mut_->lock(); target_win->mode_+= lock_type;//add the lock_type to differentiate case when we are switching from EXCLUSIVE to SHARED (no release needed in the unlock) if(lock_type == MPI_LOCK_SHARED){//the window used to be exclusive, it's now shared. - xbt_mutex_release(target_win->lock_mut_); + target_win->lock_mut_->unlock(); } } else if (not(target_win->mode_ == MPI_LOCK_SHARED && lock_type == MPI_LOCK_EXCLUSIVE)) target_win->mode_ += lock_type; // don't set to exclusive if it's already shared @@ -615,7 +612,7 @@ int Win::unlock(int rank){ target_win->mode_= 0; target_win->lockers_.remove(comm_->rank()); if (target_mode==MPI_LOCK_EXCLUSIVE){ - xbt_mutex_release(target_win->lock_mut_); + target_win->lock_mut_->unlock(); } int finished = finish_comms(rank); @@ -672,7 +669,7 @@ Win* Win::f2c(int id){ } int Win::finish_comms(){ - xbt_mutex_acquire(mut_); + mut_->lock(); //Finish own requests std::vector *reqqs = requests_; int size = static_cast(reqqs->size()); @@ -681,12 +678,12 @@ int Win::finish_comms(){ Request::waitall(size, treqs, MPI_STATUSES_IGNORE); reqqs->clear(); } - xbt_mutex_release(mut_); + mut_->unlock(); return size; } int Win::finish_comms(int rank){ - xbt_mutex_acquire(mut_); + mut_->lock(); //Finish own requests std::vector *reqqs = requests_; int size = static_cast(reqqs->size()); @@ -714,7 +711,7 @@ int Win::finish_comms(int rank){ myreqqs.clear(); } } - xbt_mutex_release(mut_); + mut_->unlock(); return size; }