-/* Copyright (c) 2007-2017. 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)");
connected_wins_[rank_] = this;
count_ = 0;
if(rank_==0){
- bar_ = MSG_barrier_init(comm_size);
+ bar_ = new simgrid::s4u::Barrier(comm_size);
}
mode_=0;
comm->add_rma_win(this);
+ comm->ref();
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
- MSG_barrier_wait(bar_);
+ bar_->wait();
int finished = finish_comms();
XBT_DEBUG("Win destructor - Finished %d RMA calls", finished);
comm_->remove_rma_win(this);
Colls::barrier(comm_);
+ 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_);
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.
opened_=0;
assert_ = assert;
- MSG_barrier_wait(bar_);
+ bar_->wait();
XBT_DEBUG("Leaving fence");
return MPI_SUCCESS;
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;
}
int Win::flush(int rank){
MPI_Win target_win = connected_wins_[rank];
- int finished = finish_comms(rank);
+ int finished = finish_comms(rank_);
XBT_DEBUG("Win_flush on local %d - Finished %d RMA calls", rank_, finished);
- finished = target_win->finish_comms(rank_);
+ finished = target_win->finish_comms(rank);
XBT_DEBUG("Win_flush on remote %d - Finished %d RMA calls", rank, finished);
return MPI_SUCCESS;
}
}
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);
- 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);
}
return static_cast<Win*>(F2C::f2c(id));
}
-
int Win::finish_comms(){
xbt_mutex_acquire(mut_);
//Finish own requests
size = 0;
std::vector<MPI_Request> myreqqs;
std::vector<MPI_Request>::iterator iter = reqqs->begin();
- int proc_id = comm_->group()->actor(rank)->getPid();
+ 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
// because we only wait for requests that we are responsible for.
return size;
}
-
+int Win::shared_query(int rank, MPI_Aint* size, int* disp_unit, void* baseptr)
+{
+ MPI_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];
+ }
+ if (target_win) {
+ *size = target_win->size_;
+ *disp_unit = target_win->disp_unit_;
+ *static_cast<void**>(baseptr) = target_win->base_;
+ } else {
+ *size = 0;
+ *static_cast<void**>(baseptr) = xbt_malloc(0);
+ }
+ return MPI_SUCCESS;
+}
}
}