src/smpi/bindings/smpi_pmpi_win.cpp

   1 /* Copyright (c) 2007-2023. 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   simgrid::smpi::Win::del(*win);
 111   *win = MPI_WIN_NULL;
 112   return MPI_SUCCESS;
 113 }
 114
 115 int PMPI_Win_set_name(MPI_Win  win, const char * name)
 116 {
 117   CHECK_WIN(1, win)
 118   CHECK_NULL(2, MPI_ERR_ARG, name)
 119   win->set_name(name);
 120   return MPI_SUCCESS;
 121 }
 122
 123 int PMPI_Win_get_name(MPI_Win  win, char * name, int* len)
 124 {
 125   CHECK_WIN(1, win)
 126   CHECK_NULL(2, MPI_ERR_ARG, name)
 127   win->get_name(name, len);
 128   return MPI_SUCCESS;
 129 }
 130
 131 int PMPI_Win_get_info(MPI_Win  win, MPI_Info* info)
 132 {
 133   CHECK_WIN(1, win)
 134   CHECK_NULL(2, MPI_ERR_ARG, info)
 135   *info = new simgrid::smpi::Info(win->info());
 136   return MPI_SUCCESS;
 137 }
 138
 139 int PMPI_Win_set_info(MPI_Win  win, MPI_Info info)
 140 {
 141   CHECK_WIN(1, win)
 142   win->set_info(info);
 143   return MPI_SUCCESS;
 144 }
 145
 146 int PMPI_Win_get_group(MPI_Win  win, MPI_Group * group){
 147   CHECK_WIN(1, win)
 148   win->get_group(group);
 149   if (*group != MPI_COMM_WORLD->group() && *group != MPI_GROUP_NULL && *group != MPI_GROUP_EMPTY)
 150     (*group)->ref();
 151   return MPI_SUCCESS;
 152 }
 153
 154 int PMPI_Win_fence( int assert,  MPI_Win win){
 155   CHECK_WIN(2, win)
 156   const SmpiBenchGuard suspend_bench;
 157   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 158   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_fence"));
 159   int retval = win->fence(assert);
 160   TRACE_smpi_comm_out(my_proc_id);
 161   return retval;
 162 }
 163
 164 int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 165               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
 166   CHECK_WIN(8, win)
 167   CHECK_RMA
 168   CHECK_TARGET_DISP(5)
 169
 170   int retval = 0;
 171   const SmpiBenchGuard suspend_bench;
 172
 173   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 174   MPI_Group group;
 175   win->get_group(&group);
 176   TRACE_smpi_comm_in(my_proc_id, __func__,
 177                      new simgrid::instr::Pt2PtTIData("Get", target_rank, origin_count,
 178                                                      simgrid::smpi::Datatype::encode(origin_datatype)));
 179    retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 180                          target_datatype);
 181   TRACE_smpi_comm_out(my_proc_id);
 182
 183   return retval;
 184 }
 185
 186 int PMPI_Rget( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 187               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request){
 188   if(target_rank==MPI_PROC_NULL)
 189     *request = MPI_REQUEST_NULL;
 190   CHECK_WIN(8, win)
 191   CHECK_RMA
 192   CHECK_TARGET_DISP(5)
 193   CHECK_NULL(9, MPI_ERR_ARG, request)
 194
 195   int retval = 0;
 196   const SmpiBenchGuard suspend_bench;
 197
 198   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 199   MPI_Group group;
 200   win->get_group(&group);
 201   TRACE_smpi_comm_in(my_proc_id, __func__,
 202                      new simgrid::instr::Pt2PtTIData(
 203                          "Rget", target_rank, origin_count,
 204                          simgrid::smpi::Datatype::encode(origin_datatype)));
 205
 206   retval = win->get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 207                          target_datatype, request);
 208
 209   TRACE_smpi_comm_out(my_proc_id);
 210
 211   return retval;
 212 }
 213
 214 int PMPI_Put(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 215               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
 216   CHECK_WIN(8, win)
 217   CHECK_RMA
 218   CHECK_TARGET_DISP(5)
 219
 220   int retval = 0;
 221   const SmpiBenchGuard suspend_bench;
 222
 223   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 224   MPI_Group group;
 225   win->get_group(&group);
 226   aid_t dst_traced = group->actor(target_rank);
 227   TRACE_smpi_comm_in(my_proc_id, __func__,
 228                      new simgrid::instr::Pt2PtTIData("Put", target_rank, origin_count,
 229                                                      simgrid::smpi::Datatype::encode(origin_datatype)));
 230   TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, SMPI_RMA_TAG, origin_count * origin_datatype->size());
 231
 232   retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 233                          target_datatype);
 234
 235   TRACE_smpi_comm_out(my_proc_id);
 236
 237   return retval;
 238 }
 239
 240 int PMPI_Rput(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 241               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request){
 242   if(target_rank==MPI_PROC_NULL)
 243     *request = MPI_REQUEST_NULL;
 244   CHECK_WIN(8, win)
 245   CHECK_RMA
 246   CHECK_TARGET_DISP(5)
 247   CHECK_NULL(9, MPI_ERR_ARG, request)
 248   int retval = 0;
 249   const SmpiBenchGuard suspend_bench;
 250
 251   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 252   MPI_Group group;
 253   win->get_group(&group);
 254   aid_t dst_traced = group->actor(target_rank);
 255   TRACE_smpi_comm_in(my_proc_id, __func__,
 256                      new simgrid::instr::Pt2PtTIData(
 257                          "Rput", target_rank, origin_count,
 258                          simgrid::smpi::Datatype::encode(origin_datatype)));
 259   TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, SMPI_RMA_TAG, origin_count * origin_datatype->size());
 260
 261   retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 262                          target_datatype, request);
 263
 264   TRACE_smpi_comm_out(my_proc_id);
 265
 266   return retval;
 267 }
 268
 269 int PMPI_Accumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 270               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){
 271   CHECK_WIN(9, win)
 272   CHECK_RMA
 273   CHECK_MPI_NULL(8, MPI_OP_NULL, MPI_ERR_OP, op)
 274   CHECK_TARGET_DISP(5)
 275
 276   int retval = 0;
 277
 278   const SmpiBenchGuard suspend_bench;
 279   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 280   MPI_Group group;
 281   win->get_group(&group);
 282   TRACE_smpi_comm_in(my_proc_id, __func__,
 283                      new simgrid::instr::Pt2PtTIData(
 284                          "Accumulate", target_rank, origin_count,
 285                          simgrid::smpi::Datatype::encode(origin_datatype)));
 286   retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 287                                 target_datatype, op);
 288
 289   TRACE_smpi_comm_out(my_proc_id);
 290
 291   return retval;
 292 }
 293
 294 int PMPI_Raccumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
 295               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request){
 296   if(target_rank==MPI_PROC_NULL)
 297     *request = MPI_REQUEST_NULL;
 298   CHECK_WIN(9, win)
 299   CHECK_RMA
 300   CHECK_MPI_NULL(8, MPI_OP_NULL, MPI_ERR_OP, op)
 301   CHECK_TARGET_DISP(5)
 302   CHECK_NULL(10, MPI_ERR_ARG, request)
 303
 304   int retval = 0;
 305
 306   const SmpiBenchGuard suspend_bench;
 307
 308   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 309   MPI_Group group;
 310   win->get_group(&group);
 311   TRACE_smpi_comm_in(my_proc_id, __func__,
 312                      new simgrid::instr::Pt2PtTIData(
 313                          "Raccumulate", target_rank, origin_count,
 314                          simgrid::smpi::Datatype::encode(origin_datatype)));
 315
 316   retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
 317                                 target_datatype, op, request);
 318
 319   TRACE_smpi_comm_out(my_proc_id);
 320
 321   return retval;
 322 }
 323
 324 int PMPI_Get_accumulate(const void* origin_addr, int origin_count, MPI_Datatype origin_datatype, void* result_addr,
 325                         int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp,
 326                         int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win)
 327 {
 328   if (op != MPI_NO_OP){
 329     CHECK_BUFFER(1, origin_addr, origin_count, origin_datatype)
 330     CHECK_COUNT(2, origin_count)
 331     if(origin_count>0)
 332       CHECK_TYPE(3, origin_datatype)
 333   }
 334   CHECK_COUNT(5, result_count)
 335   CHECK_TYPE(6, result_datatype)
 336   CHECK_BUFFER(4, result_addr, result_count, result_datatype)
 337   CHECK_WIN(12, win)
 338   CHECK_PROC_RMA(7, target_rank, win)
 339   CHECK_COUNT(9, target_count)
 340   CHECK_TYPE(10, target_datatype)
 341   CHECK_MPI_NULL(11, MPI_OP_NULL, MPI_ERR_OP, op)
 342   CHECK_TARGET_DISP(8)
 343
 344   int retval = 0;
 345   const SmpiBenchGuard suspend_bench;
 346
 347   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 348   MPI_Group group;
 349   win->get_group(&group);
 350   TRACE_smpi_comm_in(my_proc_id, __func__,
 351                      new simgrid::instr::Pt2PtTIData(
 352                          "Get_accumulate", target_rank, target_count,
 353                          simgrid::smpi::Datatype::encode(target_datatype)));
 354
 355   retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
 356                                 result_count, result_datatype, target_rank, target_disp,
 357                                 target_count, target_datatype, op);
 358
 359   TRACE_smpi_comm_out(my_proc_id);
 360
 361   return retval;
 362 }
 363
 364 int PMPI_Rget_accumulate(const void* origin_addr, int origin_count, MPI_Datatype origin_datatype, void* result_addr,
 365                          int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp,
 366                          int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request)
 367 {
 368   if(target_rank==MPI_PROC_NULL)
 369     *request = MPI_REQUEST_NULL;
 370   if (op != MPI_NO_OP){
 371     CHECK_BUFFER(1, origin_addr, origin_count, origin_datatype)
 372     CHECK_COUNT(2, origin_count)
 373     if(origin_count>0)
 374       CHECK_TYPE(3, origin_datatype)
 375   }
 376   CHECK_COUNT(5, result_count)
 377   CHECK_TYPE(6, result_datatype)
 378   CHECK_BUFFER(4, result_addr, result_count, result_datatype)
 379   CHECK_WIN(12, win)
 380   CHECK_PROC_RMA(7, target_rank, win)
 381   CHECK_COUNT(9, target_count)
 382   CHECK_TYPE(10, target_datatype)
 383   CHECK_MPI_NULL(11, MPI_OP_NULL, MPI_ERR_OP, op)
 384   CHECK_TARGET_DISP(8)
 385   CHECK_NULL(10, MPI_ERR_ARG, request)
 386   int retval = 0;
 387   const SmpiBenchGuard suspend_bench;
 388
 389   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 390   MPI_Group group;
 391   win->get_group(&group);
 392   TRACE_smpi_comm_in(my_proc_id, __func__,
 393                      new simgrid::instr::Pt2PtTIData(
 394                          "Rget_accumulate", target_rank, target_count,
 395                          simgrid::smpi::Datatype::encode(target_datatype)));
 396
 397   retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
 398                                 result_count, result_datatype, target_rank, target_disp,
 399                                 target_count, target_datatype, op, request);
 400
 401   TRACE_smpi_comm_out(my_proc_id);
 402
 403   return retval;
 404 }
 405
 406 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){
 407   return PMPI_Get_accumulate(origin_addr, origin_addr==nullptr?0:1, dtype, result_addr, 1, dtype, target_rank, target_disp, 1, dtype, op, win);
 408 }
 409
 410 int PMPI_Compare_and_swap(const void* origin_addr, void* compare_addr, void* result_addr, MPI_Datatype datatype,
 411                           int target_rank, MPI_Aint target_disp, MPI_Win win)
 412 {
 413   CHECK_NULL(1, MPI_ERR_BUFFER, origin_addr)
 414   CHECK_NULL(2, MPI_ERR_BUFFER, compare_addr)
 415   CHECK_NULL(3, MPI_ERR_BUFFER, result_addr)
 416   CHECK_TYPE(4, datatype)
 417   CHECK_WIN(6, win)
 418   CHECK_PROC_RMA(5, target_rank, win)
 419   CHECK_TARGET_DISP(6)
 420
 421   int retval = 0;
 422
 423   const SmpiBenchGuard suspend_bench;
 424
 425   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 426   MPI_Group group;
 427   win->get_group(&group);
 428   TRACE_smpi_comm_in(my_proc_id, __func__,
 429                      new simgrid::instr::Pt2PtTIData("Compare_and_swap", target_rank, 1,
 430                                                      simgrid::smpi::Datatype::encode(datatype)));
 431
 432   retval = win->compare_and_swap(origin_addr, compare_addr, result_addr, datatype, target_rank, target_disp);
 433
 434   TRACE_smpi_comm_out(my_proc_id);
 435
 436   return retval;
 437 }
 438
 439 int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){
 440   CHECK_GROUP(1, group)
 441   CHECK_WIN(2, win)
 442   const SmpiBenchGuard suspend_bench;
 443   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 444   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_post"));
 445   int retval = win->post(group,assert);
 446   TRACE_smpi_comm_out(my_proc_id);
 447   return retval;
 448 }
 449
 450 int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){
 451   CHECK_GROUP(1, group)
 452   CHECK_WIN(2, win)
 453   const SmpiBenchGuard suspend_bench;
 454   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 455   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_start"));
 456   int retval = win->start(group,assert);
 457   TRACE_smpi_comm_out(my_proc_id);
 458   return retval;
 459 }
 460
 461 int PMPI_Win_complete(MPI_Win win){
 462   CHECK_WIN(1, win)
 463   const SmpiBenchGuard suspend_bench;
 464   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 465   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_complete"));
 466   int retval = win->complete();
 467   TRACE_smpi_comm_out(my_proc_id);
 468   return retval;
 469 }
 470
 471 int PMPI_Win_wait(MPI_Win win){
 472   CHECK_WIN(1, win)
 473   const SmpiBenchGuard suspend_bench;
 474   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 475   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_wait"));
 476   int retval = win->wait();
 477   TRACE_smpi_comm_out(my_proc_id);
 478   return retval;
 479 }
 480
 481 int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win){
 482   CHECK_WIN(4, win)
 483   CHECK_PROC_RMA(2, rank, win)
 484   int retval = 0;
 485   const SmpiBenchGuard suspend_bench;
 486   if (lock_type != MPI_LOCK_EXCLUSIVE &&
 487       lock_type != MPI_LOCK_SHARED) {
 488     retval = MPI_ERR_LOCKTYPE;
 489   } else {
 490     aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 491     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock"));
 492     retval = win->lock(lock_type,rank,assert);
 493     TRACE_smpi_comm_out(my_proc_id);
 494   }
 495   return retval;
 496 }
 497
 498 int PMPI_Win_unlock(int rank, MPI_Win win){
 499   CHECK_WIN(2, win)
 500   CHECK_PROC_RMA(1, rank, win)
 501   const SmpiBenchGuard suspend_bench;
 502   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 503   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock"));
 504   int retval = win->unlock(rank);
 505   TRACE_smpi_comm_out(my_proc_id);
 506   return retval;
 507 }
 508
 509 int PMPI_Win_lock_all(int assert, MPI_Win win){
 510   CHECK_WIN(2, win)
 511   const SmpiBenchGuard suspend_bench;
 512   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 513   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock_all"));
 514   int retval = win->lock_all(assert);
 515   TRACE_smpi_comm_out(my_proc_id);
 516   return retval;
 517 }
 518
 519 int PMPI_Win_unlock_all(MPI_Win win){
 520   CHECK_WIN(1, win)
 521   const SmpiBenchGuard suspend_bench;
 522   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 523   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock_all"));
 524   int retval = win->unlock_all();
 525   TRACE_smpi_comm_out(my_proc_id);
 526   return retval;
 527 }
 528
 529 int PMPI_Win_flush(int rank, MPI_Win win){
 530   CHECK_WIN(2, win)
 531   CHECK_PROC_RMA(1, rank, win)
 532   const SmpiBenchGuard suspend_bench;
 533   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 534   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush"));
 535   int retval = win->flush(rank);
 536   TRACE_smpi_comm_out(my_proc_id);
 537   return retval;
 538 }
 539
 540 int PMPI_Win_flush_local(int rank, MPI_Win win){
 541   CHECK_WIN(2, win)
 542   CHECK_PROC_RMA(1, rank, win)
 543   const SmpiBenchGuard suspend_bench;
 544   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 545   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local"));
 546   int retval = win->flush_local(rank);
 547   TRACE_smpi_comm_out(my_proc_id);
 548   return retval;
 549 }
 550
 551 int PMPI_Win_flush_all(MPI_Win win){
 552   CHECK_WIN(1, win)
 553   const SmpiBenchGuard suspend_bench;
 554   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 555   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_all"));
 556   int retval = win->flush_all();
 557   TRACE_smpi_comm_out(my_proc_id);
 558   return retval;
 559 }
 560
 561 int PMPI_Win_flush_local_all(MPI_Win win){
 562   CHECK_WIN(1, win)
 563   const SmpiBenchGuard suspend_bench;
 564   aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
 565   TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local_all"));
 566   int retval = win->flush_local_all();
 567   TRACE_smpi_comm_out(my_proc_id);
 568   return retval;
 569 }
 570
 571 int PMPI_Win_shared_query (MPI_Win win, int rank, MPI_Aint* size, int* disp_unit, void* baseptr)
 572 {
 573   CHECK_WIN(1, win)
 574   return win->shared_query(rank, size, disp_unit, baseptr);
 575 }
 576
 577 int PMPI_Win_get_attr (MPI_Win win, int keyval, void *attribute_val, int* flag)
 578 {
 579   static MPI_Aint size;
 580   static MPI_Aint disp_unit;
 581   CHECK_WIN(1, win)
 582   switch (keyval) {
 583     case MPI_WIN_BASE:
 584       *static_cast<void**>(attribute_val) = win->base();
 585       *flag                               = 1;
 586       return MPI_SUCCESS;
 587     case MPI_WIN_SIZE:
 588       size                                    = win->size();
 589       *static_cast<MPI_Aint**>(attribute_val) = &size;
 590       *flag                                   = 1;
 591       return MPI_SUCCESS;
 592     case MPI_WIN_DISP_UNIT:
 593       disp_unit                               = win->disp_unit();
 594       *static_cast<MPI_Aint**>(attribute_val) = &disp_unit;
 595       *flag                                   = 1;
 596       return MPI_SUCCESS;
 597     default:
 598      return win->attr_get<simgrid::smpi::Win>(keyval, attribute_val, flag);
 599   }
 600 }
 601
 602 int PMPI_Win_set_attr (MPI_Win win, int type_keyval, void *attribute_val)
 603 {
 604   CHECK_WIN(1, win)
 605   return win->attr_put<simgrid::smpi::Win>(type_keyval, attribute_val);
 606 }
 607
 608 int PMPI_Win_delete_attr (MPI_Win win, int type_keyval)
 609 {
 610   CHECK_WIN(1, win)
 611   return win->attr_delete<simgrid::smpi::Win>(type_keyval);
 612 }
 613
 614 int PMPI_Win_create_keyval(MPI_Win_copy_attr_function* copy_fn, MPI_Win_delete_attr_function* delete_fn, int* keyval,
 615                             void* extra_state)
 616 {
 617   smpi_copy_fn _copy_fn={nullptr, nullptr,copy_fn,nullptr, nullptr,nullptr};
 618   smpi_delete_fn _delete_fn={nullptr, nullptr,delete_fn,nullptr, nullptr,nullptr};
 619   return simgrid::smpi::Keyval::keyval_create<simgrid::smpi::Win>(_copy_fn, _delete_fn, keyval, extra_state);
 620 }
 621
 622 int PMPI_Win_free_keyval(int* keyval) {
 623   return simgrid::smpi::Keyval::keyval_free<simgrid::smpi::Win>(keyval);
 624 }
 625
 626 MPI_Win PMPI_Win_f2c(MPI_Fint win){
 627   if(win==-1)
 628     return MPI_WIN_NULL;
 629   return simgrid::smpi::Win::f2c(win);
 630 }
 631
 632 MPI_Fint PMPI_Win_c2f(MPI_Win win){
 633   if(win==MPI_WIN_NULL)
 634     return -1;
 635   return win->c2f();
 636 }
 637
 638 int PMPI_Win_create_errhandler(MPI_Win_errhandler_function* function, MPI_Errhandler* errhandler){
 639   *errhandler=new simgrid::smpi::Errhandler(function);
 640   return MPI_SUCCESS;
 641 }
 642
 643 int PMPI_Win_get_errhandler(MPI_Win win, MPI_Errhandler* errhandler){
 644   CHECK_WIN(1, win)
 645   if (errhandler==nullptr){
 646     return MPI_ERR_ARG;
 647   }
 648   *errhandler=win->errhandler();
 649   return MPI_SUCCESS;
 650 }
 651
 652 int PMPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler){
 653   CHECK_WIN(1, win)
 654   if (errhandler==nullptr){
 655     return MPI_ERR_ARG;
 656   }
 657   win->set_errhandler(errhandler);
 658   return MPI_SUCCESS;
 659 }
 660
 661 int PMPI_Win_call_errhandler(MPI_Win win,int errorcode){
 662   CHECK_WIN(1, win)
 663   MPI_Errhandler err = win->errhandler();
 664   err->call(win, errorcode);
 665   simgrid::smpi::Errhandler::unref(err);
 666   return MPI_SUCCESS;
 667 }