-/* Copyright (c) 2007-2015. The SimGrid Team.
+/* Copyright (c) 2007-2017. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
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): base_(base), size_(size), disp_unit_(disp_unit), assert_(0), info_(info), comm_(comm){
+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();
XBT_DEBUG("Creating window");
if(rank_==0){
bar_ = MSG_barrier_init(comm_size);
}
+ mode_=0;
comm->add_rma_win(this);
xbt_mutex_destroy(mut_);
xbt_mutex_destroy(lock_mut_);
+ if(allocated_ !=0)
+ xbt_free(base_);
+
cleanup_attr<Win>();
}
+int Win::attach (void *base, MPI_Aint size){
+ if (!(base_ == MPI_BOTTOM || base_ == 0))
+ return MPI_ERR_ARG;
+ base_=0;//actually the address will be given in the RMA calls, as being the disp.
+ size_+=size;
+ return MPI_SUCCESS;
+}
+
+int Win::detach (void *base){
+ base_=MPI_BOTTOM;
+ size_=-1;
+ return MPI_SUCCESS;
+}
+
void Win::get_name(char* name, int* length){
if(name_==nullptr){
*length=0;
}
}
+MPI_Info Win::info(){
+ if(info_== MPI_INFO_NULL)
+ info_ = new Info();
+ info_->ref();
+ return info_;
+}
+
int Win::rank(){
return rank_;
}
return disp_unit_;
}
+int Win::dynamic(){
+ return dynamic_;
+}
+
+void Win::set_info(MPI_Info info){
+ if(info_!= MPI_INFO_NULL)
+ info->ref();
+ info_=info;
+}
void Win::set_name(char* name){
name_ = xbt_strdup(name);
void* recv_addr = static_cast<void*>(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, add count to it
+ //As the tag will be used for ordering of the operations, substract count from it (to avoid collisions with other SMPI tags, SMPI_RMA_TAG is set below all the other ones we use )
//prepare send_request
+
MPI_Request sreq = Request::rma_send_init(origin_addr, origin_count, origin_datatype,
- smpi_process()->index(), comm_->group()->index(target_rank), SMPI_RMA_TAG+3+count_, comm_, op);
+ smpi_process()->index(), comm_->group()->index(target_rank), SMPI_RMA_TAG-3-count_, comm_, op);
//prepare receiver request
MPI_Request rreq = Request::rma_recv_init(recv_addr, target_count, target_datatype,
- smpi_process()->index(), comm_->group()->index(target_rank), SMPI_RMA_TAG+3+count_, recv_win->comm_, op);
+ smpi_process()->index(), comm_->group()->index(target_rank), SMPI_RMA_TAG-3-count_, recv_win->comm_, op);
count_++;
//push request to receiver's win
return MPI_SUCCESS;
}
+int Win::get_accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, void *result_addr,
+ int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp, int target_count,
+ MPI_Datatype target_datatype, MPI_Op op){
+
+ //get sender pointer
+ MPI_Win send_win = connected_wins_[target_rank];
+
+ if(opened_==0){//check that post/start has been done
+ // no fence or start .. lock ok ?
+ int locked=0;
+ for(auto it : send_win->lockers_)
+ if (it == comm_->rank())
+ locked = 1;
+ if(locked != 1)
+ return MPI_ERR_WIN;
+ }
+
+ if(target_count*target_datatype->get_extent()>send_win->size_)
+ return MPI_ERR_ARG;
+
+ XBT_DEBUG("Entering MPI_Get_accumulate from %d", target_rank);
+
+ get(result_addr, result_count, result_datatype, target_rank,
+ target_disp, target_count, target_datatype);
+ accumulate(origin_addr, origin_count, origin_datatype, target_rank,
+ target_disp, target_count, target_datatype, op);
+
+ return MPI_SUCCESS;
+
+}
+
int Win::start(MPI_Group group, int assert){
/* From MPI forum advices
The call to MPI_WIN_COMPLETE does not return until the put call has completed at the origin; and the target window
int Win::wait(){
//naive, blocking implementation.
XBT_DEBUG("Entering MPI_Win_Wait");
- int i=0,j=0;
- int size = group_->size();
+ int i = 0;
+ int j = 0;
+ int size = group_->size();
MPI_Request* reqs = xbt_new0(MPI_Request, size);
while(j!=size){
}
int Win::lock(int lock_type, int rank, int assert){
+ if(opened_!=0)
+ return MPI_ERR_WIN;
+
MPI_Win target_win = connected_wins_[rank];
- //window already locked, we have to wait
- if (lock_type == MPI_LOCK_EXCLUSIVE){
- XBT_DEBUG("Win_lock - Entering lock %d", 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_);
- XBT_DEBUG("Win_lock - Released from lock %d", rank);
-}
+ 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_);
+ }
+ } else if(!(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
- xbt_mutex_acquire(target_win->mut_);
target_win->lockers_.push_back(comm_->rank());
- xbt_mutex_release(target_win->mut_);
int finished = finish_comms();
- XBT_DEBUG("Win_lock - Finished %d RMA calls", finished);
+ XBT_DEBUG("Win_lock %d - Finished %d RMA calls", rank, finished);
return MPI_SUCCESS;
}
int Win::unlock(int rank){
- MPI_Win target_win = connected_wins_[rank];
+ if(opened_!=0)
+ return MPI_ERR_WIN;
- xbt_mutex_acquire(target_win->mut_);
- int size=target_win->lockers_.size();
+ MPI_Win target_win = connected_wins_[rank];
+ int target_mode = target_win->mode_;
+ target_win->mode_= 0;
target_win->lockers_.remove(comm_->rank());
-
-
- if (size<=1){//0 or 1 lockers -> exclusive assumed
- xbt_mutex_try_acquire(target_win->lock_mut_);
+ if (target_mode==MPI_LOCK_EXCLUSIVE){
xbt_mutex_release(target_win->lock_mut_);
}
- xbt_mutex_release(target_win->mut_);
+
int finished = finish_comms();
- XBT_DEBUG("Win_unlock - Finished %d RMA calls", finished);
+ XBT_DEBUG("Win_unlock %d - Finished %d RMA calls", rank, finished);
return MPI_SUCCESS;
}
