Logo AND Algorithmique Numérique Distribuée

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