Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
sanitize the OOP of kernel::profile
[simgrid.git] / src / smpi / bindings / smpi_pmpi_win.cpp
1 /* Copyright (c) 2007-2019. 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 /* PMPI User level calls */
17
18 int PMPI_Win_create( void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win){
19   int retval = 0;
20   smpi_bench_end();
21   if (comm == MPI_COMM_NULL) {
22     retval= MPI_ERR_COMM;
23   }else if ((base == nullptr && size != 0) || disp_unit <= 0 || size < 0 ){
24     retval= MPI_ERR_OTHER;
25   }else{
26     *win = new simgrid::smpi::Win( base, size, disp_unit, info, comm);
27     retval = MPI_SUCCESS;
28   }
29   smpi_bench_begin();
30   return retval;
31 }
32
33 int PMPI_Win_allocate( MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, void *base, MPI_Win *win){
34   int retval = 0;
35   smpi_bench_end();
36   if (comm == MPI_COMM_NULL) {
37     retval= MPI_ERR_COMM;
38   }else if (disp_unit <= 0 || size < 0 ){
39     retval= MPI_ERR_OTHER;
40   }else{
41     void* ptr = xbt_malloc(size);
42     if(ptr==nullptr)
43       return MPI_ERR_NO_MEM;
44     *static_cast<void**>(base) = ptr;
45     *win = new simgrid::smpi::Win( ptr, size, disp_unit, info, comm,1);
46     retval = MPI_SUCCESS;
47   }
48   smpi_bench_begin();
49   return retval;
50 }
51
52 int PMPI_Win_allocate_shared( MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, void *base, MPI_Win *win){
53   int retval = 0;
54   smpi_bench_end();
55   if (comm == MPI_COMM_NULL) {
56     retval= MPI_ERR_COMM;
57   }else if (disp_unit <= 0 || size < 0 ){
58     retval= MPI_ERR_OTHER;
59   }else{
60     void* ptr = nullptr;
61     int rank = comm->rank();
62     if(rank==0){
63        ptr = xbt_malloc(size*comm->size());
64        if(ptr==nullptr)
65          return MPI_ERR_NO_MEM;
66     }
67     
68     simgrid::smpi::Colls::bcast(&ptr, sizeof(void*), MPI_BYTE, 0, comm);
69     simgrid::smpi::Colls::barrier(comm);
70     
71     *static_cast<void**>(base) = (char*)ptr+rank*size;
72     *win = new simgrid::smpi::Win( ptr, size, disp_unit, info, comm,rank==0);
73     retval = MPI_SUCCESS;
74   }
75   smpi_bench_begin();
76   return retval;
77 }
78
79 int PMPI_Win_create_dynamic( MPI_Info info, MPI_Comm comm, MPI_Win *win){
80   int retval = 0;
81   smpi_bench_end();
82   if (comm == MPI_COMM_NULL) {
83     retval= MPI_ERR_COMM;
84   }else{
85     *win = new simgrid::smpi::Win(info, comm);
86     retval = MPI_SUCCESS;
87   }
88   smpi_bench_begin();
89   return retval;
90 }
91
92 int PMPI_Win_attach(MPI_Win win, void *base, MPI_Aint size){
93   int retval = 0;
94   smpi_bench_end();
95   if(win == MPI_WIN_NULL){
96     retval = MPI_ERR_WIN;
97   } else if ((base == nullptr && size != 0) || size < 0 ){
98     retval= MPI_ERR_OTHER;
99   }else{
100     retval = win->attach(base, size);
101   }
102   smpi_bench_begin();
103   return retval;
104 }
105
106 int PMPI_Win_detach(MPI_Win win, void* base)
107 {
108   int retval = 0;
109   smpi_bench_end();
110   if(win == MPI_WIN_NULL){
111     retval = MPI_ERR_WIN;
112   } else if (base == nullptr){
113     retval= MPI_ERR_OTHER;
114   }else{
115     retval = win->detach(base);
116   }
117   smpi_bench_begin();
118   return retval;
119 }
120
121
122 int PMPI_Win_free( MPI_Win* win){
123   int retval = 0;
124   smpi_bench_end();
125   if (win == nullptr || *win == MPI_WIN_NULL) {
126     retval = MPI_ERR_WIN;
127   }else{
128     delete *win;
129     retval=MPI_SUCCESS;
130   }
131   smpi_bench_begin();
132   return retval;
133 }
134
135 int PMPI_Win_set_name(MPI_Win  win, char * name)
136 {
137   if (win == MPI_WIN_NULL)  {
138     return MPI_ERR_TYPE;
139   } else if (name == nullptr)  {
140     return MPI_ERR_ARG;
141   } else {
142     win->set_name(name);
143     return MPI_SUCCESS;
144   }
145 }
146
147 int PMPI_Win_get_name(MPI_Win  win, char * name, int* len)
148 {
149   if (win == MPI_WIN_NULL)  {
150     return MPI_ERR_WIN;
151   } else if (name == nullptr)  {
152     return MPI_ERR_ARG;
153   } else {
154     win->get_name(name, len);
155     return MPI_SUCCESS;
156   }
157 }
158
159 int PMPI_Win_get_info(MPI_Win  win, MPI_Info* info)
160 {
161   if (win == MPI_WIN_NULL)  {
162     return MPI_ERR_WIN;
163   } else {
164     *info = win->info();
165     return MPI_SUCCESS;
166   }
167 }
168
169 int PMPI_Win_set_info(MPI_Win  win, MPI_Info info)
170 {
171   if (win == MPI_WIN_NULL)  {
172     return MPI_ERR_TYPE;
173   } else {
174     win->set_info(info);
175     return MPI_SUCCESS;
176   }
177 }
178
179 int PMPI_Win_get_group(MPI_Win  win, MPI_Group * group){
180   if (win == MPI_WIN_NULL)  {
181     return MPI_ERR_WIN;
182   }else {
183     win->get_group(group);
184     (*group)->ref();
185     return MPI_SUCCESS;
186   }
187 }
188
189 int PMPI_Win_fence( int assert,  MPI_Win win){
190   int retval = 0;
191   smpi_bench_end();
192   if (win == MPI_WIN_NULL) {
193     retval = MPI_ERR_WIN;
194   } else {
195     int my_proc_id = simgrid::s4u::this_actor::get_pid();
196     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_fence"));
197     retval = win->fence(assert);
198     TRACE_smpi_comm_out(my_proc_id);
199   }
200   smpi_bench_begin();
201   return retval;
202 }
203
204 int PMPI_Get( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
205               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win){
206   int retval = 0;
207   smpi_bench_end();
208   if (win == MPI_WIN_NULL) {
209     retval = MPI_ERR_WIN;
210   } else if (target_rank == MPI_PROC_NULL) {
211     retval = MPI_SUCCESS;
212   } else if (target_rank <0){
213     retval = MPI_ERR_RANK;
214   } else if (win->dynamic()==0 && target_disp <0){
215     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
216     retval = MPI_ERR_ARG;
217   } else if ((origin_count < 0 || target_count < 0) ||
218              (origin_addr==nullptr && origin_count > 0)){
219     retval = MPI_ERR_COUNT;
220   } else if (((origin_datatype == MPI_DATATYPE_NULL) || (target_datatype == MPI_DATATYPE_NULL)) ||
221             ((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
222     retval = MPI_ERR_TYPE;
223   } else {
224     int my_proc_id = simgrid::s4u::this_actor::get_pid();
225     MPI_Group group;
226     win->get_group(&group);
227     TRACE_smpi_comm_in(my_proc_id, __func__,
228                        new simgrid::instr::Pt2PtTIData("Get", target_rank, origin_datatype->is_replayable()
229                                                                                ? origin_count
230                                                                                : origin_count * origin_datatype->size(),
231                                                        simgrid::smpi::Datatype::encode(origin_datatype)));
232
233     retval = win->get( 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   smpi_bench_begin();
239   return retval;
240 }
241
242 int PMPI_Rget( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
243               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request){
244   int retval = 0;
245   smpi_bench_end();
246   if (win == MPI_WIN_NULL) {
247     retval = MPI_ERR_WIN;
248   } else if (target_rank == MPI_PROC_NULL) {
249     *request = MPI_REQUEST_NULL;
250     retval = MPI_SUCCESS;
251   } else if (target_rank <0){
252     retval = MPI_ERR_RANK;
253   } else if (win->dynamic()==0 && target_disp <0){
254     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
255     retval = MPI_ERR_ARG;
256   } else if ((origin_count < 0 || target_count < 0) ||
257              (origin_addr==nullptr && origin_count > 0)){
258     retval = MPI_ERR_COUNT;
259   } else if (((origin_datatype == MPI_DATATYPE_NULL) || (target_datatype == MPI_DATATYPE_NULL)) ||
260             ((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
261     retval = MPI_ERR_TYPE;
262   } else if(request == nullptr){
263     retval = MPI_ERR_REQUEST;
264   } else {
265     int my_proc_id = simgrid::s4u::this_actor::get_pid();
266     MPI_Group group;
267     win->get_group(&group);
268     TRACE_smpi_comm_in(my_proc_id, __func__,
269                        new simgrid::instr::Pt2PtTIData(
270                            "Rget", target_rank,
271                            origin_datatype->is_replayable() ? origin_count : origin_count * origin_datatype->size(),
272                            simgrid::smpi::Datatype::encode(origin_datatype)));
273
274     retval = win->get( 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_Put( 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_Win win){
285   int retval = 0;
286   smpi_bench_end();
287   if (win == MPI_WIN_NULL) {
288     retval = MPI_ERR_WIN;
289   } else if (target_rank == MPI_PROC_NULL) {
290     retval = MPI_SUCCESS;
291   } else if (target_rank <0){
292     retval = MPI_ERR_RANK;
293   } else if (win->dynamic()==0 && target_disp <0){
294     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
295     retval = MPI_ERR_ARG;
296   } else if ((origin_count < 0 || target_count < 0) ||
297             (origin_addr==nullptr && origin_count > 0)){
298     retval = MPI_ERR_COUNT;
299   } else if (((origin_datatype == MPI_DATATYPE_NULL) || (target_datatype == MPI_DATATYPE_NULL)) ||
300             ((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
301     retval = MPI_ERR_TYPE;
302   } else {
303     int my_proc_id = simgrid::s4u::this_actor::get_pid();
304     MPI_Group group;
305     win->get_group(&group);
306     int dst_traced = group->actor(target_rank)->get_pid();
307     TRACE_smpi_comm_in(my_proc_id, __func__,
308                        new simgrid::instr::Pt2PtTIData("Put", target_rank, origin_datatype->is_replayable()
309                                                                                ? origin_count
310                                                                                : origin_count * origin_datatype->size(),
311                                                        simgrid::smpi::Datatype::encode(origin_datatype)));
312     TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, SMPI_RMA_TAG, origin_count * origin_datatype->size());
313
314     retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
315                            target_datatype);
316
317     TRACE_smpi_comm_out(my_proc_id);
318   }
319   smpi_bench_begin();
320   return retval;
321 }
322
323 int PMPI_Rput( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
324               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win, MPI_Request* request){
325   int retval = 0;
326   smpi_bench_end();
327   if (win == MPI_WIN_NULL) {
328     retval = MPI_ERR_WIN;
329   } else if (target_rank == MPI_PROC_NULL) {
330     *request = MPI_REQUEST_NULL;
331     retval = MPI_SUCCESS;
332   } else if (target_rank <0){
333     retval = MPI_ERR_RANK;
334   } else if (win->dynamic()==0 && target_disp <0){
335     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
336     retval = MPI_ERR_ARG;
337   } else if ((origin_count < 0 || target_count < 0) ||
338             (origin_addr==nullptr && origin_count > 0)){
339     retval = MPI_ERR_COUNT;
340   } else if (((origin_datatype == MPI_DATATYPE_NULL) || (target_datatype == MPI_DATATYPE_NULL)) ||
341             ((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
342     retval = MPI_ERR_TYPE;
343   } else if(request == nullptr){
344     retval = MPI_ERR_REQUEST;
345   } else {
346     int my_proc_id = simgrid::s4u::this_actor::get_pid();
347     MPI_Group group;
348     win->get_group(&group);
349     int dst_traced = group->actor(target_rank)->get_pid();
350     TRACE_smpi_comm_in(my_proc_id, __func__,
351                        new simgrid::instr::Pt2PtTIData(
352                            "Rput", target_rank,
353                            origin_datatype->is_replayable() ? origin_count : origin_count * origin_datatype->size(),
354                            simgrid::smpi::Datatype::encode(origin_datatype)));
355     TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, SMPI_RMA_TAG, origin_count * origin_datatype->size());
356
357     retval = win->put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
358                            target_datatype, request);
359
360     TRACE_smpi_comm_out(my_proc_id);
361   }
362   smpi_bench_begin();
363   return retval;
364 }
365
366 int PMPI_Accumulate( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
367               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){
368   int retval = 0;
369   smpi_bench_end();
370   if (win == MPI_WIN_NULL) {
371     retval = MPI_ERR_WIN;
372   } else if (target_rank == MPI_PROC_NULL) {
373     retval = MPI_SUCCESS;
374   } else if (target_rank <0){
375     retval = MPI_ERR_RANK;
376   } else if (win->dynamic()==0 && target_disp <0){
377     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
378     retval = MPI_ERR_ARG;
379   } else if ((origin_count < 0 || target_count < 0) ||
380              (origin_addr==nullptr && origin_count > 0)){
381     retval = MPI_ERR_COUNT;
382   } else if (((origin_datatype == MPI_DATATYPE_NULL) || (target_datatype == MPI_DATATYPE_NULL)) ||
383             ((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
384     retval = MPI_ERR_TYPE;
385   } else if (op == MPI_OP_NULL) {
386     retval = MPI_ERR_OP;
387   } else {
388     int 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                            "Accumulate", target_rank,
394                            origin_datatype->is_replayable() ? origin_count : origin_count * origin_datatype->size(),
395                            simgrid::smpi::Datatype::encode(origin_datatype)));
396     retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
397                                   target_datatype, op);
398
399     TRACE_smpi_comm_out(my_proc_id);
400   }
401   smpi_bench_begin();
402   return retval;
403 }
404
405 int PMPI_Raccumulate( void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank,
406               MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request){
407   int retval = 0;
408   smpi_bench_end();
409   if (win == MPI_WIN_NULL) {
410     retval = MPI_ERR_WIN;
411   } else if (target_rank == MPI_PROC_NULL) {
412     *request = MPI_REQUEST_NULL;
413     retval = MPI_SUCCESS;
414   } else if (target_rank <0){
415     retval = MPI_ERR_RANK;
416   } else if (win->dynamic()==0 && target_disp <0){
417     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
418     retval = MPI_ERR_ARG;
419   } else if ((origin_count < 0 || target_count < 0) ||
420              (origin_addr==nullptr && origin_count > 0)){
421     retval = MPI_ERR_COUNT;
422   } else if (((origin_datatype == MPI_DATATYPE_NULL) || (target_datatype == MPI_DATATYPE_NULL)) ||
423             ((not origin_datatype->is_valid()) || (not target_datatype->is_valid()))) {
424     retval = MPI_ERR_TYPE;
425   } else if (op == MPI_OP_NULL) {
426     retval = MPI_ERR_OP;
427   } else if(request == nullptr){
428     retval = MPI_ERR_REQUEST;
429   } else {
430     int my_proc_id = simgrid::s4u::this_actor::get_pid();
431     MPI_Group group;
432     win->get_group(&group);
433     TRACE_smpi_comm_in(my_proc_id, __func__,
434                        new simgrid::instr::Pt2PtTIData(
435                            "Raccumulate", target_rank,
436                            origin_datatype->is_replayable() ? origin_count : origin_count * origin_datatype->size(),
437                            simgrid::smpi::Datatype::encode(origin_datatype)));
438
439     retval = win->accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count,
440                                   target_datatype, op, request);
441
442     TRACE_smpi_comm_out(my_proc_id);
443   }
444   smpi_bench_begin();
445   return retval;
446 }
447
448 int PMPI_Get_accumulate(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, void *result_addr,
449 int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp, int target_count,
450 MPI_Datatype target_datatype, MPI_Op op, MPI_Win win){
451   int retval = 0;
452   smpi_bench_end();
453   if (win == MPI_WIN_NULL) {
454     retval = MPI_ERR_WIN;
455   } else if (target_rank == MPI_PROC_NULL) {
456     retval = MPI_SUCCESS;
457   } else if (target_rank <0){
458     retval = MPI_ERR_RANK;
459   } else if (win->dynamic()==0 && target_disp <0){
460     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
461     retval = MPI_ERR_ARG;
462   } else if ((origin_count < 0 || target_count < 0 || result_count <0) ||
463              (origin_addr==nullptr && origin_count > 0 && op != MPI_NO_OP) ||
464              (result_addr==nullptr && result_count > 0)){
465     retval = MPI_ERR_COUNT;
466   } else if (((target_datatype == MPI_DATATYPE_NULL) || (result_datatype == MPI_DATATYPE_NULL)) ||
467             (((origin_datatype != MPI_DATATYPE_NULL) && (not origin_datatype->is_valid())) || (not target_datatype->is_valid()) || (not result_datatype->is_valid()))) {
468     retval = MPI_ERR_TYPE;
469   } else if (op == MPI_OP_NULL) {
470     retval = MPI_ERR_OP;
471   } else {
472     int my_proc_id = simgrid::s4u::this_actor::get_pid();
473     MPI_Group group;
474     win->get_group(&group);
475     TRACE_smpi_comm_in(my_proc_id, __func__,
476                        new simgrid::instr::Pt2PtTIData(
477                            "Get_accumulate", target_rank,
478                            target_datatype->is_replayable() ? target_count : target_count * target_datatype->size(),
479                            simgrid::smpi::Datatype::encode(target_datatype)));
480
481     retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
482                                   result_count, result_datatype, target_rank, target_disp,
483                                   target_count, target_datatype, op);
484
485     TRACE_smpi_comm_out(my_proc_id);
486   }
487   smpi_bench_begin();
488   return retval;
489 }
490
491
492 int PMPI_Rget_accumulate(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, void *result_addr,
493 int result_count, MPI_Datatype result_datatype, int target_rank, MPI_Aint target_disp, int target_count,
494 MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request* request){
495   int retval = 0;
496   smpi_bench_end();
497   if (win == MPI_WIN_NULL) {
498     retval = MPI_ERR_WIN;
499   } else if (target_rank == MPI_PROC_NULL) {
500     *request = MPI_REQUEST_NULL;
501     retval = MPI_SUCCESS;
502   } else if (target_rank <0){
503     retval = MPI_ERR_RANK;
504   } else if (win->dynamic()==0 && target_disp <0){
505     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
506     retval = MPI_ERR_ARG;
507   } else if ((origin_count < 0 || target_count < 0 || result_count <0) ||
508              (origin_addr==nullptr && origin_count > 0 && op != MPI_NO_OP) ||
509              (result_addr==nullptr && result_count > 0)){
510     retval = MPI_ERR_COUNT;
511   } else if (((target_datatype == MPI_DATATYPE_NULL) || (result_datatype == MPI_DATATYPE_NULL)) ||
512             (((origin_datatype != MPI_DATATYPE_NULL) && (not origin_datatype->is_valid())) || (not target_datatype->is_valid()) || (not result_datatype->is_valid()))) {
513     retval = MPI_ERR_TYPE;
514   } else if (op == MPI_OP_NULL) {
515     retval = MPI_ERR_OP;
516   } else if(request == nullptr){
517     retval = MPI_ERR_REQUEST;
518   } else {
519     int my_proc_id = simgrid::s4u::this_actor::get_pid();
520     MPI_Group group;
521     win->get_group(&group);
522     TRACE_smpi_comm_in(my_proc_id, __func__,
523                        new simgrid::instr::Pt2PtTIData(
524                            "Rget_accumulate", target_rank,
525                            target_datatype->is_replayable() ? target_count : target_count * target_datatype->size(),
526                            simgrid::smpi::Datatype::encode(target_datatype)));
527
528     retval = win->get_accumulate( origin_addr, origin_count, origin_datatype, result_addr,
529                                   result_count, result_datatype, target_rank, target_disp,
530                                   target_count, target_datatype, op, request);
531
532     TRACE_smpi_comm_out(my_proc_id);
533   }
534   smpi_bench_begin();
535   return retval;
536 }
537
538 int PMPI_Fetch_and_op(void *origin_addr, void *result_addr, MPI_Datatype dtype, int target_rank, MPI_Aint target_disp, MPI_Op op, MPI_Win win){
539   return PMPI_Get_accumulate(origin_addr, origin_addr==nullptr?0:1, dtype, result_addr, 1, dtype, target_rank, target_disp, 1, dtype, op, win);
540 }
541
542 int PMPI_Compare_and_swap(void* origin_addr, void* compare_addr, void* result_addr, MPI_Datatype datatype,
543                           int target_rank, MPI_Aint target_disp, MPI_Win win)
544 {
545   int retval = 0;
546   smpi_bench_end();
547   if (win == MPI_WIN_NULL) {
548     retval = MPI_ERR_WIN;
549   } else if (target_rank == MPI_PROC_NULL) {
550     retval = MPI_SUCCESS;
551   } else if (target_rank <0){
552     retval = MPI_ERR_RANK;
553   } else if (win->dynamic()==0 && target_disp <0){
554     //in case of dynamic window, target_disp can be mistakenly seen as negative, as it is an address
555     retval = MPI_ERR_ARG;
556   } else if (origin_addr==nullptr || result_addr==nullptr || compare_addr==nullptr){
557     retval = MPI_ERR_COUNT;
558   } else if ((datatype == MPI_DATATYPE_NULL) || (not datatype->is_valid())) {
559     retval = MPI_ERR_TYPE;
560   } else {
561     int my_proc_id = simgrid::s4u::this_actor::get_pid();
562     MPI_Group group;
563     win->get_group(&group);
564     TRACE_smpi_comm_in(my_proc_id, __func__,
565                        new simgrid::instr::Pt2PtTIData("Compare_and_swap", target_rank,
566                                                        datatype->is_replayable() ? 1 : datatype->size(),
567                                                        simgrid::smpi::Datatype::encode(datatype)));
568
569     retval = win->compare_and_swap(origin_addr, compare_addr, result_addr, datatype, target_rank, target_disp);
570
571     TRACE_smpi_comm_out(my_proc_id);
572   }
573   smpi_bench_begin();
574   return retval;
575 }
576
577 int PMPI_Win_post(MPI_Group group, int assert, MPI_Win win){
578   int retval = 0;
579   smpi_bench_end();
580   if (win == MPI_WIN_NULL) {
581     retval = MPI_ERR_WIN;
582   } else if (group==MPI_GROUP_NULL){
583     retval = MPI_ERR_GROUP;
584   } else {
585     int my_proc_id = simgrid::s4u::this_actor::get_pid();
586     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_post"));
587     retval = win->post(group,assert);
588     TRACE_smpi_comm_out(my_proc_id);
589   }
590   smpi_bench_begin();
591   return retval;
592 }
593
594 int PMPI_Win_start(MPI_Group group, int assert, MPI_Win win){
595   int retval = 0;
596   smpi_bench_end();
597   if (win == MPI_WIN_NULL) {
598     retval = MPI_ERR_WIN;
599   } else if (group==MPI_GROUP_NULL){
600     retval = MPI_ERR_GROUP;
601   } else {
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_start"));
604     retval = win->start(group,assert);
605     TRACE_smpi_comm_out(my_proc_id);
606   }
607   smpi_bench_begin();
608   return retval;
609 }
610
611 int PMPI_Win_complete(MPI_Win win){
612   int retval = 0;
613   smpi_bench_end();
614   if (win == MPI_WIN_NULL) {
615     retval = MPI_ERR_WIN;
616   } else {
617     int my_proc_id = simgrid::s4u::this_actor::get_pid();
618     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_complete"));
619
620     retval = win->complete();
621
622     TRACE_smpi_comm_out(my_proc_id);
623   }
624   smpi_bench_begin();
625   return retval;
626 }
627
628 int PMPI_Win_wait(MPI_Win win){
629   int retval = 0;
630   smpi_bench_end();
631   if (win == MPI_WIN_NULL) {
632     retval = MPI_ERR_WIN;
633   } else {
634     int my_proc_id = simgrid::s4u::this_actor::get_pid();
635     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_wait"));
636
637     retval = win->wait();
638
639     TRACE_smpi_comm_out(my_proc_id);
640   }
641   smpi_bench_begin();
642   return retval;
643 }
644
645 int PMPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win){
646   int retval = 0;
647   smpi_bench_end();
648   if (win == MPI_WIN_NULL) {
649     retval = MPI_ERR_WIN;
650   } else if (lock_type != MPI_LOCK_EXCLUSIVE &&
651              lock_type != MPI_LOCK_SHARED) {
652     retval = MPI_ERR_LOCKTYPE;
653   } else if (rank == MPI_PROC_NULL){
654     retval = MPI_SUCCESS;
655   } else {
656     int my_proc_id = simgrid::s4u::this_actor::get_pid();
657     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock"));
658     retval = win->lock(lock_type,rank,assert);
659     TRACE_smpi_comm_out(my_proc_id);
660   }
661   smpi_bench_begin();
662   return retval;
663 }
664
665 int PMPI_Win_unlock(int rank, MPI_Win win){
666   int retval = 0;
667   smpi_bench_end();
668   if (win == MPI_WIN_NULL) {
669     retval = MPI_ERR_WIN;
670   } else if (rank == MPI_PROC_NULL){
671     retval = MPI_SUCCESS;
672   } else {
673     int my_proc_id = simgrid::s4u::this_actor::get_pid();
674     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock"));
675     retval = win->unlock(rank);
676     TRACE_smpi_comm_out(my_proc_id);
677   }
678   smpi_bench_begin();
679   return retval;
680 }
681
682 int PMPI_Win_lock_all(int assert, MPI_Win win){
683   int retval = 0;
684   smpi_bench_end();
685   if (win == MPI_WIN_NULL) {
686     retval = MPI_ERR_WIN;
687   } else {
688     int my_proc_id = simgrid::s4u::this_actor::get_pid();
689     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_lock_all"));
690     retval = win->lock_all(assert);
691     TRACE_smpi_comm_out(my_proc_id);
692   }
693   smpi_bench_begin();
694   return retval;
695 }
696
697 int PMPI_Win_unlock_all(MPI_Win win){
698   int retval = 0;
699   smpi_bench_end();
700   if (win == MPI_WIN_NULL) {
701     retval = MPI_ERR_WIN;
702   } else {
703     int my_proc_id = simgrid::s4u::this_actor::get_pid();
704     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_unlock_all"));
705     retval = win->unlock_all();
706     TRACE_smpi_comm_out(my_proc_id);
707   }
708   smpi_bench_begin();
709   return retval;
710 }
711
712 int PMPI_Win_flush(int rank, MPI_Win win){
713   int retval = 0;
714   smpi_bench_end();
715   if (win == MPI_WIN_NULL) {
716     retval = MPI_ERR_WIN;
717   } else if (rank == MPI_PROC_NULL){
718     retval = MPI_SUCCESS;
719   } else {
720     int my_proc_id = simgrid::s4u::this_actor::get_pid();
721     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush"));
722     retval = win->flush(rank);
723     TRACE_smpi_comm_out(my_proc_id);
724   }
725   smpi_bench_begin();
726   return retval;
727 }
728
729 int PMPI_Win_flush_local(int rank, MPI_Win win){
730   int retval = 0;
731   smpi_bench_end();
732   if (win == MPI_WIN_NULL) {
733     retval = MPI_ERR_WIN;
734   } else if (rank == MPI_PROC_NULL){
735     retval = MPI_SUCCESS;
736   } else {
737     int my_proc_id = simgrid::s4u::this_actor::get_pid();
738     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local"));
739     retval = win->flush_local(rank);
740     TRACE_smpi_comm_out(my_proc_id);
741   }
742   smpi_bench_begin();
743   return retval;
744 }
745
746 int PMPI_Win_flush_all(MPI_Win win){
747   int retval = 0;
748   smpi_bench_end();
749   if (win == MPI_WIN_NULL) {
750     retval = MPI_ERR_WIN;
751   } else {
752     int my_proc_id = simgrid::s4u::this_actor::get_pid();
753     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_all"));
754     retval = win->flush_all();
755     TRACE_smpi_comm_out(my_proc_id);
756   }
757   smpi_bench_begin();
758   return retval;
759 }
760
761 int PMPI_Win_flush_local_all(MPI_Win win){
762   int retval = 0;
763   smpi_bench_end();
764   if (win == MPI_WIN_NULL) {
765     retval = MPI_ERR_WIN;
766   } else {
767     int my_proc_id = simgrid::s4u::this_actor::get_pid();
768     TRACE_smpi_comm_in(my_proc_id, __func__, new simgrid::instr::NoOpTIData("Win_flush_local_all"));
769     retval = win->flush_local_all();
770     TRACE_smpi_comm_out(my_proc_id);
771   }
772   smpi_bench_begin();
773   return retval;
774 }
775
776 int PMPI_Win_shared_query (MPI_Win win, int rank, MPI_Aint* size, int* disp_unit, void* baseptr)
777 {
778   if (win==MPI_WIN_NULL)
779     return MPI_ERR_TYPE;
780   else
781     return win->shared_query(rank, size, disp_unit, baseptr);
782 }
783
784 int PMPI_Win_get_attr (MPI_Win win, int keyval, void *attribute_val, int* flag)
785 {
786   static MPI_Aint size;
787   static int disp_unit;
788   if (win==MPI_WIN_NULL)
789     return MPI_ERR_TYPE;
790   else{
791   switch (keyval) {
792     case MPI_WIN_BASE :
793       *static_cast<void**>(attribute_val)  = win->base();
794       *flag = 1;
795       return MPI_SUCCESS;
796     case MPI_WIN_SIZE :
797       size = win->size();
798       *static_cast<MPI_Aint**>(attribute_val)  = &size;
799       *flag = 1;
800       return MPI_SUCCESS;
801     case MPI_WIN_DISP_UNIT :
802       disp_unit=win->disp_unit();
803       *static_cast<int**>(attribute_val)  = &disp_unit;
804       *flag = 1;
805       return MPI_SUCCESS;
806     default:
807       return win->attr_get<simgrid::smpi::Win>(keyval, attribute_val, flag);
808   }
809 }
810
811 }
812
813 int PMPI_Win_set_attr (MPI_Win win, int type_keyval, void *attribute_val)
814 {
815   if (win==MPI_WIN_NULL)
816     return MPI_ERR_TYPE;
817   else
818     return win->attr_put<simgrid::smpi::Win>(type_keyval, attribute_val);
819 }
820
821 int PMPI_Win_delete_attr (MPI_Win win, int type_keyval)
822 {
823   if (win==MPI_WIN_NULL)
824     return MPI_ERR_TYPE;
825   else
826     return win->attr_delete<simgrid::smpi::Win>(type_keyval);
827 }
828
829 int PMPI_Win_create_keyval(MPI_Win_copy_attr_function* copy_fn, MPI_Win_delete_attr_function* delete_fn, int* keyval,
830                             void* extra_state)
831 {
832   smpi_copy_fn _copy_fn={nullptr, nullptr,copy_fn,nullptr, nullptr,nullptr};
833   smpi_delete_fn _delete_fn={nullptr, nullptr,delete_fn,nullptr, nullptr,nullptr};
834   return simgrid::smpi::Keyval::keyval_create<simgrid::smpi::Win>(_copy_fn, _delete_fn, keyval, extra_state);
835 }
836
837 int PMPI_Win_free_keyval(int* keyval) {
838   return simgrid::smpi::Keyval::keyval_free<simgrid::smpi::Win>(keyval);
839 }
840
841 MPI_Win PMPI_Win_f2c(MPI_Fint win){
842   return static_cast<MPI_Win>(simgrid::smpi::Win::f2c(win));
843 }
844
845 MPI_Fint PMPI_Win_c2f(MPI_Win win){
846   return win->c2f();
847 }