src/smpi/bindings/smpi_pmpi_win.cpp

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