src/smpi/bindings/smpi_pmpi_win.cpp

   1 /* Copyright (c) 2007-2022. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "private.hpp"
   7 #include "smpi_coll.hpp"
   8 #include "smpi_comm.hpp"
   9 #include "smpi_datatype_derived.hpp"
  10 #include "smpi_op.hpp"
  11 #include "smpi_win.hpp"
  12 #include "src/smpi/include/smpi_actor.hpp"
  13
  14 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
  15
  16 #define CHECK_RMA\
  17   CHECK_COUNT(2, origin_count)\
  18   CHECK_TYPE(3, origin_datatype)\
  19   CHECK_BUFFER(1, origin_addr, origin_count, origin_datatype)\
  20   CHECK_PROC_RMA(4, target_rank, win)\
  21   CHECK_COUNT(6, target_count)\
  22   CHECK_TYPE(7, target_datatype)
  23
  24 #define CHECK_TARGET_DISP(num)                                                                                         \
  25   if (not win->dynamic())                                                                                              \
  26     CHECK_NEGATIVE((num), MPI_ERR_RMA_RANGE, target_disp)
  27
  28 /* PMPI User level calls */
  29
  30 int PMPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){
  31   int retval = 0;
  32   CHECK_COMM(5)
  33   CHECK_BUFFER(1, base, size, MPI_BYTE)
  34   CHECK_NEGATIVE(2, MPI_ERR_OTHER, size)
  35   CHECK_NEGATIVE(3, MPI_ERR_OTHER, disp_unit)
  36   CHECK_COLLECTIVE(comm, __func__)
  37   const SmpiBenchGuard suspend_bench;
  38   if (base == nullptr && size != 0){
  39     retval= MPI_ERR_OTHER;
  40   }else{
  41     *win = new simgrid::smpi::Win( base, size, disp_unit, info, comm);
  42     retval = MPI_SUCCESS;
  43   }
  44   return retval;
  45 }
  46
  47 int PMPI_Win_allocate( MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, void *base, MPI_Win *win){
  48   CHECK_COMM(5)
  49   CHECK_NEGATIVE(2, MPI_ERR_OTHER, size)
  50   CHECK_NEGATIVE(3, MPI_ERR_OTHER, disp_unit)
  51   void* ptr = xbt_malloc(size);
  52   const SmpiBenchGuard suspend_bench;
  53   *static_cast<void**>(base) = ptr;
  54   *win                       = new simgrid::smpi::Win(ptr, size, disp_unit, info, comm, true);
  55   return MPI_SUCCESS;
  56 }
  57
  58 int PMPI_Win_allocate_shared( MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, void *base, MPI_Win *win){
  59   CHECK_COMM(5)
  60   CHECK_NEGATIVE(2, MPI_ERR_OTHER, size)
  61   CHECK_NEGATIVE(3, MPI_ERR_OTHER, disp_unit)
  62   void* ptr = nullptr;
  63   int rank = comm->rank();
  64   if(rank==0){
  65      ptr = xbt_malloc(size*comm->size());
  66   }
  67   const SmpiBenchGuard suspend_bench;
  68   simgrid::smpi::colls::bcast(&ptr, sizeof(void*), MPI_BYTE, 0, comm);
  69   simgrid::smpi::colls::barrier(comm);
  70   *static_cast<void**>(base) = (char*)ptr+rank*size;
  71   *win                       = new simgrid::smpi::Win(ptr, size, disp_unit, info, comm, rank == 0);
  72   return MPI_SUCCESS;
  73 }
  74
  75 int PMPI_Win_create_dynamic( MPI_Info info, MPI_Comm comm, MPI_Win *win){
  76   CHECK_COMM(2)
  77   const SmpiBenchGuard suspend_bench;
  78   *win = new simgrid::smpi::Win(info, comm);
  79   return MPI_SUCCESS;
  80 }
  81
  82 int PMPI_Win_attach(MPI_Win win, void *base, MPI_Aint size){
  83   CHECK_WIN(1, win)
  84   CHECK_NEGATIVE(3, MPI_ERR_OTHER, size)
  85   if (base == nullptr && size != 0)
  86     return MPI_ERR_OTHER;
  87   const SmpiBenchGuard suspend_bench;
  88   int retval = win->attach(base, size);
  89   return retval;
  90 }
  91
  92 int PMPI_Win_detach(MPI_Win win, const void* base)
  93 {
  94   CHECK_WIN(1, win)
  95   CHECK_NULL(2, MPI_ERR_OTHER, base)
  96   const SmpiBenchGuard suspend_bench;
  97   int retval = win->detach(base);
  98   return retval;
  99 }
 100
 101 int PMPI_Win_free( MPI_Win* win){
 102   CHECK_NULL(1, MPI_ERR_WIN, win)
 103   CHECK_WIN(1, (*win))
 104   CHECK_COLLECTIVE((*win)->comm(), __func__)
 105   if (_smpi_cfg_pedantic && (*win)->opened() == 1){//only check in pedantic mode, as it's not clear this is illegal
 106     XBT_WARN("Attempt to destroy a MPI_Win too early -missing MPI_Win_fence ?");
 107     return MPI_ERR_WIN;
 108   }
 109   const SmpiBenchGuard suspend_bench;
 110   return simgrid::smpi::Win::del(*win);
 111   return MPI_SUCCESS;
 112 }
 113
 114 int PMPI_Win_set_name(MPI_Win  win, const char * name)
 115 {
 116   CHECK_WIN(1, win)
 117   CHECK_NULL(2, MPI_ERR_ARG, name)
 118   win->set_name(name);
 119   return MPI_SUCCESS;
 120 }
 121
 122 int PMPI_Win_get_name(MPI_Win  win, char * name, int* len)
 123 {
 124   CHECK_WIN(1, win)
 125   CHECK_NULL(2, MPI_ERR_ARG, name)
 126   win->get_name(name, len);
 127   return MPI_SUCCESS;
 128 }
 129
 130 int PMPI_Win_get_info(MPI_Win  win, MPI_Info* info)
 131 {
 132   CHECK_WIN(1, win)
 133   CHECK_NULL(2, MPI_ERR_ARG, info)
 134   *info = new simgrid::smpi::Info(win->info());
 135   return MPI_SUCCESS;
 136 }
 137
 138 int PMPI_Win_set_info(MPI_Win  win, MPI_Info info)
 139 {
 140   CHECK_WIN(1, win)
 141   win->set_info(info);
 142   return MPI_SUCCESS;
 143 }
 144
 145 int PMPI_Win_get_group(MPI_Win  win, MPI_Group * group){
 146   CHECK_WIN(1, win)
 147   win->get_group(group);
 148   if (*group != MPI_COMM_WORLD->group() && *group != MPI_GROUP_NULL && *group != MPI_GROUP_EMPTY)
 149     (*group)->ref();
 150   return MPI_SUCCESS;
 151 }
 152
 153 int PMPI_Win_fence( int assert,  MPI_Win win){
 154   CHECK_WIN(2, win)
 155   const SmpiBenchGuard suspend_bench;
 156   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 157   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_fence"));
 158   int retval = win->fence(assert);
 159   TRACE_smpi_comm_out(my_proc_id);
 160   return retval;
 161 }
 162
 163 int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 164               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
 165   CHECK_WIN(8, win)
 166   CHECK_RMA
 167   CHECK_TARGET_DISP(5)
 168
 169   int retval = 0;
 170   const SmpiBenchGuard suspend_bench;
 171
 172   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 173   MPI_Group group;
 174   win->get_group(&group);
 175   TRACE_smpi_comm_in(my_proc_id, __func__,
 176                      new simgrid::instr::Pt2PtTIData("Get", target_rank, origin_count,
 177                                                      simgrid::smpi::Datatype::encode(origin_datatype)));
 178    retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 179                          target_datatype);
 180   TRACE_smpi_comm_out(my_proc_id);
 181
 182   return retval;
 183 }
 184
 185 int PMPI_Rget( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 186               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request){
 187   if(target_rank==MPI_PROC_NULL)
 188     *request = MPI_REQUEST_NULL;
 189   CHECK_WIN(8, win)
 190   CHECK_RMA
 191   CHECK_TARGET_DISP(5)
 192   CHECK_NULL(9, MPI_ERR_ARG, request)
 193
 194   int retval = 0;
 195   const SmpiBenchGuard suspend_bench;
 196
 197   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 198   MPI_Group group;
 199   win->get_group(&group);
 200   TRACE_smpi_comm_in(my_proc_id, __func__,
 201                      new simgrid::instr::Pt2PtTIData(
 202                          "Rget", target_rank, origin_count,
 203                          simgrid::smpi::Datatype::encode(origin_datatype)));
 204
 205   retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 206                          target_datatype, request);
 207
 208   TRACE_smpi_comm_out(my_proc_id);
 209
 210   return retval;
 211 }
 212
 213 int PMPI_Put(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 214               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
 215   CHECK_WIN(8, win)
 216   CHECK_RMA
 217   CHECK_TARGET_DISP(5)
 218
 219   int retval = 0;
 220   const SmpiBenchGuard suspend_bench;
 221
 222   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 223   MPI_Group group;
 224   win->get_group(&group);
 225   aid_t dst_traced = group->actor(target_rank);
 226   TRACE_smpi_comm_in(my_proc_id, __func__,
 227                      new simgrid::instr::Pt2PtTIData("Put", target_rank, origin_count,
 228                                                      simgrid::smpi::Datatype::encode(origin_datatype)));
 229   TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, SMPI_RMA_TAG, origin_count * origin_datatype->size());
 230
 231   retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 232                          target_datatype);
 233
 234   TRACE_smpi_comm_out(my_proc_id);
 235
 236   return retval;
 237 }
 238
 239 int PMPI_Rput(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 240               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request){
 241   if(target_rank==MPI_PROC_NULL)
 242     *request = MPI_REQUEST_NULL;
 243   CHECK_WIN(8, win)
 244   CHECK_RMA
 245   CHECK_TARGET_DISP(5)
 246   CHECK_NULL(9, MPI_ERR_ARG, request)
 247   int retval = 0;
 248   const SmpiBenchGuard suspend_bench;
 249
 250   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 251   MPI_Group group;
 252   win->get_group(&group);
 253   aid_t dst_traced = group->actor(target_rank);
 254   TRACE_smpi_comm_in(my_proc_id, __func__,
 255                      new simgrid::instr::Pt2PtTIData(
 256                          "Rput", target_rank, origin_count,
 257                          simgrid::smpi::Datatype::encode(origin_datatype)));
 258   TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, SMPI_RMA_TAG, origin_count * origin_datatype->size());
 259
 260   retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 261                          target_datatype, request);
 262
 263   TRACE_smpi_comm_out(my_proc_id);
 264
 265   return retval;
 266 }
 267
 268 int PMPI_Accumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 269               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){
 270   CHECK_WIN(9, win)
 271   CHECK_RMA
 272   CHECK_MPI_NULL(8, MPI_OP_NULL, MPI_ERR_OP, op)
 273   CHECK_TARGET_DISP(5)
 274
 275   int retval = 0;
 276
 277   const SmpiBenchGuard suspend_bench;
 278   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 279   MPI_Group group;
 280   win->get_group(&group);
 281   TRACE_smpi_comm_in(my_proc_id, __func__,
 282                      new simgrid::instr::Pt2PtTIData(
 283                          "Accumulate", target_rank, origin_count,
 284                          simgrid::smpi::Datatype::encode(origin_datatype)));
 285   retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 286                                 target_datatype, op);
 287
 288   TRACE_smpi_comm_out(my_proc_id);
 289
 290   return retval;
 291 }
 292
 293 int PMPI_Raccumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 294               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request){
 295   if(target_rank==MPI_PROC_NULL)
 296     *request = MPI_REQUEST_NULL;
 297   CHECK_WIN(9, win)
 298   CHECK_RMA
 299   CHECK_MPI_NULL(8, MPI_OP_NULL, MPI_ERR_OP, op)
 300   CHECK_TARGET_DISP(5)
 301   CHECK_NULL(10, MPI_ERR_ARG, request)
 302
 303   int retval = 0;
 304
 305   const SmpiBenchGuard suspend_bench;
 306
 307   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 308   MPI_Group group;
 309   win->get_group(&group);
 310   TRACE_smpi_comm_in(my_proc_id, __func__,
 311                      new simgrid::instr::Pt2PtTIData(
 312                          "Raccumulate", target_rank, origin_count,
 313                          simgrid::smpi::Datatype::encode(origin_datatype)));
 314
 315   retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 316                                 target_datatype, op, request);
 317
 318   TRACE_smpi_comm_out(my_proc_id);
 319
 320   return retval;
 321 }
 322
 323 int PMPI_Get_accumulate(const void* origin_addr, int origin_count, MPI_Datatype origin_datatype, void* result_addr,
 324                         int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp,
 325                         int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win)
 326 {
 327   if (op != MPI_NO_OP){
 328     CHECK_BUFFER(1, origin_addr, origin_count, origin_datatype)
 329     CHECK_COUNT(2, origin_count)
 330     if(origin_count>0)
 331       CHECK_TYPE(3, origin_datatype)
 332   }
 333   CHECK_COUNT(5, result_count)
 334   CHECK_TYPE(6, result_datatype)
 335   CHECK_BUFFER(4, result_addr, result_count, result_datatype)
 336   CHECK_WIN(12, win)
 337   CHECK_PROC_RMA(7, target_rank, win)
 338   CHECK_COUNT(9, target_count)
 339   CHECK_TYPE(10, target_datatype)
 340   CHECK_MPI_NULL(11, MPI_OP_NULL, MPI_ERR_OP, op)
 341   CHECK_TARGET_DISP(8)
 342
 343   int retval = 0;
 344   const SmpiBenchGuard suspend_bench;
 345
 346   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 347   MPI_Group group;
 348   win->get_group(&group);
 349   TRACE_smpi_comm_in(my_proc_id, __func__,
 350                      new simgrid::instr::Pt2PtTIData(
 351                          "Get_accumulate", target_rank, target_count,
 352                          simgrid::smpi::Datatype::encode(target_datatype)));
 353
 354   retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
 355                                 result_count, result_datatype, target_rank, target_disp,
 356                                 target_count, target_datatype, op);
 357
 358   TRACE_smpi_comm_out(my_proc_id);
 359
 360   return retval;
 361 }
 362
 363 int PMPI_Rget_accumulate(const void* origin_addr, int origin_count, MPI_Datatype origin_datatype, void* result_addr,
 364                          int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp,
 365                          int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request)
 366 {
 367   if(target_rank==MPI_PROC_NULL)
 368     *request = MPI_REQUEST_NULL;
 369   if (op != MPI_NO_OP){
 370     CHECK_BUFFER(1, origin_addr, origin_count, origin_datatype)
 371     CHECK_COUNT(2, origin_count)
 372     if(origin_count>0)
 373       CHECK_TYPE(3, origin_datatype)
 374   }
 375   CHECK_COUNT(5, result_count)
 376   CHECK_TYPE(6, result_datatype)
 377   CHECK_BUFFER(4, result_addr, result_count, result_datatype)
 378   CHECK_WIN(12, win)
 379   CHECK_PROC_RMA(7, target_rank, win)
 380   CHECK_COUNT(9, target_count)
 381   CHECK_TYPE(10, target_datatype)
 382   CHECK_MPI_NULL(11, MPI_OP_NULL, MPI_ERR_OP, op)
 383   CHECK_TARGET_DISP(8)
 384   CHECK_NULL(10, MPI_ERR_ARG, request)
 385   int retval = 0;
 386   const SmpiBenchGuard suspend_bench;
 387
 388   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 389   MPI_Group group;
 390   win->get_group(&group);
 391   TRACE_smpi_comm_in(my_proc_id, __func__,
 392                      new simgrid::instr::Pt2PtTIData(
 393                          "Rget_accumulate", target_rank, target_count,
 394                          simgrid::smpi::Datatype::encode(target_datatype)));
 395
 396   retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
 397                                 result_count, result_datatype, target_rank, target_disp,
 398                                 target_count, target_datatype, op, request);
 399
 400   TRACE_smpi_comm_out(my_proc_id);
 401
 402   return retval;
 403 }
 404
 405 int PMPI_Fetch_and_op(const void *origin_addr, void *result_addr, MPI_Datatype dtype, int target_rank, MPI_Aint target_disp, MPI_Op op, MPI_Win win){
 406   return PMPI_Get_accumulate(origin_addr, origin_addr==nullptr?0:1, dtype, result_addr, 1, dtype, target_rank, target_disp, 1, dtype, op, win);
 407 }
 408
 409 int PMPI_Compare_and_swap(const void* origin_addr, void* compare_addr, void* result_addr, MPI_Datatype datatype,
 410                           int target_rank, MPI_Aint target_disp, MPI_Win win)
 411 {
 412   CHECK_NULL(1, MPI_ERR_BUFFER, origin_addr)
 413   CHECK_NULL(2, MPI_ERR_BUFFER, compare_addr)
 414   CHECK_NULL(3, MPI_ERR_BUFFER, result_addr)
 415   CHECK_TYPE(4, datatype)
 416   CHECK_WIN(6, win)
 417   CHECK_PROC_RMA(5, target_rank, win)
 418   CHECK_TARGET_DISP(6)
 419
 420   int retval = 0;
 421
 422   const SmpiBenchGuard suspend_bench;
 423
 424   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 425   MPI_Group group;
 426   win->get_group(&group);
 427   TRACE_smpi_comm_in(my_proc_id, __func__,
 428                      new simgrid::instr::Pt2PtTIData("Compare_and_swap", target_rank, 1,
 429                                                      simgrid::smpi::Datatype::encode(datatype)));
 430
 431   retval = win->compare_and_swap(origin_addr, compare_addr, result_addr, datatype, target_rank, target_disp);
 432
 433   TRACE_smpi_comm_out(my_proc_id);
 434
 435   return retval;
 436 }
 437
 438 int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){
 439   CHECK_GROUP(1, group)
 440   CHECK_WIN(2, win)
 441   const SmpiBenchGuard suspend_bench;
 442   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 443   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_post"));
 444   int retval = win->post(group,assert);
 445   TRACE_smpi_comm_out(my_proc_id);
 446   return retval;
 447 }
 448
 449 int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){
 450   CHECK_GROUP(1, group)
 451   CHECK_WIN(2, win)
 452   const SmpiBenchGuard suspend_bench;
 453   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 454   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_start"));
 455   int retval = win->start(group,assert);
 456   TRACE_smpi_comm_out(my_proc_id);
 457   return retval;
 458 }
 459
 460 int PMPI_Win_complete(MPI_Win win){
 461   CHECK_WIN(1, win)
 462   const SmpiBenchGuard suspend_bench;
 463   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 464   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_complete"));
 465   int retval = win->complete();
 466   TRACE_smpi_comm_out(my_proc_id);
 467   return retval;
 468 }
 469
 470 int PMPI_Win_wait(MPI_Win win){
 471   CHECK_WIN(1, win)
 472   const SmpiBenchGuard suspend_bench;
 473   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 474   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_wait"));
 475   int retval = win->wait();
 476   TRACE_smpi_comm_out(my_proc_id);
 477   return retval;
 478 }
 479
 480 int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win){
 481   CHECK_WIN(4, win)
 482   CHECK_PROC_RMA(2, rank, win)
 483   int retval = 0;
 484   const SmpiBenchGuard suspend_bench;
 485   if (lock_type != MPI_LOCK_EXCLUSIVE &&
 486       lock_type != MPI_LOCK_SHARED) {
 487     retval = MPI_ERR_LOCKTYPE;
 488   } else {
 489     aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 490     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock"));
 491     retval = win->lock(lock_type,rank,assert);
 492     TRACE_smpi_comm_out(my_proc_id);
 493   }
 494   return retval;
 495 }
 496
 497 int PMPI_Win_unlock(int rank, MPI_Win win){
 498   CHECK_WIN(2, win)
 499   CHECK_PROC_RMA(1, rank, win)
 500   const SmpiBenchGuard suspend_bench;
 501   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 502   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock"));
 503   int retval = win->unlock(rank);
 504   TRACE_smpi_comm_out(my_proc_id);
 505   return retval;
 506 }
 507
 508 int PMPI_Win_lock_all(int assert, MPI_Win win){
 509   CHECK_WIN(2, win)
 510   const SmpiBenchGuard suspend_bench;
 511   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 512   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock_all"));
 513   int retval = win->lock_all(assert);
 514   TRACE_smpi_comm_out(my_proc_id);
 515   return retval;
 516 }
 517
 518 int PMPI_Win_unlock_all(MPI_Win win){
 519   CHECK_WIN(1, win)
 520   const SmpiBenchGuard suspend_bench;
 521   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 522   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock_all"));
 523   int retval = win->unlock_all();
 524   TRACE_smpi_comm_out(my_proc_id);
 525   return retval;
 526 }
 527
 528 int PMPI_Win_flush(int rank, MPI_Win win){
 529   CHECK_WIN(2, win)
 530   CHECK_PROC_RMA(1, rank, win)
 531   const SmpiBenchGuard suspend_bench;
 532   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 533   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush"));
 534   int retval = win->flush(rank);
 535   TRACE_smpi_comm_out(my_proc_id);
 536   return retval;
 537 }
 538
 539 int PMPI_Win_flush_local(int rank, MPI_Win win){
 540   CHECK_WIN(2, win)
 541   CHECK_PROC_RMA(1, rank, win)
 542   const SmpiBenchGuard suspend_bench;
 543   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 544   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local"));
 545   int retval = win->flush_local(rank);
 546   TRACE_smpi_comm_out(my_proc_id);
 547   return retval;
 548 }
 549
 550 int PMPI_Win_flush_all(MPI_Win win){
 551   CHECK_WIN(1, win)
 552   const SmpiBenchGuard suspend_bench;
 553   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 554   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_all"));
 555   int retval = win->flush_all();
 556   TRACE_smpi_comm_out(my_proc_id);
 557   return retval;
 558 }
 559
 560 int PMPI_Win_flush_local_all(MPI_Win win){
 561   CHECK_WIN(1, win)
 562   const SmpiBenchGuard suspend_bench;
 563   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 564   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local_all"));
 565   int retval = win->flush_local_all();
 566   TRACE_smpi_comm_out(my_proc_id);
 567   return retval;
 568 }
 569
 570 int PMPI_Win_shared_query (MPI_Win win, int rank, MPI_Aint* size, int* disp_unit, void* baseptr)
 571 {
 572   CHECK_WIN(1, win)
 573   return win->shared_query(rank, size, disp_unit, baseptr);
 574 }
 575
 576 int PMPI_Win_get_attr (MPI_Win win, int keyval, void *attribute_val, int* flag)
 577 {
 578   static MPI_Aint size;
 579   static MPI_Aint disp_unit;
 580   CHECK_WIN(1, win)
 581   switch (keyval) {
 582     case MPI_WIN_BASE:
 583       *static_cast<void**>(attribute_val) = win->base();
 584       *flag                               = 1;
 585       return MPI_SUCCESS;
 586     case MPI_WIN_SIZE:
 587       size                                    = win->size();
 588       *static_cast<MPI_Aint**>(attribute_val) = &size;
 589       *flag                                   = 1;
 590       return MPI_SUCCESS;
 591     case MPI_WIN_DISP_UNIT:
 592       disp_unit                               = win->disp_unit();
 593       *static_cast<MPI_Aint**>(attribute_val) = &disp_unit;
 594       *flag                                   = 1;
 595       return MPI_SUCCESS;
 596     default:
 597      return win->attr_get<simgrid::smpi::Win>(keyval, attribute_val, flag);
 598   }
 599 }
 600
 601 int PMPI_Win_set_attr (MPI_Win win, int type_keyval, void *attribute_val)
 602 {
 603   CHECK_WIN(1, win)
 604   return win->attr_put<simgrid::smpi::Win>(type_keyval, attribute_val);
 605 }
 606
 607 int PMPI_Win_delete_attr (MPI_Win win, int type_keyval)
 608 {
 609   CHECK_WIN(1, win)
 610   return win->attr_delete<simgrid::smpi::Win>(type_keyval);
 611 }
 612
 613 int PMPI_Win_create_keyval(MPI_Win_copy_attr_function* copy_fn, MPI_Win_delete_attr_function* delete_fn, int* keyval,
 614                             void* extra_state)
 615 {
 616   smpi_copy_fn _copy_fn={nullptr, nullptr,copy_fn,nullptr, nullptr,nullptr};
 617   smpi_delete_fn _delete_fn={nullptr, nullptr,delete_fn,nullptr, nullptr,nullptr};
 618   return simgrid::smpi::Keyval::keyval_create<simgrid::smpi::Win>(_copy_fn, _delete_fn, keyval, extra_state);
 619 }
 620
 621 int PMPI_Win_free_keyval(int* keyval) {
 622   return simgrid::smpi::Keyval::keyval_free<simgrid::smpi::Win>(keyval);
 623 }
 624
 625 MPI_Win PMPI_Win_f2c(MPI_Fint win){
 626   if(win==-1)
 627     return MPI_WIN_NULL;
 628   return simgrid::smpi::Win::f2c(win);
 629 }
 630
 631 MPI_Fint PMPI_Win_c2f(MPI_Win win){
 632   if(win==MPI_WIN_NULL)
 633     return -1;
 634   return win->c2f();
 635 }
 636
 637 int PMPI_Win_create_errhandler(MPI_Win_errhandler_function* function, MPI_Errhandler* errhandler){
 638   *errhandler=new simgrid::smpi::Errhandler(function);
 639   return MPI_SUCCESS;
 640 }
 641
 642 int PMPI_Win_get_errhandler(MPI_Win win, MPI_Errhandler* errhandler){
 643   CHECK_WIN(1, win)
 644   if (errhandler==nullptr){
 645     return MPI_ERR_ARG;
 646   }
 647   *errhandler=win->errhandler();
 648   return MPI_SUCCESS;
 649 }
 650
 651 int PMPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler){
 652   CHECK_WIN(1, win)
 653   if (errhandler==nullptr){
 654     return MPI_ERR_ARG;
 655   }
 656   win->set_errhandler(errhandler);
 657   return MPI_SUCCESS;
 658 }
 659
 660 int PMPI_Win_call_errhandler(MPI_Win win,int errorcode){
 661   CHECK_WIN(1, win)
 662   MPI_Errhandler err = win->errhandler();
 663   err->call(win, errorcode);
 664   simgrid::smpi::Errhandler::unref(err);
 665   return MPI_SUCCESS;
 666 }