src/smpi/bindings/smpi_pmpi_win.cpp

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