Multi-ApplicationOnlineProfiling  2.1
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
MPI_Inst.c
Go to the documentation of this file.
1 /* ############################ MALP License ############################## */
2 /* # Fri Jan 18 14:00:00 CET 2013 # */
3 /* # Copyright or (C) or Copr. Commissariat a l'Energie Atomique # */
4 /* # # */
5 /* # This software is governed by the CeCILL-C license under French law # */
6 /* # and abiding by the rules of distribution of free software. You can # */
7 /* # use, modify and/ or redistribute the software under the terms of # */
8 /* # the CeCILL-C license as circulated by CEA, CNRS and INRIA at the # */
9 /* # following URL http://www.cecill.info. # */
10 /* # # */
11 /* # The fact that you are presently reading this means that you have # */
12 /* # had knowledge of the CeCILL-C license and that you accept its # */
13 /* # terms. # */
14 /* # # */
15 /* # Authors: # */
16 /* # - BESNARD Jean-Baptiste jean-baptiste.besnard@cea.fr # */
17 /* # # */
18 /* ######################################################################## */
19 #include <VMPI.h>
20 #include "VMPI_Wrap.h"
21 #include "MPI_Events.h"
22 #include "MPI_Inst.h"
23 #include "Event_Desc.h"
24 #include "Timer.h"
25 #include "Event_Pack.h"
26 #include "Stream_MGR.h"
27 #include "OTF_Event_forge.h"
28 #include "Posix_Profile.h"
29 #include "MALP_Config.h"
30 
31 #include <mpi.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 
36 #define PRINT_NAME( a ) printf( #a"\n");
37 #define SET_SOURCE( a ) _container.event.mpi_event.source = a;
38 #define SET_DEST( a ) _container.event.mpi_event.dest = a;
39 #define SET_TAG( a ) _container.event.mpi_event.tag = a;
40 #define SET_COUNT( a ) _container.event.mpi_event.count = a;
41 #define SET_COMM( a ) _container.event.mpi_event.comm = (uint64_t)a;
42 #define SET_DATATYPE( a ) _container.event.mpi_event.datatype = (uint64_t)a;
43 #define COMP_SIZE( a ) PMPI_Type_size( datatype ,&_size); \
44  _size *= a;
45 
46 int MPI_Abort( MPI_Comm comm, int errorcode )
47 {
48 
49  /* Virtualize MPI */
50  MACRO_MPI_Comm (comm)
51 
52  /* Pre instrum */
53  int _rank = Stream_desc_get()->mpi_rank;
54 
55  struct MALP_Trace_Event _container;
56 
57  /********************************/
58  /* FILL MPI EVENT */
59  /********************************/
60 
61  _container.event.mpi_event.type =
62  T_MPI_ENUM(MPI_ABORT)
63  ;
64 
65  /* Set default source & dest before override */
66  _container.event.mpi_event.source = _rank;
67  _container.event.mpi_event.dest = _rank;
68 
69 
70 
71 
72 
73 
74  SET_COMM (comm)
75 
76  /* Fill in size informations if needed */
77  int _size = 0;
78  #if 0
79 
80  #endif
81  _container.event.mpi_event.size = _size;
82 
83  /********************************/
84  /* EMIT OTF ENTER */
85  /********************************/
86 
87  struct MALP_Trace_Event otf_event;
88 
89  uint64_t _begin = Timer_tsc ();
90 
93  {
94 
95  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
96  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
97  MALP_EVENT_MPI, _container.event.mpi_event.type );
98  Event_Packer_push(&otf_event);
99  }
100 
101  /********************************/
102  /* ACTUAL FUNCTION CALL */
103  /********************************/
104 
106  int ret = PMPI_Abort( comm, errorcode );
108 
109  /********************************/
110  /* EMIT OTF END */
111  /********************************/
112 
113  uint64_t _end = Timer_tsc();
114  uint64_t _duration = _end - _begin;
115 
117  {
119  {
120 
121  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
122  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
123  MALP_EVENT_MPI, _container.event.mpi_event.type );
124 
125 
126  Event_Packer_push(&otf_event);
127  }
128 
129  /********************************/
130  /* EMIT MALP EVENT */
131  /********************************/
132 
133  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
134 
135  /* Submit event if MPI instrumented */
136  Event_Packer_push(&_container);
137  }
138 
139 
140  return ret;
141 }
142 int MPI_Accumulate( void * origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win )
143 {
144 
145  /* Virtualize MPI */
146 
147 
148  /* Pre instrum */
149  int _rank = Stream_desc_get()->mpi_rank;
150 
151  struct MALP_Trace_Event _container;
152 
153  /********************************/
154  /* FILL MPI EVENT */
155  /********************************/
156 
157  _container.event.mpi_event.type =
158  T_MPI_ENUM(MPI_ACCUMULATE)
159  ;
160 
161  /* Set default source & dest before override */
162  _container.event.mpi_event.source = _rank;
163  _container.event.mpi_event.dest = _rank;
164 
165 
166 
167 
168 
169 
170 
171 
172  /* Fill in size informations if needed */
173  int _size = 0;
174  #if 0
175 
176  #endif
177  _container.event.mpi_event.size = _size;
178 
179  /********************************/
180  /* EMIT OTF ENTER */
181  /********************************/
182 
183  struct MALP_Trace_Event otf_event;
184 
185  uint64_t _begin = Timer_tsc ();
186 
189  {
190 
191  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
192  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
193  MALP_EVENT_MPI, _container.event.mpi_event.type );
194  Event_Packer_push(&otf_event);
195  }
196 
197  /********************************/
198  /* ACTUAL FUNCTION CALL */
199  /********************************/
200 
202  int ret = PMPI_Accumulate( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, op, win );
204 
205  /********************************/
206  /* EMIT OTF END */
207  /********************************/
208 
209  uint64_t _end = Timer_tsc();
210  uint64_t _duration = _end - _begin;
211 
213  {
215  {
216 
217  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
218  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
219  MALP_EVENT_MPI, _container.event.mpi_event.type );
220 
221 
222  Event_Packer_push(&otf_event);
223  }
224 
225  /********************************/
226  /* EMIT MALP EVENT */
227  /********************************/
228 
229  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
230 
231  /* Submit event if MPI instrumented */
232  Event_Packer_push(&_container);
233  }
234 
235 
236  return ret;
237 }
238 int MPI_Add_error_class( int * errorclass )
239 {
240 
241  /* Virtualize MPI */
242 
243 
244  /* Pre instrum */
245  int _rank = Stream_desc_get()->mpi_rank;
246 
247  struct MALP_Trace_Event _container;
248 
249  /********************************/
250  /* FILL MPI EVENT */
251  /********************************/
252 
253  _container.event.mpi_event.type =
254  T_MPI_ENUM(MPI_ADD_ERROR_CLASS)
255  ;
256 
257  /* Set default source & dest before override */
258  _container.event.mpi_event.source = _rank;
259  _container.event.mpi_event.dest = _rank;
260 
261 
262 
263 
264 
265 
266 
267 
268  /* Fill in size informations if needed */
269  int _size = 0;
270  #if 0
271 
272  #endif
273  _container.event.mpi_event.size = _size;
274 
275  /********************************/
276  /* EMIT OTF ENTER */
277  /********************************/
278 
279  struct MALP_Trace_Event otf_event;
280 
281  uint64_t _begin = Timer_tsc ();
282 
285  {
286 
287  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
288  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
289  MALP_EVENT_MPI, _container.event.mpi_event.type );
290  Event_Packer_push(&otf_event);
291  }
292 
293  /********************************/
294  /* ACTUAL FUNCTION CALL */
295  /********************************/
296 
298  int ret = PMPI_Add_error_class( errorclass );
300 
301  /********************************/
302  /* EMIT OTF END */
303  /********************************/
304 
305  uint64_t _end = Timer_tsc();
306  uint64_t _duration = _end - _begin;
307 
309  {
311  {
312 
313  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
314  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
315  MALP_EVENT_MPI, _container.event.mpi_event.type );
316 
317 
318  Event_Packer_push(&otf_event);
319  }
320 
321  /********************************/
322  /* EMIT MALP EVENT */
323  /********************************/
324 
325  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
326 
327  /* Submit event if MPI instrumented */
328  Event_Packer_push(&_container);
329  }
330 
331 
332  return ret;
333 }
334 int MPI_Add_error_code( int errorclass, int * errorcode )
335 {
336 
337  /* Virtualize MPI */
338 
339 
340  /* Pre instrum */
341  int _rank = Stream_desc_get()->mpi_rank;
342 
343  struct MALP_Trace_Event _container;
344 
345  /********************************/
346  /* FILL MPI EVENT */
347  /********************************/
348 
349  _container.event.mpi_event.type =
350  T_MPI_ENUM(MPI_ADD_ERROR_CODE)
351  ;
352 
353  /* Set default source & dest before override */
354  _container.event.mpi_event.source = _rank;
355  _container.event.mpi_event.dest = _rank;
356 
357 
358 
359 
360 
361 
362 
363 
364  /* Fill in size informations if needed */
365  int _size = 0;
366  #if 0
367 
368  #endif
369  _container.event.mpi_event.size = _size;
370 
371  /********************************/
372  /* EMIT OTF ENTER */
373  /********************************/
374 
375  struct MALP_Trace_Event otf_event;
376 
377  uint64_t _begin = Timer_tsc ();
378 
381  {
382 
383  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
384  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
385  MALP_EVENT_MPI, _container.event.mpi_event.type );
386  Event_Packer_push(&otf_event);
387  }
388 
389  /********************************/
390  /* ACTUAL FUNCTION CALL */
391  /********************************/
392 
394  int ret = PMPI_Add_error_code( errorclass, errorcode );
396 
397  /********************************/
398  /* EMIT OTF END */
399  /********************************/
400 
401  uint64_t _end = Timer_tsc();
402  uint64_t _duration = _end - _begin;
403 
405  {
407  {
408 
409  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
410  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
411  MALP_EVENT_MPI, _container.event.mpi_event.type );
412 
413 
414  Event_Packer_push(&otf_event);
415  }
416 
417  /********************************/
418  /* EMIT MALP EVENT */
419  /********************************/
420 
421  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
422 
423  /* Submit event if MPI instrumented */
424  Event_Packer_push(&_container);
425  }
426 
427 
428  return ret;
429 }
430 int MPI_Add_error_string( int errorcode, char * string )
431 {
432 
433  /* Virtualize MPI */
434 
435 
436  /* Pre instrum */
437  int _rank = Stream_desc_get()->mpi_rank;
438 
439  struct MALP_Trace_Event _container;
440 
441  /********************************/
442  /* FILL MPI EVENT */
443  /********************************/
444 
445  _container.event.mpi_event.type =
446  T_MPI_ENUM(MPI_ADD_ERROR_STRING)
447  ;
448 
449  /* Set default source & dest before override */
450  _container.event.mpi_event.source = _rank;
451  _container.event.mpi_event.dest = _rank;
452 
453 
454 
455 
456 
457 
458 
459 
460  /* Fill in size informations if needed */
461  int _size = 0;
462  #if 0
463 
464  #endif
465  _container.event.mpi_event.size = _size;
466 
467  /********************************/
468  /* EMIT OTF ENTER */
469  /********************************/
470 
471  struct MALP_Trace_Event otf_event;
472 
473  uint64_t _begin = Timer_tsc ();
474 
477  {
478 
479  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
480  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
481  MALP_EVENT_MPI, _container.event.mpi_event.type );
482  Event_Packer_push(&otf_event);
483  }
484 
485  /********************************/
486  /* ACTUAL FUNCTION CALL */
487  /********************************/
488 
490  int ret = PMPI_Add_error_string( errorcode, string );
492 
493  /********************************/
494  /* EMIT OTF END */
495  /********************************/
496 
497  uint64_t _end = Timer_tsc();
498  uint64_t _duration = _end - _begin;
499 
501  {
503  {
504 
505  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
506  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
507  MALP_EVENT_MPI, _container.event.mpi_event.type );
508 
509 
510  Event_Packer_push(&otf_event);
511  }
512 
513  /********************************/
514  /* EMIT MALP EVENT */
515  /********************************/
516 
517  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
518 
519  /* Submit event if MPI instrumented */
520  Event_Packer_push(&_container);
521  }
522 
523 
524  return ret;
525 }
526 int MPI_Address( void * location, MPI_Aint * address )
527 {
528 
529  /* Virtualize MPI */
530 
531 
532  /* Pre instrum */
533  int _rank = Stream_desc_get()->mpi_rank;
534 
535  struct MALP_Trace_Event _container;
536 
537  /********************************/
538  /* FILL MPI EVENT */
539  /********************************/
540 
541  _container.event.mpi_event.type =
542  T_MPI_ENUM(MPI_ADDRESS)
543  ;
544 
545  /* Set default source & dest before override */
546  _container.event.mpi_event.source = _rank;
547  _container.event.mpi_event.dest = _rank;
548 
549 
550 
551 
552 
553 
554 
555 
556  /* Fill in size informations if needed */
557  int _size = 0;
558  #if 0
559 
560  #endif
561  _container.event.mpi_event.size = _size;
562 
563  /********************************/
564  /* EMIT OTF ENTER */
565  /********************************/
566 
567  struct MALP_Trace_Event otf_event;
568 
569  uint64_t _begin = Timer_tsc ();
570 
573  {
574 
575  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
576  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
577  MALP_EVENT_MPI, _container.event.mpi_event.type );
578  Event_Packer_push(&otf_event);
579  }
580 
581  /********************************/
582  /* ACTUAL FUNCTION CALL */
583  /********************************/
584 
586  int ret = PMPI_Address( location, address );
588 
589  /********************************/
590  /* EMIT OTF END */
591  /********************************/
592 
593  uint64_t _end = Timer_tsc();
594  uint64_t _duration = _end - _begin;
595 
597  {
599  {
600 
601  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
602  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
603  MALP_EVENT_MPI, _container.event.mpi_event.type );
604 
605 
606  Event_Packer_push(&otf_event);
607  }
608 
609  /********************************/
610  /* EMIT MALP EVENT */
611  /********************************/
612 
613  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
614 
615  /* Submit event if MPI instrumented */
616  Event_Packer_push(&_container);
617  }
618 
619 
620  return ret;
621 }
622 int MPI_Allgather( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm )
623 {
624 
625  /* Virtualize MPI */
626  MACRO_MPI_Comm (comm)
627 
628  /* Pre instrum */
629  int _rank = Stream_desc_get()->mpi_rank;
630 
631  struct MALP_Trace_Event _container;
632 
633  /********************************/
634  /* FILL MPI EVENT */
635  /********************************/
636 
637  _container.event.mpi_event.type =
638  T_MPI_ENUM(MPI_ALLGATHER)
639  ;
640 
641  /* Set default source & dest before override */
642  _container.event.mpi_event.source = _rank;
643  _container.event.mpi_event.dest = _rank;
644 
645 
646 
647 
648 
649 
650  SET_COMM (comm)
651 
652  /* Fill in size informations if needed */
653  int _size = 0;
654  #if 0
655 
656  #endif
657  _container.event.mpi_event.size = _size;
658 
659  /********************************/
660  /* EMIT OTF ENTER */
661  /********************************/
662 
663  struct MALP_Trace_Event otf_event;
664 
665  uint64_t _begin = Timer_tsc ();
666 
669  {
670 
671  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
672  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
673  MALP_EVENT_MPI, _container.event.mpi_event.type );
674  Event_Packer_push(&otf_event);
675  }
676 
677  /********************************/
678  /* ACTUAL FUNCTION CALL */
679  /********************************/
680 
682  int ret = PMPI_Allgather( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm );
684 
685  /********************************/
686  /* EMIT OTF END */
687  /********************************/
688 
689  uint64_t _end = Timer_tsc();
690  uint64_t _duration = _end - _begin;
691 
693  {
695  {
696 
697  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
698  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
699  MALP_EVENT_MPI, _container.event.mpi_event.type );
700 
701 
702  Event_Packer_push(&otf_event);
703  }
704 
705  /********************************/
706  /* EMIT MALP EVENT */
707  /********************************/
708 
709  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
710 
711  /* Submit event if MPI instrumented */
712  Event_Packer_push(&_container);
713  }
714 
715 
716  return ret;
717 }
718 int MPI_Allgatherv( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int * recvcounts, int * displs, MPI_Datatype recvtype, MPI_Comm comm )
719 {
720 
721  /* Virtualize MPI */
722  MACRO_MPI_Comm (comm)
723 
724  /* Pre instrum */
725  int _rank = Stream_desc_get()->mpi_rank;
726 
727  struct MALP_Trace_Event _container;
728 
729  /********************************/
730  /* FILL MPI EVENT */
731  /********************************/
732 
733  _container.event.mpi_event.type =
734  T_MPI_ENUM(MPI_ALLGATHERV)
735  ;
736 
737  /* Set default source & dest before override */
738  _container.event.mpi_event.source = _rank;
739  _container.event.mpi_event.dest = _rank;
740 
741 
742 
743 
744 
745 
746  SET_COMM (comm)
747 
748  /* Fill in size informations if needed */
749  int _size = 0;
750  #if 0
751 
752  #endif
753  _container.event.mpi_event.size = _size;
754 
755  /********************************/
756  /* EMIT OTF ENTER */
757  /********************************/
758 
759  struct MALP_Trace_Event otf_event;
760 
761  uint64_t _begin = Timer_tsc ();
762 
765  {
766 
767  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
768  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
769  MALP_EVENT_MPI, _container.event.mpi_event.type );
770  Event_Packer_push(&otf_event);
771  }
772 
773  /********************************/
774  /* ACTUAL FUNCTION CALL */
775  /********************************/
776 
778  int ret = PMPI_Allgatherv( sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm );
780 
781  /********************************/
782  /* EMIT OTF END */
783  /********************************/
784 
785  uint64_t _end = Timer_tsc();
786  uint64_t _duration = _end - _begin;
787 
789  {
791  {
792 
793  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
794  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
795  MALP_EVENT_MPI, _container.event.mpi_event.type );
796 
797 
798  Event_Packer_push(&otf_event);
799  }
800 
801  /********************************/
802  /* EMIT MALP EVENT */
803  /********************************/
804 
805  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
806 
807  /* Submit event if MPI instrumented */
808  Event_Packer_push(&_container);
809  }
810 
811 
812  return ret;
813 }
814 int MPI_Alloc_mem( MPI_Aint size, MPI_Info info, void * baseptr )
815 {
816 
817  /* Virtualize MPI */
818 
819 
820  /* Pre instrum */
821  int _rank = Stream_desc_get()->mpi_rank;
822 
823  struct MALP_Trace_Event _container;
824 
825  /********************************/
826  /* FILL MPI EVENT */
827  /********************************/
828 
829  _container.event.mpi_event.type =
830  T_MPI_ENUM(MPI_ALLOC_MEM)
831  ;
832 
833  /* Set default source & dest before override */
834  _container.event.mpi_event.source = _rank;
835  _container.event.mpi_event.dest = _rank;
836 
837 
838 
839 
840 
841 
842 
843 
844  /* Fill in size informations if needed */
845  int _size = 0;
846  #if 0
847 
848  #endif
849  _container.event.mpi_event.size = _size;
850 
851  /********************************/
852  /* EMIT OTF ENTER */
853  /********************************/
854 
855  struct MALP_Trace_Event otf_event;
856 
857  uint64_t _begin = Timer_tsc ();
858 
861  {
862 
863  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
864  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
865  MALP_EVENT_MPI, _container.event.mpi_event.type );
866  Event_Packer_push(&otf_event);
867  }
868 
869  /********************************/
870  /* ACTUAL FUNCTION CALL */
871  /********************************/
872 
874  int ret = PMPI_Alloc_mem( size, info, baseptr );
876 
877  /********************************/
878  /* EMIT OTF END */
879  /********************************/
880 
881  uint64_t _end = Timer_tsc();
882  uint64_t _duration = _end - _begin;
883 
885  {
887  {
888 
889  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
890  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
891  MALP_EVENT_MPI, _container.event.mpi_event.type );
892 
893 
894  Event_Packer_push(&otf_event);
895  }
896 
897  /********************************/
898  /* EMIT MALP EVENT */
899  /********************************/
900 
901  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
902 
903  /* Submit event if MPI instrumented */
904  Event_Packer_push(&_container);
905  }
906 
907 
908  return ret;
909 }
910 int MPI_Allreduce( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
911 {
912 
913  /* Virtualize MPI */
914  MACRO_MPI_Comm (comm)
915 
916  /* Pre instrum */
917  int _rank = Stream_desc_get()->mpi_rank;
918 
919  struct MALP_Trace_Event _container;
920 
921  /********************************/
922  /* FILL MPI EVENT */
923  /********************************/
924 
925  _container.event.mpi_event.type =
926  T_MPI_ENUM(MPI_ALLREDUCE)
927  ;
928 
929  /* Set default source & dest before override */
930  _container.event.mpi_event.source = _rank;
931  _container.event.mpi_event.dest = _rank;
932 
933 
934 
935 
936  SET_COUNT (count)
937  SET_DATATYPE (datatype)
938  SET_COMM (comm)
939 
940  /* Fill in size informations if needed */
941  int _size = 0;
942  #if 1
943  COMP_SIZE (count)
944  #endif
945  _container.event.mpi_event.size = _size;
946 
947  /********************************/
948  /* EMIT OTF ENTER */
949  /********************************/
950 
951  struct MALP_Trace_Event otf_event;
952 
953  uint64_t _begin = Timer_tsc ();
954 
957  {
958 
959  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
960  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
961  MALP_EVENT_MPI, _container.event.mpi_event.type );
962  Event_Packer_push(&otf_event);
963  }
964 
965  /********************************/
966  /* ACTUAL FUNCTION CALL */
967  /********************************/
968 
970  int ret = PMPI_Allreduce( sendbuf, recvbuf, count, datatype, op, comm );
972 
973  /********************************/
974  /* EMIT OTF END */
975  /********************************/
976 
977  uint64_t _end = Timer_tsc();
978  uint64_t _duration = _end - _begin;
979 
981  {
983  {
984 
985  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
986  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
987  MALP_EVENT_MPI, _container.event.mpi_event.type );
988 
989 
990  Event_Packer_push(&otf_event);
991  }
992 
993  /********************************/
994  /* EMIT MALP EVENT */
995  /********************************/
996 
997  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
998 
999  /* Submit event if MPI instrumented */
1000  Event_Packer_push(&_container);
1001  }
1002 
1003 
1004  return ret;
1005 }
1006 int MPI_Alltoall( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm )
1007 {
1008 
1009  /* Virtualize MPI */
1010  MACRO_MPI_Comm (comm)
1011 
1012  /* Pre instrum */
1013  int _rank = Stream_desc_get()->mpi_rank;
1014 
1015  struct MALP_Trace_Event _container;
1016 
1017  /********************************/
1018  /* FILL MPI EVENT */
1019  /********************************/
1020 
1021  _container.event.mpi_event.type =
1022  T_MPI_ENUM(MPI_ALLTOALL)
1023  ;
1024 
1025  /* Set default source & dest before override */
1026  _container.event.mpi_event.source = _rank;
1027  _container.event.mpi_event.dest = _rank;
1028 
1029 
1030 
1031 
1032 
1033 
1034  SET_COMM (comm)
1035 
1036  /* Fill in size informations if needed */
1037  int _size = 0;
1038  #if 0
1039 
1040  #endif
1041  _container.event.mpi_event.size = _size;
1042 
1043  /********************************/
1044  /* EMIT OTF ENTER */
1045  /********************************/
1046 
1047  struct MALP_Trace_Event otf_event;
1048 
1049  uint64_t _begin = Timer_tsc ();
1050 
1053  {
1054 
1055  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1056  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1057  MALP_EVENT_MPI, _container.event.mpi_event.type );
1058  Event_Packer_push(&otf_event);
1059  }
1060 
1061  /********************************/
1062  /* ACTUAL FUNCTION CALL */
1063  /********************************/
1064 
1066  int ret = PMPI_Alltoall( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm );
1068 
1069  /********************************/
1070  /* EMIT OTF END */
1071  /********************************/
1072 
1073  uint64_t _end = Timer_tsc();
1074  uint64_t _duration = _end - _begin;
1075 
1077  {
1079  {
1080 
1081  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1082  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1083  MALP_EVENT_MPI, _container.event.mpi_event.type );
1084 
1085 
1086  Event_Packer_push(&otf_event);
1087  }
1088 
1089  /********************************/
1090  /* EMIT MALP EVENT */
1091  /********************************/
1092 
1093  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1094 
1095  /* Submit event if MPI instrumented */
1096  Event_Packer_push(&_container);
1097  }
1098 
1099 
1100  return ret;
1101 }
1102 int MPI_Alltoallv( void * sendbuf, int * sendcounts, int * sdispls, MPI_Datatype sendtype, void * recvbuf, int * recvcounts, int * rdispls, MPI_Datatype recvtype, MPI_Comm comm )
1103 {
1104 
1105  /* Virtualize MPI */
1106  MACRO_MPI_Comm (comm)
1107 
1108  /* Pre instrum */
1109  int _rank = Stream_desc_get()->mpi_rank;
1110 
1111  struct MALP_Trace_Event _container;
1112 
1113  /********************************/
1114  /* FILL MPI EVENT */
1115  /********************************/
1116 
1117  _container.event.mpi_event.type =
1118  T_MPI_ENUM(MPI_ALLTOALLV)
1119  ;
1120 
1121  /* Set default source & dest before override */
1122  _container.event.mpi_event.source = _rank;
1123  _container.event.mpi_event.dest = _rank;
1124 
1125 
1126 
1127 
1128 
1129 
1130  SET_COMM (comm)
1131 
1132  /* Fill in size informations if needed */
1133  int _size = 0;
1134  #if 0
1135 
1136  #endif
1137  _container.event.mpi_event.size = _size;
1138 
1139  /********************************/
1140  /* EMIT OTF ENTER */
1141  /********************************/
1142 
1143  struct MALP_Trace_Event otf_event;
1144 
1145  uint64_t _begin = Timer_tsc ();
1146 
1149  {
1150 
1151  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1152  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1153  MALP_EVENT_MPI, _container.event.mpi_event.type );
1154  Event_Packer_push(&otf_event);
1155  }
1156 
1157  /********************************/
1158  /* ACTUAL FUNCTION CALL */
1159  /********************************/
1160 
1162  int ret = PMPI_Alltoallv( sendbuf, sendcounts, sdispls, sendtype, recvbuf, recvcounts, rdispls, recvtype, comm );
1164 
1165  /********************************/
1166  /* EMIT OTF END */
1167  /********************************/
1168 
1169  uint64_t _end = Timer_tsc();
1170  uint64_t _duration = _end - _begin;
1171 
1173  {
1175  {
1176 
1177  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1178  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1179  MALP_EVENT_MPI, _container.event.mpi_event.type );
1180 
1181 
1182  Event_Packer_push(&otf_event);
1183  }
1184 
1185  /********************************/
1186  /* EMIT MALP EVENT */
1187  /********************************/
1188 
1189  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1190 
1191  /* Submit event if MPI instrumented */
1192  Event_Packer_push(&_container);
1193  }
1194 
1195 
1196  return ret;
1197 }
1198 int MPI_Alltoallw( void * sendbuf, int * sendcounts, int * sdispls, MPI_Datatype * sendtypes, void * recvbuf, int * recvcounts, int * rdispls, MPI_Datatype * recvtypes, MPI_Comm comm )
1199 {
1200 
1201  /* Virtualize MPI */
1202  MACRO_MPI_Comm (comm)
1203 
1204  /* Pre instrum */
1205  int _rank = Stream_desc_get()->mpi_rank;
1206 
1207  struct MALP_Trace_Event _container;
1208 
1209  /********************************/
1210  /* FILL MPI EVENT */
1211  /********************************/
1212 
1213  _container.event.mpi_event.type =
1214  T_MPI_ENUM(MPI_ALLTOALLW)
1215  ;
1216 
1217  /* Set default source & dest before override */
1218  _container.event.mpi_event.source = _rank;
1219  _container.event.mpi_event.dest = _rank;
1220 
1221 
1222 
1223 
1224 
1225 
1226  SET_COMM (comm)
1227 
1228  /* Fill in size informations if needed */
1229  int _size = 0;
1230  #if 0
1231 
1232  #endif
1233  _container.event.mpi_event.size = _size;
1234 
1235  /********************************/
1236  /* EMIT OTF ENTER */
1237  /********************************/
1238 
1239  struct MALP_Trace_Event otf_event;
1240 
1241  uint64_t _begin = Timer_tsc ();
1242 
1245  {
1246 
1247  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1248  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1249  MALP_EVENT_MPI, _container.event.mpi_event.type );
1250  Event_Packer_push(&otf_event);
1251  }
1252 
1253  /********************************/
1254  /* ACTUAL FUNCTION CALL */
1255  /********************************/
1256 
1258  int ret = PMPI_Alltoallw( sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm );
1260 
1261  /********************************/
1262  /* EMIT OTF END */
1263  /********************************/
1264 
1265  uint64_t _end = Timer_tsc();
1266  uint64_t _duration = _end - _begin;
1267 
1269  {
1271  {
1272 
1273  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1274  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1275  MALP_EVENT_MPI, _container.event.mpi_event.type );
1276 
1277 
1278  Event_Packer_push(&otf_event);
1279  }
1280 
1281  /********************************/
1282  /* EMIT MALP EVENT */
1283  /********************************/
1284 
1285  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1286 
1287  /* Submit event if MPI instrumented */
1288  Event_Packer_push(&_container);
1289  }
1290 
1291 
1292  return ret;
1293 }
1294 int MPI_Attr_delete( MPI_Comm comm, int keyval )
1295 {
1296 
1297  /* Virtualize MPI */
1298  MACRO_MPI_Comm (comm)
1299 
1300  /* Pre instrum */
1301  int _rank = Stream_desc_get()->mpi_rank;
1302 
1303  struct MALP_Trace_Event _container;
1304 
1305  /********************************/
1306  /* FILL MPI EVENT */
1307  /********************************/
1308 
1309  _container.event.mpi_event.type =
1310  T_MPI_ENUM(MPI_ATTR_DELETE)
1311  ;
1312 
1313  /* Set default source & dest before override */
1314  _container.event.mpi_event.source = _rank;
1315  _container.event.mpi_event.dest = _rank;
1316 
1317 
1318 
1319 
1320 
1321 
1322  SET_COMM (comm)
1323 
1324  /* Fill in size informations if needed */
1325  int _size = 0;
1326  #if 0
1327 
1328  #endif
1329  _container.event.mpi_event.size = _size;
1330 
1331  /********************************/
1332  /* EMIT OTF ENTER */
1333  /********************************/
1334 
1335  struct MALP_Trace_Event otf_event;
1336 
1337  uint64_t _begin = Timer_tsc ();
1338 
1341  {
1342 
1343  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1344  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1345  MALP_EVENT_MPI, _container.event.mpi_event.type );
1346  Event_Packer_push(&otf_event);
1347  }
1348 
1349  /********************************/
1350  /* ACTUAL FUNCTION CALL */
1351  /********************************/
1352 
1354  int ret = PMPI_Attr_delete( comm, keyval );
1356 
1357  /********************************/
1358  /* EMIT OTF END */
1359  /********************************/
1360 
1361  uint64_t _end = Timer_tsc();
1362  uint64_t _duration = _end - _begin;
1363 
1365  {
1367  {
1368 
1369  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1370  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1371  MALP_EVENT_MPI, _container.event.mpi_event.type );
1372 
1373 
1374  Event_Packer_push(&otf_event);
1375  }
1376 
1377  /********************************/
1378  /* EMIT MALP EVENT */
1379  /********************************/
1380 
1381  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1382 
1383  /* Submit event if MPI instrumented */
1384  Event_Packer_push(&_container);
1385  }
1386 
1387 
1388  return ret;
1389 }
1390 int MPI_Attr_get( MPI_Comm comm, int keyval, void * attribute_val, int * flag )
1391 {
1392 
1393  /* Virtualize MPI */
1394  MACRO_MPI_Comm (comm)
1395 
1396  /* Pre instrum */
1397  int _rank = Stream_desc_get()->mpi_rank;
1398 
1399  struct MALP_Trace_Event _container;
1400 
1401  /********************************/
1402  /* FILL MPI EVENT */
1403  /********************************/
1404 
1405  _container.event.mpi_event.type =
1406  T_MPI_ENUM(MPI_ATTR_GET)
1407  ;
1408 
1409  /* Set default source & dest before override */
1410  _container.event.mpi_event.source = _rank;
1411  _container.event.mpi_event.dest = _rank;
1412 
1413 
1414 
1415 
1416 
1417 
1418  SET_COMM (comm)
1419 
1420  /* Fill in size informations if needed */
1421  int _size = 0;
1422  #if 0
1423 
1424  #endif
1425  _container.event.mpi_event.size = _size;
1426 
1427  /********************************/
1428  /* EMIT OTF ENTER */
1429  /********************************/
1430 
1431  struct MALP_Trace_Event otf_event;
1432 
1433  uint64_t _begin = Timer_tsc ();
1434 
1437  {
1438 
1439  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1440  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1441  MALP_EVENT_MPI, _container.event.mpi_event.type );
1442  Event_Packer_push(&otf_event);
1443  }
1444 
1445  /********************************/
1446  /* ACTUAL FUNCTION CALL */
1447  /********************************/
1448 
1450  int ret = PMPI_Attr_get( comm, keyval, attribute_val, flag );
1452 
1453  /********************************/
1454  /* EMIT OTF END */
1455  /********************************/
1456 
1457  uint64_t _end = Timer_tsc();
1458  uint64_t _duration = _end - _begin;
1459 
1461  {
1463  {
1464 
1465  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1466  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1467  MALP_EVENT_MPI, _container.event.mpi_event.type );
1468 
1469 
1470  Event_Packer_push(&otf_event);
1471  }
1472 
1473  /********************************/
1474  /* EMIT MALP EVENT */
1475  /********************************/
1476 
1477  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1478 
1479  /* Submit event if MPI instrumented */
1480  Event_Packer_push(&_container);
1481  }
1482 
1483 
1484  return ret;
1485 }
1486 int MPI_Attr_put( MPI_Comm comm, int keyval, void * attribute_val )
1487 {
1488 
1489  /* Virtualize MPI */
1490  MACRO_MPI_Comm (comm)
1491 
1492  /* Pre instrum */
1493  int _rank = Stream_desc_get()->mpi_rank;
1494 
1495  struct MALP_Trace_Event _container;
1496 
1497  /********************************/
1498  /* FILL MPI EVENT */
1499  /********************************/
1500 
1501  _container.event.mpi_event.type =
1502  T_MPI_ENUM(MPI_ATTR_PUT)
1503  ;
1504 
1505  /* Set default source & dest before override */
1506  _container.event.mpi_event.source = _rank;
1507  _container.event.mpi_event.dest = _rank;
1508 
1509 
1510 
1511 
1512 
1513 
1514  SET_COMM (comm)
1515 
1516  /* Fill in size informations if needed */
1517  int _size = 0;
1518  #if 0
1519 
1520  #endif
1521  _container.event.mpi_event.size = _size;
1522 
1523  /********************************/
1524  /* EMIT OTF ENTER */
1525  /********************************/
1526 
1527  struct MALP_Trace_Event otf_event;
1528 
1529  uint64_t _begin = Timer_tsc ();
1530 
1533  {
1534 
1535  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1536  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1537  MALP_EVENT_MPI, _container.event.mpi_event.type );
1538  Event_Packer_push(&otf_event);
1539  }
1540 
1541  /********************************/
1542  /* ACTUAL FUNCTION CALL */
1543  /********************************/
1544 
1546  int ret = PMPI_Attr_put( comm, keyval, attribute_val );
1548 
1549  /********************************/
1550  /* EMIT OTF END */
1551  /********************************/
1552 
1553  uint64_t _end = Timer_tsc();
1554  uint64_t _duration = _end - _begin;
1555 
1557  {
1559  {
1560 
1561  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1562  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1563  MALP_EVENT_MPI, _container.event.mpi_event.type );
1564 
1565 
1566  Event_Packer_push(&otf_event);
1567  }
1568 
1569  /********************************/
1570  /* EMIT MALP EVENT */
1571  /********************************/
1572 
1573  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1574 
1575  /* Submit event if MPI instrumented */
1576  Event_Packer_push(&_container);
1577  }
1578 
1579 
1580  return ret;
1581 }
1582 int MPI_Barrier( MPI_Comm comm )
1583 {
1584 
1585  /* Virtualize MPI */
1586  MACRO_MPI_Comm (comm)
1587 
1588  /* Pre instrum */
1589  int _rank = Stream_desc_get()->mpi_rank;
1590 
1591  struct MALP_Trace_Event _container;
1592 
1593  /********************************/
1594  /* FILL MPI EVENT */
1595  /********************************/
1596 
1597  _container.event.mpi_event.type =
1598  T_MPI_ENUM(MPI_BARRIER)
1599  ;
1600 
1601  /* Set default source & dest before override */
1602  _container.event.mpi_event.source = _rank;
1603  _container.event.mpi_event.dest = _rank;
1604 
1605 
1606 
1607 
1608 
1609 
1610  SET_COMM (comm)
1611 
1612  /* Fill in size informations if needed */
1613  int _size = 0;
1614  #if 0
1615 
1616  #endif
1617  _container.event.mpi_event.size = _size;
1618 
1619  /********************************/
1620  /* EMIT OTF ENTER */
1621  /********************************/
1622 
1623  struct MALP_Trace_Event otf_event;
1624 
1625  uint64_t _begin = Timer_tsc ();
1626 
1629  {
1630 
1631  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1632  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1633  MALP_EVENT_MPI, _container.event.mpi_event.type );
1634  Event_Packer_push(&otf_event);
1635  }
1636 
1637  /********************************/
1638  /* ACTUAL FUNCTION CALL */
1639  /********************************/
1640 
1642  int ret = PMPI_Barrier( comm );
1644 
1645  /********************************/
1646  /* EMIT OTF END */
1647  /********************************/
1648 
1649  uint64_t _end = Timer_tsc();
1650  uint64_t _duration = _end - _begin;
1651 
1653  {
1655  {
1656 
1657  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1658  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1659  MALP_EVENT_MPI, _container.event.mpi_event.type );
1660 
1661 
1662  Event_Packer_push(&otf_event);
1663  }
1664 
1665  /********************************/
1666  /* EMIT MALP EVENT */
1667  /********************************/
1668 
1669  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1670 
1671  /* Submit event if MPI instrumented */
1672  Event_Packer_push(&_container);
1673  }
1674 
1675 
1676  return ret;
1677 }
1678 int MPI_Bcast( void * buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm )
1679 {
1680 
1681  /* Virtualize MPI */
1682  MACRO_MPI_Comm (comm)
1683 
1684  /* Pre instrum */
1685  int _rank = Stream_desc_get()->mpi_rank;
1686 
1687  struct MALP_Trace_Event _container;
1688 
1689  /********************************/
1690  /* FILL MPI EVENT */
1691  /********************************/
1692 
1693  _container.event.mpi_event.type =
1694  T_MPI_ENUM(MPI_BCAST)
1695  ;
1696 
1697  /* Set default source & dest before override */
1698  _container.event.mpi_event.source = _rank;
1699  _container.event.mpi_event.dest = _rank;
1700 
1701 
1702 
1703 
1704  SET_COUNT (count)
1705  SET_DATATYPE (datatype)
1706  SET_COMM (comm)
1707 
1708  /* Fill in size informations if needed */
1709  int _size = 0;
1710  #if 1
1711  COMP_SIZE (count)
1712  #endif
1713  _container.event.mpi_event.size = _size;
1714 
1715  /********************************/
1716  /* EMIT OTF ENTER */
1717  /********************************/
1718 
1719  struct MALP_Trace_Event otf_event;
1720 
1721  uint64_t _begin = Timer_tsc ();
1722 
1725  {
1726 
1727  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1728  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1729  MALP_EVENT_MPI, _container.event.mpi_event.type );
1730  Event_Packer_push(&otf_event);
1731  }
1732 
1733  /********************************/
1734  /* ACTUAL FUNCTION CALL */
1735  /********************************/
1736 
1738  int ret = PMPI_Bcast( buffer, count, datatype, root, comm );
1740 
1741  /********************************/
1742  /* EMIT OTF END */
1743  /********************************/
1744 
1745  uint64_t _end = Timer_tsc();
1746  uint64_t _duration = _end - _begin;
1747 
1749  {
1751  {
1752 
1753  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1754  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1755  MALP_EVENT_MPI, _container.event.mpi_event.type );
1756 
1757 
1758  Event_Packer_push(&otf_event);
1759  }
1760 
1761  /********************************/
1762  /* EMIT MALP EVENT */
1763  /********************************/
1764 
1765  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1766 
1767  /* Submit event if MPI instrumented */
1768  Event_Packer_push(&_container);
1769  }
1770 
1771 
1772  return ret;
1773 }
1774 int MPI_Bsend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
1775 {
1776 
1777  /* Virtualize MPI */
1778  MACRO_MPI_Comm (comm)
1779 
1780  /* Pre instrum */
1781  int _rank = Stream_desc_get()->mpi_rank;
1782 
1783  struct MALP_Trace_Event _container;
1784 
1785  /********************************/
1786  /* FILL MPI EVENT */
1787  /********************************/
1788 
1789  _container.event.mpi_event.type =
1790  T_MPI_ENUM(MPI_BSEND)
1791  ;
1792 
1793  /* Set default source & dest before override */
1794  _container.event.mpi_event.source = _rank;
1795  _container.event.mpi_event.dest = _rank;
1796 
1797 
1798  SET_DEST (dest)
1799  SET_TAG (tag)
1800  SET_COUNT (count)
1801  SET_DATATYPE (datatype)
1802  SET_COMM (comm)
1803 
1804  /* Fill in size informations if needed */
1805  int _size = 0;
1806  #if 1
1807  COMP_SIZE (count)
1808  #endif
1809  _container.event.mpi_event.size = _size;
1810 
1811  /********************************/
1812  /* EMIT OTF ENTER */
1813  /********************************/
1814 
1815  struct MALP_Trace_Event otf_event;
1816 
1817  uint64_t _begin = Timer_tsc ();
1818 
1821  {
1822 
1823  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1824  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1825  MALP_EVENT_MPI, _container.event.mpi_event.type );
1826  Event_Packer_push(&otf_event);
1827  }
1828 
1829  /********************************/
1830  /* ACTUAL FUNCTION CALL */
1831  /********************************/
1832 
1834  int ret = PMPI_Bsend( buf, count, datatype, dest, tag, comm );
1836 
1837  /********************************/
1838  /* EMIT OTF END */
1839  /********************************/
1840 
1841  uint64_t _end = Timer_tsc();
1842  uint64_t _duration = _end - _begin;
1843 
1845  {
1847  {
1848 
1849  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1850  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1851  MALP_EVENT_MPI, _container.event.mpi_event.type );
1852 
1853 
1854  Event_Packer_push(&otf_event);
1855  }
1856 
1857  /********************************/
1858  /* EMIT MALP EVENT */
1859  /********************************/
1860 
1861  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1862 
1863  /* Submit event if MPI instrumented */
1864  Event_Packer_push(&_container);
1865  }
1866 
1867 
1868  return ret;
1869 }
1870 int MPI_Bsend_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
1871 {
1872 
1873  /* Virtualize MPI */
1874  MACRO_MPI_Comm (comm)
1875 
1876  /* Pre instrum */
1877  int _rank = Stream_desc_get()->mpi_rank;
1878 
1879  struct MALP_Trace_Event _container;
1880 
1881  /********************************/
1882  /* FILL MPI EVENT */
1883  /********************************/
1884 
1885  _container.event.mpi_event.type =
1886  T_MPI_ENUM(MPI_BSEND_INIT)
1887  ;
1888 
1889  /* Set default source & dest before override */
1890  _container.event.mpi_event.source = _rank;
1891  _container.event.mpi_event.dest = _rank;
1892 
1893 
1894  SET_DEST (dest)
1895  SET_TAG (tag)
1896  SET_COUNT (count)
1897  SET_DATATYPE (datatype)
1898  SET_COMM (comm)
1899 
1900  /* Fill in size informations if needed */
1901  int _size = 0;
1902  #if 1
1903  COMP_SIZE (count)
1904  #endif
1905  _container.event.mpi_event.size = _size;
1906 
1907  /********************************/
1908  /* EMIT OTF ENTER */
1909  /********************************/
1910 
1911  struct MALP_Trace_Event otf_event;
1912 
1913  uint64_t _begin = Timer_tsc ();
1914 
1917  {
1918 
1919  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
1920  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
1921  MALP_EVENT_MPI, _container.event.mpi_event.type );
1922  Event_Packer_push(&otf_event);
1923  }
1924 
1925  /********************************/
1926  /* ACTUAL FUNCTION CALL */
1927  /********************************/
1928 
1930  int ret = PMPI_Bsend_init( buf, count, datatype, dest, tag, comm, request );
1932 
1933  /********************************/
1934  /* EMIT OTF END */
1935  /********************************/
1936 
1937  uint64_t _end = Timer_tsc();
1938  uint64_t _duration = _end - _begin;
1939 
1941  {
1943  {
1944 
1945  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
1946  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
1947  MALP_EVENT_MPI, _container.event.mpi_event.type );
1948 
1949 
1950  Event_Packer_push(&otf_event);
1951  }
1952 
1953  /********************************/
1954  /* EMIT MALP EVENT */
1955  /********************************/
1956 
1957  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
1958 
1959  /* Submit event if MPI instrumented */
1960  Event_Packer_push(&_container);
1961  }
1962 
1963 
1964  return ret;
1965 }
1966 int MPI_Buffer_attach( void * buffer, int size )
1967 {
1968 
1969  /* Virtualize MPI */
1970 
1971 
1972  /* Pre instrum */
1973  int _rank = Stream_desc_get()->mpi_rank;
1974 
1975  struct MALP_Trace_Event _container;
1976 
1977  /********************************/
1978  /* FILL MPI EVENT */
1979  /********************************/
1980 
1981  _container.event.mpi_event.type =
1982  T_MPI_ENUM(MPI_BUFFER_ATTACH)
1983  ;
1984 
1985  /* Set default source & dest before override */
1986  _container.event.mpi_event.source = _rank;
1987  _container.event.mpi_event.dest = _rank;
1988 
1989 
1990 
1991 
1992 
1993 
1994 
1995 
1996  /* Fill in size informations if needed */
1997  int _size = 0;
1998  #if 0
1999 
2000  #endif
2001  _container.event.mpi_event.size = _size;
2002 
2003  /********************************/
2004  /* EMIT OTF ENTER */
2005  /********************************/
2006 
2007  struct MALP_Trace_Event otf_event;
2008 
2009  uint64_t _begin = Timer_tsc ();
2010 
2013  {
2014 
2015  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2016  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2017  MALP_EVENT_MPI, _container.event.mpi_event.type );
2018  Event_Packer_push(&otf_event);
2019  }
2020 
2021  /********************************/
2022  /* ACTUAL FUNCTION CALL */
2023  /********************************/
2024 
2026  int ret = PMPI_Buffer_attach( buffer, size );
2028 
2029  /********************************/
2030  /* EMIT OTF END */
2031  /********************************/
2032 
2033  uint64_t _end = Timer_tsc();
2034  uint64_t _duration = _end - _begin;
2035 
2037  {
2039  {
2040 
2041  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2042  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2043  MALP_EVENT_MPI, _container.event.mpi_event.type );
2044 
2045 
2046  Event_Packer_push(&otf_event);
2047  }
2048 
2049  /********************************/
2050  /* EMIT MALP EVENT */
2051  /********************************/
2052 
2053  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2054 
2055  /* Submit event if MPI instrumented */
2056  Event_Packer_push(&_container);
2057  }
2058 
2059 
2060  return ret;
2061 }
2062 int MPI_Buffer_detach( void * buffer, int * size )
2063 {
2064 
2065  /* Virtualize MPI */
2066 
2067 
2068  /* Pre instrum */
2069  int _rank = Stream_desc_get()->mpi_rank;
2070 
2071  struct MALP_Trace_Event _container;
2072 
2073  /********************************/
2074  /* FILL MPI EVENT */
2075  /********************************/
2076 
2077  _container.event.mpi_event.type =
2078  T_MPI_ENUM(MPI_BUFFER_DETACH)
2079  ;
2080 
2081  /* Set default source & dest before override */
2082  _container.event.mpi_event.source = _rank;
2083  _container.event.mpi_event.dest = _rank;
2084 
2085 
2086 
2087 
2088 
2089 
2090 
2091 
2092  /* Fill in size informations if needed */
2093  int _size = 0;
2094  #if 0
2095 
2096  #endif
2097  _container.event.mpi_event.size = _size;
2098 
2099  /********************************/
2100  /* EMIT OTF ENTER */
2101  /********************************/
2102 
2103  struct MALP_Trace_Event otf_event;
2104 
2105  uint64_t _begin = Timer_tsc ();
2106 
2109  {
2110 
2111  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2112  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2113  MALP_EVENT_MPI, _container.event.mpi_event.type );
2114  Event_Packer_push(&otf_event);
2115  }
2116 
2117  /********************************/
2118  /* ACTUAL FUNCTION CALL */
2119  /********************************/
2120 
2122  int ret = PMPI_Buffer_detach( buffer, size );
2124 
2125  /********************************/
2126  /* EMIT OTF END */
2127  /********************************/
2128 
2129  uint64_t _end = Timer_tsc();
2130  uint64_t _duration = _end - _begin;
2131 
2133  {
2135  {
2136 
2137  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2138  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2139  MALP_EVENT_MPI, _container.event.mpi_event.type );
2140 
2141 
2142  Event_Packer_push(&otf_event);
2143  }
2144 
2145  /********************************/
2146  /* EMIT MALP EVENT */
2147  /********************************/
2148 
2149  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2150 
2151  /* Submit event if MPI instrumented */
2152  Event_Packer_push(&_container);
2153  }
2154 
2155 
2156  return ret;
2157 }
2158 int MPI_Cancel( MPI_Request * request )
2159 {
2160 
2161  /* Virtualize MPI */
2162 
2163 
2164  /* Pre instrum */
2165  int _rank = Stream_desc_get()->mpi_rank;
2166 
2167  struct MALP_Trace_Event _container;
2168 
2169  /********************************/
2170  /* FILL MPI EVENT */
2171  /********************************/
2172 
2173  _container.event.mpi_event.type =
2174  T_MPI_ENUM(MPI_CANCEL)
2175  ;
2176 
2177  /* Set default source & dest before override */
2178  _container.event.mpi_event.source = _rank;
2179  _container.event.mpi_event.dest = _rank;
2180 
2181 
2182 
2183 
2184 
2185 
2186 
2187 
2188  /* Fill in size informations if needed */
2189  int _size = 0;
2190  #if 0
2191 
2192  #endif
2193  _container.event.mpi_event.size = _size;
2194 
2195  /********************************/
2196  /* EMIT OTF ENTER */
2197  /********************************/
2198 
2199  struct MALP_Trace_Event otf_event;
2200 
2201  uint64_t _begin = Timer_tsc ();
2202 
2205  {
2206 
2207  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2208  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2209  MALP_EVENT_MPI, _container.event.mpi_event.type );
2210  Event_Packer_push(&otf_event);
2211  }
2212 
2213  /********************************/
2214  /* ACTUAL FUNCTION CALL */
2215  /********************************/
2216 
2218  int ret = PMPI_Cancel( request );
2220 
2221  /********************************/
2222  /* EMIT OTF END */
2223  /********************************/
2224 
2225  uint64_t _end = Timer_tsc();
2226  uint64_t _duration = _end - _begin;
2227 
2229  {
2231  {
2232 
2233  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2234  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2235  MALP_EVENT_MPI, _container.event.mpi_event.type );
2236 
2237 
2238  Event_Packer_push(&otf_event);
2239  }
2240 
2241  /********************************/
2242  /* EMIT MALP EVENT */
2243  /********************************/
2244 
2245  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2246 
2247  /* Submit event if MPI instrumented */
2248  Event_Packer_push(&_container);
2249  }
2250 
2251 
2252  return ret;
2253 }
2254 int MPI_Cart_coords( MPI_Comm comm, int rank, int maxdims, int * coords )
2255 {
2256 
2257  /* Virtualize MPI */
2258  MACRO_MPI_Comm (comm)
2259 
2260  /* Pre instrum */
2261  int _rank = Stream_desc_get()->mpi_rank;
2262 
2263  struct MALP_Trace_Event _container;
2264 
2265  /********************************/
2266  /* FILL MPI EVENT */
2267  /********************************/
2268 
2269  _container.event.mpi_event.type =
2270  T_MPI_ENUM(MPI_CART_COORDS)
2271  ;
2272 
2273  /* Set default source & dest before override */
2274  _container.event.mpi_event.source = _rank;
2275  _container.event.mpi_event.dest = _rank;
2276 
2277 
2278 
2279 
2280 
2281 
2282  SET_COMM (comm)
2283 
2284  /* Fill in size informations if needed */
2285  int _size = 0;
2286  #if 0
2287 
2288  #endif
2289  _container.event.mpi_event.size = _size;
2290 
2291  /********************************/
2292  /* EMIT OTF ENTER */
2293  /********************************/
2294 
2295  struct MALP_Trace_Event otf_event;
2296 
2297  uint64_t _begin = Timer_tsc ();
2298 
2301  {
2302 
2303  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2304  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2305  MALP_EVENT_MPI, _container.event.mpi_event.type );
2306  Event_Packer_push(&otf_event);
2307  }
2308 
2309  /********************************/
2310  /* ACTUAL FUNCTION CALL */
2311  /********************************/
2312 
2314  int ret = PMPI_Cart_coords( comm, rank, maxdims, coords );
2316 
2317  /********************************/
2318  /* EMIT OTF END */
2319  /********************************/
2320 
2321  uint64_t _end = Timer_tsc();
2322  uint64_t _duration = _end - _begin;
2323 
2325  {
2327  {
2328 
2329  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2330  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2331  MALP_EVENT_MPI, _container.event.mpi_event.type );
2332 
2333 
2334  Event_Packer_push(&otf_event);
2335  }
2336 
2337  /********************************/
2338  /* EMIT MALP EVENT */
2339  /********************************/
2340 
2341  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2342 
2343  /* Submit event if MPI instrumented */
2344  Event_Packer_push(&_container);
2345  }
2346 
2347 
2348  return ret;
2349 }
2350 int MPI_Cart_create( MPI_Comm old_comm, int ndims, int * dims, int * periods, int reorder, MPI_Comm * comm_cart )
2351 {
2352 
2353  /* Virtualize MPI */
2354  MACRO_MPI_Comm (old_comm)
2355 
2356  /* Pre instrum */
2357  int _rank = Stream_desc_get()->mpi_rank;
2358 
2359  struct MALP_Trace_Event _container;
2360 
2361  /********************************/
2362  /* FILL MPI EVENT */
2363  /********************************/
2364 
2365  _container.event.mpi_event.type =
2366  T_MPI_ENUM(MPI_CART_CREATE)
2367  ;
2368 
2369  /* Set default source & dest before override */
2370  _container.event.mpi_event.source = _rank;
2371  _container.event.mpi_event.dest = _rank;
2372 
2373 
2374 
2375 
2376 
2377 
2378 
2379 
2380  /* Fill in size informations if needed */
2381  int _size = 0;
2382  #if 0
2383 
2384  #endif
2385  _container.event.mpi_event.size = _size;
2386 
2387  /********************************/
2388  /* EMIT OTF ENTER */
2389  /********************************/
2390 
2391  struct MALP_Trace_Event otf_event;
2392 
2393  uint64_t _begin = Timer_tsc ();
2394 
2397  {
2398 
2399  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2400  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2401  MALP_EVENT_MPI, _container.event.mpi_event.type );
2402  Event_Packer_push(&otf_event);
2403  }
2404 
2405  /********************************/
2406  /* ACTUAL FUNCTION CALL */
2407  /********************************/
2408 
2410  int ret = PMPI_Cart_create( old_comm, ndims, dims, periods, reorder, comm_cart );
2412 
2413  /********************************/
2414  /* EMIT OTF END */
2415  /********************************/
2416 
2417  uint64_t _end = Timer_tsc();
2418  uint64_t _duration = _end - _begin;
2419 
2421  {
2423  {
2424 
2425  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2426  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2427  MALP_EVENT_MPI, _container.event.mpi_event.type );
2428 
2429 
2430  Event_Packer_push(&otf_event);
2431  }
2432 
2433  /********************************/
2434  /* EMIT MALP EVENT */
2435  /********************************/
2436 
2437  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2438 
2439  /* Submit event if MPI instrumented */
2440  Event_Packer_push(&_container);
2441  }
2442 
2443 
2444  return ret;
2445 }
2446 int MPI_Cart_get( MPI_Comm comm, int maxdims, int * dims, int * periods, int * coords )
2447 {
2448 
2449  /* Virtualize MPI */
2450  MACRO_MPI_Comm (comm)
2451 
2452  /* Pre instrum */
2453  int _rank = Stream_desc_get()->mpi_rank;
2454 
2455  struct MALP_Trace_Event _container;
2456 
2457  /********************************/
2458  /* FILL MPI EVENT */
2459  /********************************/
2460 
2461  _container.event.mpi_event.type =
2462  T_MPI_ENUM(MPI_CART_GET)
2463  ;
2464 
2465  /* Set default source & dest before override */
2466  _container.event.mpi_event.source = _rank;
2467  _container.event.mpi_event.dest = _rank;
2468 
2469 
2470 
2471 
2472 
2473 
2474  SET_COMM (comm)
2475 
2476  /* Fill in size informations if needed */
2477  int _size = 0;
2478  #if 0
2479 
2480  #endif
2481  _container.event.mpi_event.size = _size;
2482 
2483  /********************************/
2484  /* EMIT OTF ENTER */
2485  /********************************/
2486 
2487  struct MALP_Trace_Event otf_event;
2488 
2489  uint64_t _begin = Timer_tsc ();
2490 
2493  {
2494 
2495  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2496  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2497  MALP_EVENT_MPI, _container.event.mpi_event.type );
2498  Event_Packer_push(&otf_event);
2499  }
2500 
2501  /********************************/
2502  /* ACTUAL FUNCTION CALL */
2503  /********************************/
2504 
2506  int ret = PMPI_Cart_get( comm, maxdims, dims, periods, coords );
2508 
2509  /********************************/
2510  /* EMIT OTF END */
2511  /********************************/
2512 
2513  uint64_t _end = Timer_tsc();
2514  uint64_t _duration = _end - _begin;
2515 
2517  {
2519  {
2520 
2521  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2522  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2523  MALP_EVENT_MPI, _container.event.mpi_event.type );
2524 
2525 
2526  Event_Packer_push(&otf_event);
2527  }
2528 
2529  /********************************/
2530  /* EMIT MALP EVENT */
2531  /********************************/
2532 
2533  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2534 
2535  /* Submit event if MPI instrumented */
2536  Event_Packer_push(&_container);
2537  }
2538 
2539 
2540  return ret;
2541 }
2542 int MPI_Cart_map( MPI_Comm comm, int ndims, int * dims, int * periods, int * newrank )
2543 {
2544 
2545  /* Virtualize MPI */
2546  MACRO_MPI_Comm (comm)
2547 
2548  /* Pre instrum */
2549  int _rank = Stream_desc_get()->mpi_rank;
2550 
2551  struct MALP_Trace_Event _container;
2552 
2553  /********************************/
2554  /* FILL MPI EVENT */
2555  /********************************/
2556 
2557  _container.event.mpi_event.type =
2558  T_MPI_ENUM(MPI_CART_MAP)
2559  ;
2560 
2561  /* Set default source & dest before override */
2562  _container.event.mpi_event.source = _rank;
2563  _container.event.mpi_event.dest = _rank;
2564 
2565 
2566 
2567 
2568 
2569 
2570  SET_COMM (comm)
2571 
2572  /* Fill in size informations if needed */
2573  int _size = 0;
2574  #if 0
2575 
2576  #endif
2577  _container.event.mpi_event.size = _size;
2578 
2579  /********************************/
2580  /* EMIT OTF ENTER */
2581  /********************************/
2582 
2583  struct MALP_Trace_Event otf_event;
2584 
2585  uint64_t _begin = Timer_tsc ();
2586 
2589  {
2590 
2591  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2592  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2593  MALP_EVENT_MPI, _container.event.mpi_event.type );
2594  Event_Packer_push(&otf_event);
2595  }
2596 
2597  /********************************/
2598  /* ACTUAL FUNCTION CALL */
2599  /********************************/
2600 
2602  int ret = PMPI_Cart_map( comm, ndims, dims, periods, newrank );
2604 
2605  /********************************/
2606  /* EMIT OTF END */
2607  /********************************/
2608 
2609  uint64_t _end = Timer_tsc();
2610  uint64_t _duration = _end - _begin;
2611 
2613  {
2615  {
2616 
2617  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2618  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2619  MALP_EVENT_MPI, _container.event.mpi_event.type );
2620 
2621 
2622  Event_Packer_push(&otf_event);
2623  }
2624 
2625  /********************************/
2626  /* EMIT MALP EVENT */
2627  /********************************/
2628 
2629  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2630 
2631  /* Submit event if MPI instrumented */
2632  Event_Packer_push(&_container);
2633  }
2634 
2635 
2636  return ret;
2637 }
2638 int MPI_Cart_rank( MPI_Comm comm, int * coords, int * rank )
2639 {
2640 
2641  /* Virtualize MPI */
2642  MACRO_MPI_Comm (comm)
2643 
2644  /* Pre instrum */
2645  int _rank = Stream_desc_get()->mpi_rank;
2646 
2647  struct MALP_Trace_Event _container;
2648 
2649  /********************************/
2650  /* FILL MPI EVENT */
2651  /********************************/
2652 
2653  _container.event.mpi_event.type =
2654  T_MPI_ENUM(MPI_CART_RANK)
2655  ;
2656 
2657  /* Set default source & dest before override */
2658  _container.event.mpi_event.source = _rank;
2659  _container.event.mpi_event.dest = _rank;
2660 
2661 
2662 
2663 
2664 
2665 
2666  SET_COMM (comm)
2667 
2668  /* Fill in size informations if needed */
2669  int _size = 0;
2670  #if 0
2671 
2672  #endif
2673  _container.event.mpi_event.size = _size;
2674 
2675  /********************************/
2676  /* EMIT OTF ENTER */
2677  /********************************/
2678 
2679  struct MALP_Trace_Event otf_event;
2680 
2681  uint64_t _begin = Timer_tsc ();
2682 
2685  {
2686 
2687  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2688  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2689  MALP_EVENT_MPI, _container.event.mpi_event.type );
2690  Event_Packer_push(&otf_event);
2691  }
2692 
2693  /********************************/
2694  /* ACTUAL FUNCTION CALL */
2695  /********************************/
2696 
2698  int ret = PMPI_Cart_rank( comm, coords, rank );
2700 
2701  /********************************/
2702  /* EMIT OTF END */
2703  /********************************/
2704 
2705  uint64_t _end = Timer_tsc();
2706  uint64_t _duration = _end - _begin;
2707 
2709  {
2711  {
2712 
2713  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2714  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2715  MALP_EVENT_MPI, _container.event.mpi_event.type );
2716 
2717 
2718  Event_Packer_push(&otf_event);
2719  }
2720 
2721  /********************************/
2722  /* EMIT MALP EVENT */
2723  /********************************/
2724 
2725  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2726 
2727  /* Submit event if MPI instrumented */
2728  Event_Packer_push(&_container);
2729  }
2730 
2731 
2732  return ret;
2733 }
2734 int MPI_Cart_shift( MPI_Comm comm, int direction, int disp, int * rank_source, int * rank_dest )
2735 {
2736 
2737  /* Virtualize MPI */
2738  MACRO_MPI_Comm (comm)
2739 
2740  /* Pre instrum */
2741  int _rank = Stream_desc_get()->mpi_rank;
2742 
2743  struct MALP_Trace_Event _container;
2744 
2745  /********************************/
2746  /* FILL MPI EVENT */
2747  /********************************/
2748 
2749  _container.event.mpi_event.type =
2750  T_MPI_ENUM(MPI_CART_SHIFT)
2751  ;
2752 
2753  /* Set default source & dest before override */
2754  _container.event.mpi_event.source = _rank;
2755  _container.event.mpi_event.dest = _rank;
2756 
2757 
2758 
2759 
2760 
2761 
2762  SET_COMM (comm)
2763 
2764  /* Fill in size informations if needed */
2765  int _size = 0;
2766  #if 0
2767 
2768  #endif
2769  _container.event.mpi_event.size = _size;
2770 
2771  /********************************/
2772  /* EMIT OTF ENTER */
2773  /********************************/
2774 
2775  struct MALP_Trace_Event otf_event;
2776 
2777  uint64_t _begin = Timer_tsc ();
2778 
2781  {
2782 
2783  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2784  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2785  MALP_EVENT_MPI, _container.event.mpi_event.type );
2786  Event_Packer_push(&otf_event);
2787  }
2788 
2789  /********************************/
2790  /* ACTUAL FUNCTION CALL */
2791  /********************************/
2792 
2794  int ret = PMPI_Cart_shift( comm, direction, disp, rank_source, rank_dest );
2796 
2797  /********************************/
2798  /* EMIT OTF END */
2799  /********************************/
2800 
2801  uint64_t _end = Timer_tsc();
2802  uint64_t _duration = _end - _begin;
2803 
2805  {
2807  {
2808 
2809  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2810  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2811  MALP_EVENT_MPI, _container.event.mpi_event.type );
2812 
2813 
2814  Event_Packer_push(&otf_event);
2815  }
2816 
2817  /********************************/
2818  /* EMIT MALP EVENT */
2819  /********************************/
2820 
2821  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2822 
2823  /* Submit event if MPI instrumented */
2824  Event_Packer_push(&_container);
2825  }
2826 
2827 
2828  return ret;
2829 }
2830 int MPI_Cart_sub( MPI_Comm comm, int * remain_dims, MPI_Comm * new_comm )
2831 {
2832 
2833  /* Virtualize MPI */
2834  MACRO_MPI_Comm (comm)
2835 
2836  /* Pre instrum */
2837  int _rank = Stream_desc_get()->mpi_rank;
2838 
2839  struct MALP_Trace_Event _container;
2840 
2841  /********************************/
2842  /* FILL MPI EVENT */
2843  /********************************/
2844 
2845  _container.event.mpi_event.type =
2846  T_MPI_ENUM(MPI_CART_SUB)
2847  ;
2848 
2849  /* Set default source & dest before override */
2850  _container.event.mpi_event.source = _rank;
2851  _container.event.mpi_event.dest = _rank;
2852 
2853 
2854 
2855 
2856 
2857 
2858  SET_COMM (comm)
2859 
2860  /* Fill in size informations if needed */
2861  int _size = 0;
2862  #if 0
2863 
2864  #endif
2865  _container.event.mpi_event.size = _size;
2866 
2867  /********************************/
2868  /* EMIT OTF ENTER */
2869  /********************************/
2870 
2871  struct MALP_Trace_Event otf_event;
2872 
2873  uint64_t _begin = Timer_tsc ();
2874 
2877  {
2878 
2879  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2880  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2881  MALP_EVENT_MPI, _container.event.mpi_event.type );
2882  Event_Packer_push(&otf_event);
2883  }
2884 
2885  /********************************/
2886  /* ACTUAL FUNCTION CALL */
2887  /********************************/
2888 
2890  int ret = PMPI_Cart_sub( comm, remain_dims, new_comm );
2892 
2893  /********************************/
2894  /* EMIT OTF END */
2895  /********************************/
2896 
2897  uint64_t _end = Timer_tsc();
2898  uint64_t _duration = _end - _begin;
2899 
2901  {
2903  {
2904 
2905  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
2906  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
2907  MALP_EVENT_MPI, _container.event.mpi_event.type );
2908 
2909 
2910  Event_Packer_push(&otf_event);
2911  }
2912 
2913  /********************************/
2914  /* EMIT MALP EVENT */
2915  /********************************/
2916 
2917  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
2918 
2919  /* Submit event if MPI instrumented */
2920  Event_Packer_push(&_container);
2921  }
2922 
2923 
2924  return ret;
2925 }
2926 int MPI_Cartdim_get( MPI_Comm comm, int * ndims )
2927 {
2928 
2929  /* Virtualize MPI */
2930  MACRO_MPI_Comm (comm)
2931 
2932  /* Pre instrum */
2933  int _rank = Stream_desc_get()->mpi_rank;
2934 
2935  struct MALP_Trace_Event _container;
2936 
2937  /********************************/
2938  /* FILL MPI EVENT */
2939  /********************************/
2940 
2941  _container.event.mpi_event.type =
2942  T_MPI_ENUM(MPI_CARTDIM_GET)
2943  ;
2944 
2945  /* Set default source & dest before override */
2946  _container.event.mpi_event.source = _rank;
2947  _container.event.mpi_event.dest = _rank;
2948 
2949 
2950 
2951 
2952 
2953 
2954  SET_COMM (comm)
2955 
2956  /* Fill in size informations if needed */
2957  int _size = 0;
2958  #if 0
2959 
2960  #endif
2961  _container.event.mpi_event.size = _size;
2962 
2963  /********************************/
2964  /* EMIT OTF ENTER */
2965  /********************************/
2966 
2967  struct MALP_Trace_Event otf_event;
2968 
2969  uint64_t _begin = Timer_tsc ();
2970 
2973  {
2974 
2975  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
2976  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
2977  MALP_EVENT_MPI, _container.event.mpi_event.type );
2978  Event_Packer_push(&otf_event);
2979  }
2980 
2981  /********************************/
2982  /* ACTUAL FUNCTION CALL */
2983  /********************************/
2984 
2986  int ret = PMPI_Cartdim_get( comm, ndims );
2988 
2989  /********************************/
2990  /* EMIT OTF END */
2991  /********************************/
2992 
2993  uint64_t _end = Timer_tsc();
2994  uint64_t _duration = _end - _begin;
2995 
2997  {
2999  {
3000 
3001  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3002  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3003  MALP_EVENT_MPI, _container.event.mpi_event.type );
3004 
3005 
3006  Event_Packer_push(&otf_event);
3007  }
3008 
3009  /********************************/
3010  /* EMIT MALP EVENT */
3011  /********************************/
3012 
3013  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3014 
3015  /* Submit event if MPI instrumented */
3016  Event_Packer_push(&_container);
3017  }
3018 
3019 
3020  return ret;
3021 }
3022 int MPI_Close_port( char * port_name )
3023 {
3024 
3025  /* Virtualize MPI */
3026 
3027 
3028  /* Pre instrum */
3029  int _rank = Stream_desc_get()->mpi_rank;
3030 
3031  struct MALP_Trace_Event _container;
3032 
3033  /********************************/
3034  /* FILL MPI EVENT */
3035  /********************************/
3036 
3037  _container.event.mpi_event.type =
3038  T_MPI_ENUM(MPI_CLOSE_PORT)
3039  ;
3040 
3041  /* Set default source & dest before override */
3042  _container.event.mpi_event.source = _rank;
3043  _container.event.mpi_event.dest = _rank;
3044 
3045 
3046 
3047 
3048 
3049 
3050 
3051 
3052  /* Fill in size informations if needed */
3053  int _size = 0;
3054  #if 0
3055 
3056  #endif
3057  _container.event.mpi_event.size = _size;
3058 
3059  /********************************/
3060  /* EMIT OTF ENTER */
3061  /********************************/
3062 
3063  struct MALP_Trace_Event otf_event;
3064 
3065  uint64_t _begin = Timer_tsc ();
3066 
3069  {
3070 
3071  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3072  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3073  MALP_EVENT_MPI, _container.event.mpi_event.type );
3074  Event_Packer_push(&otf_event);
3075  }
3076 
3077  /********************************/
3078  /* ACTUAL FUNCTION CALL */
3079  /********************************/
3080 
3082  int ret = PMPI_Close_port( port_name );
3084 
3085  /********************************/
3086  /* EMIT OTF END */
3087  /********************************/
3088 
3089  uint64_t _end = Timer_tsc();
3090  uint64_t _duration = _end - _begin;
3091 
3093  {
3095  {
3096 
3097  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3098  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3099  MALP_EVENT_MPI, _container.event.mpi_event.type );
3100 
3101 
3102  Event_Packer_push(&otf_event);
3103  }
3104 
3105  /********************************/
3106  /* EMIT MALP EVENT */
3107  /********************************/
3108 
3109  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3110 
3111  /* Submit event if MPI instrumented */
3112  Event_Packer_push(&_container);
3113  }
3114 
3115 
3116  return ret;
3117 }
3118 int MPI_Comm_accept( char * port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm * newcomm )
3119 {
3120 
3121  /* Virtualize MPI */
3122  MACRO_MPI_Comm (comm)
3123 
3124  /* Pre instrum */
3125  int _rank = Stream_desc_get()->mpi_rank;
3126 
3127  struct MALP_Trace_Event _container;
3128 
3129  /********************************/
3130  /* FILL MPI EVENT */
3131  /********************************/
3132 
3133  _container.event.mpi_event.type =
3134  T_MPI_ENUM(MPI_COMM_ACCEPT)
3135  ;
3136 
3137  /* Set default source & dest before override */
3138  _container.event.mpi_event.source = _rank;
3139  _container.event.mpi_event.dest = _rank;
3140 
3141 
3142 
3143 
3144 
3145 
3146  SET_COMM (comm)
3147 
3148  /* Fill in size informations if needed */
3149  int _size = 0;
3150  #if 0
3151 
3152  #endif
3153  _container.event.mpi_event.size = _size;
3154 
3155  /********************************/
3156  /* EMIT OTF ENTER */
3157  /********************************/
3158 
3159  struct MALP_Trace_Event otf_event;
3160 
3161  uint64_t _begin = Timer_tsc ();
3162 
3165  {
3166 
3167  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3168  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3169  MALP_EVENT_MPI, _container.event.mpi_event.type );
3170  Event_Packer_push(&otf_event);
3171  }
3172 
3173  /********************************/
3174  /* ACTUAL FUNCTION CALL */
3175  /********************************/
3176 
3178  int ret = PMPI_Comm_accept( port_name, info, root, comm, newcomm );
3180 
3181  /********************************/
3182  /* EMIT OTF END */
3183  /********************************/
3184 
3185  uint64_t _end = Timer_tsc();
3186  uint64_t _duration = _end - _begin;
3187 
3189  {
3191  {
3192 
3193  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3194  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3195  MALP_EVENT_MPI, _container.event.mpi_event.type );
3196 
3197 
3198  Event_Packer_push(&otf_event);
3199  }
3200 
3201  /********************************/
3202  /* EMIT MALP EVENT */
3203  /********************************/
3204 
3205  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3206 
3207  /* Submit event if MPI instrumented */
3208  Event_Packer_push(&_container);
3209  }
3210 
3211 
3212  return ret;
3213 }
3214 int MPI_Comm_c2f( MPI_Comm comm )
3215 {
3216 
3217  /* Virtualize MPI */
3218  MACRO_MPI_Comm (comm)
3219 
3220  /* Pre instrum */
3221  int _rank = Stream_desc_get()->mpi_rank;
3222 
3223  struct MALP_Trace_Event _container;
3224 
3225  /********************************/
3226  /* FILL MPI EVENT */
3227  /********************************/
3228 
3229  _container.event.mpi_event.type =
3230  T_MPI_ENUM(MPI_COMM_C2F)
3231  ;
3232 
3233  /* Set default source & dest before override */
3234  _container.event.mpi_event.source = _rank;
3235  _container.event.mpi_event.dest = _rank;
3236 
3237 
3238 
3239 
3240 
3241 
3242  SET_COMM (comm)
3243 
3244  /* Fill in size informations if needed */
3245  int _size = 0;
3246  #if 0
3247 
3248  #endif
3249  _container.event.mpi_event.size = _size;
3250 
3251  /********************************/
3252  /* EMIT OTF ENTER */
3253  /********************************/
3254 
3255  struct MALP_Trace_Event otf_event;
3256 
3257  uint64_t _begin = Timer_tsc ();
3258 
3261  {
3262 
3263  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3264  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3265  MALP_EVENT_MPI, _container.event.mpi_event.type );
3266  Event_Packer_push(&otf_event);
3267  }
3268 
3269  /********************************/
3270  /* ACTUAL FUNCTION CALL */
3271  /********************************/
3272 
3274  int ret = PMPI_Comm_c2f( comm );
3276 
3277  /********************************/
3278  /* EMIT OTF END */
3279  /********************************/
3280 
3281  uint64_t _end = Timer_tsc();
3282  uint64_t _duration = _end - _begin;
3283 
3285  {
3287  {
3288 
3289  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3290  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3291  MALP_EVENT_MPI, _container.event.mpi_event.type );
3292 
3293 
3294  Event_Packer_push(&otf_event);
3295  }
3296 
3297  /********************************/
3298  /* EMIT MALP EVENT */
3299  /********************************/
3300 
3301  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3302 
3303  /* Submit event if MPI instrumented */
3304  Event_Packer_push(&_container);
3305  }
3306 
3307 
3308  return ret;
3309 }
3310 int MPI_Comm_call_errhandler( MPI_Comm comm, int errorcode )
3311 {
3312 
3313  /* Virtualize MPI */
3314  MACRO_MPI_Comm (comm)
3315 
3316  /* Pre instrum */
3317  int _rank = Stream_desc_get()->mpi_rank;
3318 
3319  struct MALP_Trace_Event _container;
3320 
3321  /********************************/
3322  /* FILL MPI EVENT */
3323  /********************************/
3324 
3325  _container.event.mpi_event.type =
3326  T_MPI_ENUM(MPI_COMM_CALL_ERRHANDLER)
3327  ;
3328 
3329  /* Set default source & dest before override */
3330  _container.event.mpi_event.source = _rank;
3331  _container.event.mpi_event.dest = _rank;
3332 
3333 
3334 
3335 
3336 
3337 
3338  SET_COMM (comm)
3339 
3340  /* Fill in size informations if needed */
3341  int _size = 0;
3342  #if 0
3343 
3344  #endif
3345  _container.event.mpi_event.size = _size;
3346 
3347  /********************************/
3348  /* EMIT OTF ENTER */
3349  /********************************/
3350 
3351  struct MALP_Trace_Event otf_event;
3352 
3353  uint64_t _begin = Timer_tsc ();
3354 
3357  {
3358 
3359  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3360  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3361  MALP_EVENT_MPI, _container.event.mpi_event.type );
3362  Event_Packer_push(&otf_event);
3363  }
3364 
3365  /********************************/
3366  /* ACTUAL FUNCTION CALL */
3367  /********************************/
3368 
3370  int ret = PMPI_Comm_call_errhandler( comm, errorcode );
3372 
3373  /********************************/
3374  /* EMIT OTF END */
3375  /********************************/
3376 
3377  uint64_t _end = Timer_tsc();
3378  uint64_t _duration = _end - _begin;
3379 
3381  {
3383  {
3384 
3385  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3386  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3387  MALP_EVENT_MPI, _container.event.mpi_event.type );
3388 
3389 
3390  Event_Packer_push(&otf_event);
3391  }
3392 
3393  /********************************/
3394  /* EMIT MALP EVENT */
3395  /********************************/
3396 
3397  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3398 
3399  /* Submit event if MPI instrumented */
3400  Event_Packer_push(&_container);
3401  }
3402 
3403 
3404  return ret;
3405 }
3406 int MPI_Comm_compare( MPI_Comm comm1, MPI_Comm comm2, int * result )
3407 {
3408 
3409  /* Virtualize MPI */
3410  MACRO_MPI_Comm (comm1) MACRO_MPI_Comm (comm2)
3411 
3412  /* Pre instrum */
3413  int _rank = Stream_desc_get()->mpi_rank;
3414 
3415  struct MALP_Trace_Event _container;
3416 
3417  /********************************/
3418  /* FILL MPI EVENT */
3419  /********************************/
3420 
3421  _container.event.mpi_event.type =
3422  T_MPI_ENUM(MPI_COMM_COMPARE)
3423  ;
3424 
3425  /* Set default source & dest before override */
3426  _container.event.mpi_event.source = _rank;
3427  _container.event.mpi_event.dest = _rank;
3428 
3429 
3430 
3431 
3432 
3433 
3434 
3435 
3436  /* Fill in size informations if needed */
3437  int _size = 0;
3438  #if 0
3439 
3440  #endif
3441  _container.event.mpi_event.size = _size;
3442 
3443  /********************************/
3444  /* EMIT OTF ENTER */
3445  /********************************/
3446 
3447  struct MALP_Trace_Event otf_event;
3448 
3449  uint64_t _begin = Timer_tsc ();
3450 
3453  {
3454 
3455  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3456  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3457  MALP_EVENT_MPI, _container.event.mpi_event.type );
3458  Event_Packer_push(&otf_event);
3459  }
3460 
3461  /********************************/
3462  /* ACTUAL FUNCTION CALL */
3463  /********************************/
3464 
3466  int ret = PMPI_Comm_compare( comm1, comm2, result );
3468 
3469  /********************************/
3470  /* EMIT OTF END */
3471  /********************************/
3472 
3473  uint64_t _end = Timer_tsc();
3474  uint64_t _duration = _end - _begin;
3475 
3477  {
3479  {
3480 
3481  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3482  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3483  MALP_EVENT_MPI, _container.event.mpi_event.type );
3484 
3485 
3486  Event_Packer_push(&otf_event);
3487  }
3488 
3489  /********************************/
3490  /* EMIT MALP EVENT */
3491  /********************************/
3492 
3493  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3494 
3495  /* Submit event if MPI instrumented */
3496  Event_Packer_push(&_container);
3497  }
3498 
3499 
3500  return ret;
3501 }
3502 int MPI_Comm_connect( char * port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm * newcomm )
3503 {
3504 
3505  /* Virtualize MPI */
3506  MACRO_MPI_Comm (comm)
3507 
3508  /* Pre instrum */
3509  int _rank = Stream_desc_get()->mpi_rank;
3510 
3511  struct MALP_Trace_Event _container;
3512 
3513  /********************************/
3514  /* FILL MPI EVENT */
3515  /********************************/
3516 
3517  _container.event.mpi_event.type =
3518  T_MPI_ENUM(MPI_COMM_CONNECT)
3519  ;
3520 
3521  /* Set default source & dest before override */
3522  _container.event.mpi_event.source = _rank;
3523  _container.event.mpi_event.dest = _rank;
3524 
3525 
3526 
3527 
3528 
3529 
3530  SET_COMM (comm)
3531 
3532  /* Fill in size informations if needed */
3533  int _size = 0;
3534  #if 0
3535 
3536  #endif
3537  _container.event.mpi_event.size = _size;
3538 
3539  /********************************/
3540  /* EMIT OTF ENTER */
3541  /********************************/
3542 
3543  struct MALP_Trace_Event otf_event;
3544 
3545  uint64_t _begin = Timer_tsc ();
3546 
3549  {
3550 
3551  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3552  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3553  MALP_EVENT_MPI, _container.event.mpi_event.type );
3554  Event_Packer_push(&otf_event);
3555  }
3556 
3557  /********************************/
3558  /* ACTUAL FUNCTION CALL */
3559  /********************************/
3560 
3562  int ret = PMPI_Comm_connect( port_name, info, root, comm, newcomm );
3564 
3565  /********************************/
3566  /* EMIT OTF END */
3567  /********************************/
3568 
3569  uint64_t _end = Timer_tsc();
3570  uint64_t _duration = _end - _begin;
3571 
3573  {
3575  {
3576 
3577  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3578  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3579  MALP_EVENT_MPI, _container.event.mpi_event.type );
3580 
3581 
3582  Event_Packer_push(&otf_event);
3583  }
3584 
3585  /********************************/
3586  /* EMIT MALP EVENT */
3587  /********************************/
3588 
3589  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3590 
3591  /* Submit event if MPI instrumented */
3592  Event_Packer_push(&_container);
3593  }
3594 
3595 
3596  return ret;
3597 }
3598 int MPI_Comm_create_errhandler( MPI_Comm_errhandler_function * function, MPI_Errhandler * errhandler )
3599 {
3600 
3601  /* Virtualize MPI */
3602 
3603 
3604  /* Pre instrum */
3605  int _rank = Stream_desc_get()->mpi_rank;
3606 
3607  struct MALP_Trace_Event _container;
3608 
3609  /********************************/
3610  /* FILL MPI EVENT */
3611  /********************************/
3612 
3613  _container.event.mpi_event.type =
3614  T_MPI_ENUM(MPI_COMM_CREATE_ERRHANDLER)
3615  ;
3616 
3617  /* Set default source & dest before override */
3618  _container.event.mpi_event.source = _rank;
3619  _container.event.mpi_event.dest = _rank;
3620 
3621 
3622 
3623 
3624 
3625 
3626 
3627 
3628  /* Fill in size informations if needed */
3629  int _size = 0;
3630  #if 0
3631 
3632  #endif
3633  _container.event.mpi_event.size = _size;
3634 
3635  /********************************/
3636  /* EMIT OTF ENTER */
3637  /********************************/
3638 
3639  struct MALP_Trace_Event otf_event;
3640 
3641  uint64_t _begin = Timer_tsc ();
3642 
3645  {
3646 
3647  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3648  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3649  MALP_EVENT_MPI, _container.event.mpi_event.type );
3650  Event_Packer_push(&otf_event);
3651  }
3652 
3653  /********************************/
3654  /* ACTUAL FUNCTION CALL */
3655  /********************************/
3656 
3658  int ret = PMPI_Comm_create_errhandler( function, errhandler );
3660 
3661  /********************************/
3662  /* EMIT OTF END */
3663  /********************************/
3664 
3665  uint64_t _end = Timer_tsc();
3666  uint64_t _duration = _end - _begin;
3667 
3669  {
3671  {
3672 
3673  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3674  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3675  MALP_EVENT_MPI, _container.event.mpi_event.type );
3676 
3677 
3678  Event_Packer_push(&otf_event);
3679  }
3680 
3681  /********************************/
3682  /* EMIT MALP EVENT */
3683  /********************************/
3684 
3685  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3686 
3687  /* Submit event if MPI instrumented */
3688  Event_Packer_push(&_container);
3689  }
3690 
3691 
3692  return ret;
3693 }
3694 int MPI_Comm_create_keyval( MPI_Comm_copy_attr_function * comm_copy_attr_fn, MPI_Comm_delete_attr_function * comm_delete_attr_fn, int * comm_keyval, void * extra_state )
3695 {
3696 
3697  /* Virtualize MPI */
3698 
3699 
3700  /* Pre instrum */
3701  int _rank = Stream_desc_get()->mpi_rank;
3702 
3703  struct MALP_Trace_Event _container;
3704 
3705  /********************************/
3706  /* FILL MPI EVENT */
3707  /********************************/
3708 
3709  _container.event.mpi_event.type =
3710  T_MPI_ENUM(MPI_COMM_CREATE_KEYVAL)
3711  ;
3712 
3713  /* Set default source & dest before override */
3714  _container.event.mpi_event.source = _rank;
3715  _container.event.mpi_event.dest = _rank;
3716 
3717 
3718 
3719 
3720 
3721 
3722 
3723 
3724  /* Fill in size informations if needed */
3725  int _size = 0;
3726  #if 0
3727 
3728  #endif
3729  _container.event.mpi_event.size = _size;
3730 
3731  /********************************/
3732  /* EMIT OTF ENTER */
3733  /********************************/
3734 
3735  struct MALP_Trace_Event otf_event;
3736 
3737  uint64_t _begin = Timer_tsc ();
3738 
3741  {
3742 
3743  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3744  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3745  MALP_EVENT_MPI, _container.event.mpi_event.type );
3746  Event_Packer_push(&otf_event);
3747  }
3748 
3749  /********************************/
3750  /* ACTUAL FUNCTION CALL */
3751  /********************************/
3752 
3754  int ret = PMPI_Comm_create_keyval( comm_copy_attr_fn, comm_delete_attr_fn, comm_keyval, extra_state );
3756 
3757  /********************************/
3758  /* EMIT OTF END */
3759  /********************************/
3760 
3761  uint64_t _end = Timer_tsc();
3762  uint64_t _duration = _end - _begin;
3763 
3765  {
3767  {
3768 
3769  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3770  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3771  MALP_EVENT_MPI, _container.event.mpi_event.type );
3772 
3773 
3774  Event_Packer_push(&otf_event);
3775  }
3776 
3777  /********************************/
3778  /* EMIT MALP EVENT */
3779  /********************************/
3780 
3781  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3782 
3783  /* Submit event if MPI instrumented */
3784  Event_Packer_push(&_container);
3785  }
3786 
3787 
3788  return ret;
3789 }
3790 int MPI_Comm_create( MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm )
3791 {
3792 
3793  /* Virtualize MPI */
3794  MACRO_MPI_Comm (comm)
3795 
3796  /* Pre instrum */
3797  int _rank = Stream_desc_get()->mpi_rank;
3798 
3799  struct MALP_Trace_Event _container;
3800 
3801  /********************************/
3802  /* FILL MPI EVENT */
3803  /********************************/
3804 
3805  _container.event.mpi_event.type =
3806  T_MPI_ENUM(MPI_COMM_CREATE)
3807  ;
3808 
3809  /* Set default source & dest before override */
3810  _container.event.mpi_event.source = _rank;
3811  _container.event.mpi_event.dest = _rank;
3812 
3813 
3814 
3815 
3816 
3817 
3818  SET_COMM (comm)
3819 
3820  /* Fill in size informations if needed */
3821  int _size = 0;
3822  #if 0
3823 
3824  #endif
3825  _container.event.mpi_event.size = _size;
3826 
3827  /********************************/
3828  /* EMIT OTF ENTER */
3829  /********************************/
3830 
3831  struct MALP_Trace_Event otf_event;
3832 
3833  uint64_t _begin = Timer_tsc ();
3834 
3837  {
3838 
3839  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3840  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3841  MALP_EVENT_MPI, _container.event.mpi_event.type );
3842  Event_Packer_push(&otf_event);
3843  }
3844 
3845  /********************************/
3846  /* ACTUAL FUNCTION CALL */
3847  /********************************/
3848 
3850  int ret = PMPI_Comm_create( comm, group, newcomm );
3852 
3853  /********************************/
3854  /* EMIT OTF END */
3855  /********************************/
3856 
3857  uint64_t _end = Timer_tsc();
3858  uint64_t _duration = _end - _begin;
3859 
3861  {
3863  {
3864 
3865  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3866  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3867  MALP_EVENT_MPI, _container.event.mpi_event.type );
3868 
3869 
3870  Event_Packer_push(&otf_event);
3871  }
3872 
3873  /********************************/
3874  /* EMIT MALP EVENT */
3875  /********************************/
3876 
3877  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3878 
3879  /* Submit event if MPI instrumented */
3880  Event_Packer_push(&_container);
3881  }
3882 
3883 
3884  return ret;
3885 }
3886 int MPI_Comm_delete_attr( MPI_Comm comm, int comm_keyval )
3887 {
3888 
3889  /* Virtualize MPI */
3890  MACRO_MPI_Comm (comm)
3891 
3892  /* Pre instrum */
3893  int _rank = Stream_desc_get()->mpi_rank;
3894 
3895  struct MALP_Trace_Event _container;
3896 
3897  /********************************/
3898  /* FILL MPI EVENT */
3899  /********************************/
3900 
3901  _container.event.mpi_event.type =
3902  T_MPI_ENUM(MPI_COMM_DELETE_ATTR)
3903  ;
3904 
3905  /* Set default source & dest before override */
3906  _container.event.mpi_event.source = _rank;
3907  _container.event.mpi_event.dest = _rank;
3908 
3909 
3910 
3911 
3912 
3913 
3914  SET_COMM (comm)
3915 
3916  /* Fill in size informations if needed */
3917  int _size = 0;
3918  #if 0
3919 
3920  #endif
3921  _container.event.mpi_event.size = _size;
3922 
3923  /********************************/
3924  /* EMIT OTF ENTER */
3925  /********************************/
3926 
3927  struct MALP_Trace_Event otf_event;
3928 
3929  uint64_t _begin = Timer_tsc ();
3930 
3933  {
3934 
3935  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
3936  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
3937  MALP_EVENT_MPI, _container.event.mpi_event.type );
3938  Event_Packer_push(&otf_event);
3939  }
3940 
3941  /********************************/
3942  /* ACTUAL FUNCTION CALL */
3943  /********************************/
3944 
3946  int ret = PMPI_Comm_delete_attr( comm, comm_keyval );
3948 
3949  /********************************/
3950  /* EMIT OTF END */
3951  /********************************/
3952 
3953  uint64_t _end = Timer_tsc();
3954  uint64_t _duration = _end - _begin;
3955 
3957  {
3959  {
3960 
3961  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
3962  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
3963  MALP_EVENT_MPI, _container.event.mpi_event.type );
3964 
3965 
3966  Event_Packer_push(&otf_event);
3967  }
3968 
3969  /********************************/
3970  /* EMIT MALP EVENT */
3971  /********************************/
3972 
3973  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
3974 
3975  /* Submit event if MPI instrumented */
3976  Event_Packer_push(&_container);
3977  }
3978 
3979 
3980  return ret;
3981 }
3982 int MPI_Comm_disconnect( MPI_Comm * comm )
3983 {
3984 
3985  /* Virtualize MPI */
3986 
3987 
3988  /* Pre instrum */
3989  int _rank = Stream_desc_get()->mpi_rank;
3990 
3991  struct MALP_Trace_Event _container;
3992 
3993  /********************************/
3994  /* FILL MPI EVENT */
3995  /********************************/
3996 
3997  _container.event.mpi_event.type =
3998  T_MPI_ENUM(MPI_COMM_DISCONNECT)
3999  ;
4000 
4001  /* Set default source & dest before override */
4002  _container.event.mpi_event.source = _rank;
4003  _container.event.mpi_event.dest = _rank;
4004 
4005 
4006 
4007 
4008 
4009 
4010 
4011 
4012  /* Fill in size informations if needed */
4013  int _size = 0;
4014  #if 0
4015 
4016  #endif
4017  _container.event.mpi_event.size = _size;
4018 
4019  /********************************/
4020  /* EMIT OTF ENTER */
4021  /********************************/
4022 
4023  struct MALP_Trace_Event otf_event;
4024 
4025  uint64_t _begin = Timer_tsc ();
4026 
4029  {
4030 
4031  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4032  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4033  MALP_EVENT_MPI, _container.event.mpi_event.type );
4034  Event_Packer_push(&otf_event);
4035  }
4036 
4037  /********************************/
4038  /* ACTUAL FUNCTION CALL */
4039  /********************************/
4040 
4042  int ret = PMPI_Comm_disconnect( comm );
4044 
4045  /********************************/
4046  /* EMIT OTF END */
4047  /********************************/
4048 
4049  uint64_t _end = Timer_tsc();
4050  uint64_t _duration = _end - _begin;
4051 
4053  {
4055  {
4056 
4057  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4058  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4059  MALP_EVENT_MPI, _container.event.mpi_event.type );
4060 
4061 
4062  Event_Packer_push(&otf_event);
4063  }
4064 
4065  /********************************/
4066  /* EMIT MALP EVENT */
4067  /********************************/
4068 
4069  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4070 
4071  /* Submit event if MPI instrumented */
4072  Event_Packer_push(&_container);
4073  }
4074 
4075 
4076  return ret;
4077 }
4078 int MPI_Comm_dup( MPI_Comm comm, MPI_Comm * newcomm )
4079 {
4080 
4081  /* Virtualize MPI */
4082  MACRO_MPI_Comm (comm)
4083 
4084  /* Pre instrum */
4085  int _rank = Stream_desc_get()->mpi_rank;
4086 
4087  struct MALP_Trace_Event _container;
4088 
4089  /********************************/
4090  /* FILL MPI EVENT */
4091  /********************************/
4092 
4093  _container.event.mpi_event.type =
4094  T_MPI_ENUM(MPI_COMM_DUP)
4095  ;
4096 
4097  /* Set default source & dest before override */
4098  _container.event.mpi_event.source = _rank;
4099  _container.event.mpi_event.dest = _rank;
4100 
4101 
4102 
4103 
4104 
4105 
4106  SET_COMM (comm)
4107 
4108  /* Fill in size informations if needed */
4109  int _size = 0;
4110  #if 0
4111 
4112  #endif
4113  _container.event.mpi_event.size = _size;
4114 
4115  /********************************/
4116  /* EMIT OTF ENTER */
4117  /********************************/
4118 
4119  struct MALP_Trace_Event otf_event;
4120 
4121  uint64_t _begin = Timer_tsc ();
4122 
4125  {
4126 
4127  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4128  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4129  MALP_EVENT_MPI, _container.event.mpi_event.type );
4130  Event_Packer_push(&otf_event);
4131  }
4132 
4133  /********************************/
4134  /* ACTUAL FUNCTION CALL */
4135  /********************************/
4136 
4138  int ret = PMPI_Comm_dup( comm, newcomm );
4140 
4141  /********************************/
4142  /* EMIT OTF END */
4143  /********************************/
4144 
4145  uint64_t _end = Timer_tsc();
4146  uint64_t _duration = _end - _begin;
4147 
4149  {
4151  {
4152 
4153  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4154  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4155  MALP_EVENT_MPI, _container.event.mpi_event.type );
4156 
4157 
4158  Event_Packer_push(&otf_event);
4159  }
4160 
4161  /********************************/
4162  /* EMIT MALP EVENT */
4163  /********************************/
4164 
4165  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4166 
4167  /* Submit event if MPI instrumented */
4168  Event_Packer_push(&_container);
4169  }
4170 
4171 
4172  return ret;
4173 }
4174 int MPI_Comm_free_keyval( int * comm_keyval )
4175 {
4176 
4177  /* Virtualize MPI */
4178 
4179 
4180  /* Pre instrum */
4181  int _rank = Stream_desc_get()->mpi_rank;
4182 
4183  struct MALP_Trace_Event _container;
4184 
4185  /********************************/
4186  /* FILL MPI EVENT */
4187  /********************************/
4188 
4189  _container.event.mpi_event.type =
4190  T_MPI_ENUM(MPI_COMM_FREE_KEYVAL)
4191  ;
4192 
4193  /* Set default source & dest before override */
4194  _container.event.mpi_event.source = _rank;
4195  _container.event.mpi_event.dest = _rank;
4196 
4197 
4198 
4199 
4200 
4201 
4202 
4203 
4204  /* Fill in size informations if needed */
4205  int _size = 0;
4206  #if 0
4207 
4208  #endif
4209  _container.event.mpi_event.size = _size;
4210 
4211  /********************************/
4212  /* EMIT OTF ENTER */
4213  /********************************/
4214 
4215  struct MALP_Trace_Event otf_event;
4216 
4217  uint64_t _begin = Timer_tsc ();
4218 
4221  {
4222 
4223  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4224  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4225  MALP_EVENT_MPI, _container.event.mpi_event.type );
4226  Event_Packer_push(&otf_event);
4227  }
4228 
4229  /********************************/
4230  /* ACTUAL FUNCTION CALL */
4231  /********************************/
4232 
4234  int ret = PMPI_Comm_free_keyval( comm_keyval );
4236 
4237  /********************************/
4238  /* EMIT OTF END */
4239  /********************************/
4240 
4241  uint64_t _end = Timer_tsc();
4242  uint64_t _duration = _end - _begin;
4243 
4245  {
4247  {
4248 
4249  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4250  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4251  MALP_EVENT_MPI, _container.event.mpi_event.type );
4252 
4253 
4254  Event_Packer_push(&otf_event);
4255  }
4256 
4257  /********************************/
4258  /* EMIT MALP EVENT */
4259  /********************************/
4260 
4261  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4262 
4263  /* Submit event if MPI instrumented */
4264  Event_Packer_push(&_container);
4265  }
4266 
4267 
4268  return ret;
4269 }
4270 int MPI_Comm_free( MPI_Comm * comm )
4271 {
4272 
4273  /* Virtualize MPI */
4274 
4275 
4276  /* Pre instrum */
4277  int _rank = Stream_desc_get()->mpi_rank;
4278 
4279  struct MALP_Trace_Event _container;
4280 
4281  /********************************/
4282  /* FILL MPI EVENT */
4283  /********************************/
4284 
4285  _container.event.mpi_event.type =
4286  T_MPI_ENUM(MPI_COMM_FREE)
4287  ;
4288 
4289  /* Set default source & dest before override */
4290  _container.event.mpi_event.source = _rank;
4291  _container.event.mpi_event.dest = _rank;
4292 
4293 
4294 
4295 
4296 
4297 
4298 
4299 
4300  /* Fill in size informations if needed */
4301  int _size = 0;
4302  #if 0
4303 
4304  #endif
4305  _container.event.mpi_event.size = _size;
4306 
4307  /********************************/
4308  /* EMIT OTF ENTER */
4309  /********************************/
4310 
4311  struct MALP_Trace_Event otf_event;
4312 
4313  uint64_t _begin = Timer_tsc ();
4314 
4317  {
4318 
4319  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4320  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4321  MALP_EVENT_MPI, _container.event.mpi_event.type );
4322  Event_Packer_push(&otf_event);
4323  }
4324 
4325  /********************************/
4326  /* ACTUAL FUNCTION CALL */
4327  /********************************/
4328 
4330  int ret = PMPI_Comm_free( comm );
4332 
4333  /********************************/
4334  /* EMIT OTF END */
4335  /********************************/
4336 
4337  uint64_t _end = Timer_tsc();
4338  uint64_t _duration = _end - _begin;
4339 
4341  {
4343  {
4344 
4345  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4346  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4347  MALP_EVENT_MPI, _container.event.mpi_event.type );
4348 
4349 
4350  Event_Packer_push(&otf_event);
4351  }
4352 
4353  /********************************/
4354  /* EMIT MALP EVENT */
4355  /********************************/
4356 
4357  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4358 
4359  /* Submit event if MPI instrumented */
4360  Event_Packer_push(&_container);
4361  }
4362 
4363 
4364  return ret;
4365 }
4366 int MPI_Comm_get_attr( MPI_Comm comm, int comm_keyval, void * attribute_val, int * flag )
4367 {
4368 
4369  /* Virtualize MPI */
4370  MACRO_MPI_Comm (comm)
4371 
4372  /* Pre instrum */
4373  int _rank = Stream_desc_get()->mpi_rank;
4374 
4375  struct MALP_Trace_Event _container;
4376 
4377  /********************************/
4378  /* FILL MPI EVENT */
4379  /********************************/
4380 
4381  _container.event.mpi_event.type =
4382  T_MPI_ENUM(MPI_COMM_GET_ATTR)
4383  ;
4384 
4385  /* Set default source & dest before override */
4386  _container.event.mpi_event.source = _rank;
4387  _container.event.mpi_event.dest = _rank;
4388 
4389 
4390 
4391 
4392 
4393 
4394  SET_COMM (comm)
4395 
4396  /* Fill in size informations if needed */
4397  int _size = 0;
4398  #if 0
4399 
4400  #endif
4401  _container.event.mpi_event.size = _size;
4402 
4403  /********************************/
4404  /* EMIT OTF ENTER */
4405  /********************************/
4406 
4407  struct MALP_Trace_Event otf_event;
4408 
4409  uint64_t _begin = Timer_tsc ();
4410 
4413  {
4414 
4415  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4416  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4417  MALP_EVENT_MPI, _container.event.mpi_event.type );
4418  Event_Packer_push(&otf_event);
4419  }
4420 
4421  /********************************/
4422  /* ACTUAL FUNCTION CALL */
4423  /********************************/
4424 
4426  int ret = PMPI_Comm_get_attr( comm, comm_keyval, attribute_val, flag );
4428 
4429  /********************************/
4430  /* EMIT OTF END */
4431  /********************************/
4432 
4433  uint64_t _end = Timer_tsc();
4434  uint64_t _duration = _end - _begin;
4435 
4437  {
4439  {
4440 
4441  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4442  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4443  MALP_EVENT_MPI, _container.event.mpi_event.type );
4444 
4445 
4446  Event_Packer_push(&otf_event);
4447  }
4448 
4449  /********************************/
4450  /* EMIT MALP EVENT */
4451  /********************************/
4452 
4453  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4454 
4455  /* Submit event if MPI instrumented */
4456  Event_Packer_push(&_container);
4457  }
4458 
4459 
4460  return ret;
4461 }
4462 int MPI_Comm_get_errhandler( MPI_Comm comm, MPI_Errhandler * erhandler )
4463 {
4464 
4465  /* Virtualize MPI */
4466  MACRO_MPI_Comm (comm)
4467 
4468  /* Pre instrum */
4469  int _rank = Stream_desc_get()->mpi_rank;
4470 
4471  struct MALP_Trace_Event _container;
4472 
4473  /********************************/
4474  /* FILL MPI EVENT */
4475  /********************************/
4476 
4477  _container.event.mpi_event.type =
4478  T_MPI_ENUM(MPI_COMM_GET_ERRHANDLER)
4479  ;
4480 
4481  /* Set default source & dest before override */
4482  _container.event.mpi_event.source = _rank;
4483  _container.event.mpi_event.dest = _rank;
4484 
4485 
4486 
4487 
4488 
4489 
4490  SET_COMM (comm)
4491 
4492  /* Fill in size informations if needed */
4493  int _size = 0;
4494  #if 0
4495 
4496  #endif
4497  _container.event.mpi_event.size = _size;
4498 
4499  /********************************/
4500  /* EMIT OTF ENTER */
4501  /********************************/
4502 
4503  struct MALP_Trace_Event otf_event;
4504 
4505  uint64_t _begin = Timer_tsc ();
4506 
4509  {
4510 
4511  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4512  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4513  MALP_EVENT_MPI, _container.event.mpi_event.type );
4514  Event_Packer_push(&otf_event);
4515  }
4516 
4517  /********************************/
4518  /* ACTUAL FUNCTION CALL */
4519  /********************************/
4520 
4522  int ret = PMPI_Comm_get_errhandler( comm, erhandler );
4524 
4525  /********************************/
4526  /* EMIT OTF END */
4527  /********************************/
4528 
4529  uint64_t _end = Timer_tsc();
4530  uint64_t _duration = _end - _begin;
4531 
4533  {
4535  {
4536 
4537  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4538  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4539  MALP_EVENT_MPI, _container.event.mpi_event.type );
4540 
4541 
4542  Event_Packer_push(&otf_event);
4543  }
4544 
4545  /********************************/
4546  /* EMIT MALP EVENT */
4547  /********************************/
4548 
4549  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4550 
4551  /* Submit event if MPI instrumented */
4552  Event_Packer_push(&_container);
4553  }
4554 
4555 
4556  return ret;
4557 }
4558 int MPI_Comm_get_name( MPI_Comm comm, char * comm_name, int * resultlen )
4559 {
4560 
4561  /* Virtualize MPI */
4562  MACRO_MPI_Comm (comm)
4563 
4564  /* Pre instrum */
4565  int _rank = Stream_desc_get()->mpi_rank;
4566 
4567  struct MALP_Trace_Event _container;
4568 
4569  /********************************/
4570  /* FILL MPI EVENT */
4571  /********************************/
4572 
4573  _container.event.mpi_event.type =
4574  T_MPI_ENUM(MPI_COMM_GET_NAME)
4575  ;
4576 
4577  /* Set default source & dest before override */
4578  _container.event.mpi_event.source = _rank;
4579  _container.event.mpi_event.dest = _rank;
4580 
4581 
4582 
4583 
4584 
4585 
4586  SET_COMM (comm)
4587 
4588  /* Fill in size informations if needed */
4589  int _size = 0;
4590  #if 0
4591 
4592  #endif
4593  _container.event.mpi_event.size = _size;
4594 
4595  /********************************/
4596  /* EMIT OTF ENTER */
4597  /********************************/
4598 
4599  struct MALP_Trace_Event otf_event;
4600 
4601  uint64_t _begin = Timer_tsc ();
4602 
4605  {
4606 
4607  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4608  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4609  MALP_EVENT_MPI, _container.event.mpi_event.type );
4610  Event_Packer_push(&otf_event);
4611  }
4612 
4613  /********************************/
4614  /* ACTUAL FUNCTION CALL */
4615  /********************************/
4616 
4618  int ret = PMPI_Comm_get_name( comm, comm_name, resultlen );
4620 
4621  /********************************/
4622  /* EMIT OTF END */
4623  /********************************/
4624 
4625  uint64_t _end = Timer_tsc();
4626  uint64_t _duration = _end - _begin;
4627 
4629  {
4631  {
4632 
4633  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4634  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4635  MALP_EVENT_MPI, _container.event.mpi_event.type );
4636 
4637 
4638  Event_Packer_push(&otf_event);
4639  }
4640 
4641  /********************************/
4642  /* EMIT MALP EVENT */
4643  /********************************/
4644 
4645  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4646 
4647  /* Submit event if MPI instrumented */
4648  Event_Packer_push(&_container);
4649  }
4650 
4651 
4652  return ret;
4653 }
4654 int MPI_Comm_get_parent( MPI_Comm * parent )
4655 {
4656 
4657  /* Virtualize MPI */
4658 
4659 
4660  /* Pre instrum */
4661  int _rank = Stream_desc_get()->mpi_rank;
4662 
4663  struct MALP_Trace_Event _container;
4664 
4665  /********************************/
4666  /* FILL MPI EVENT */
4667  /********************************/
4668 
4669  _container.event.mpi_event.type =
4670  T_MPI_ENUM(MPI_COMM_GET_PARENT)
4671  ;
4672 
4673  /* Set default source & dest before override */
4674  _container.event.mpi_event.source = _rank;
4675  _container.event.mpi_event.dest = _rank;
4676 
4677 
4678 
4679 
4680 
4681 
4682 
4683 
4684  /* Fill in size informations if needed */
4685  int _size = 0;
4686  #if 0
4687 
4688  #endif
4689  _container.event.mpi_event.size = _size;
4690 
4691  /********************************/
4692  /* EMIT OTF ENTER */
4693  /********************************/
4694 
4695  struct MALP_Trace_Event otf_event;
4696 
4697  uint64_t _begin = Timer_tsc ();
4698 
4701  {
4702 
4703  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4704  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4705  MALP_EVENT_MPI, _container.event.mpi_event.type );
4706  Event_Packer_push(&otf_event);
4707  }
4708 
4709  /********************************/
4710  /* ACTUAL FUNCTION CALL */
4711  /********************************/
4712 
4714  int ret = PMPI_Comm_get_parent( parent );
4716 
4717  /********************************/
4718  /* EMIT OTF END */
4719  /********************************/
4720 
4721  uint64_t _end = Timer_tsc();
4722  uint64_t _duration = _end - _begin;
4723 
4725  {
4727  {
4728 
4729  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4730  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4731  MALP_EVENT_MPI, _container.event.mpi_event.type );
4732 
4733 
4734  Event_Packer_push(&otf_event);
4735  }
4736 
4737  /********************************/
4738  /* EMIT MALP EVENT */
4739  /********************************/
4740 
4741  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4742 
4743  /* Submit event if MPI instrumented */
4744  Event_Packer_push(&_container);
4745  }
4746 
4747 
4748  return ret;
4749 }
4750 int MPI_Comm_group( MPI_Comm comm, MPI_Group * group )
4751 {
4752 
4753  /* Virtualize MPI */
4754  MACRO_MPI_Comm (comm)
4755 
4756  /* Pre instrum */
4757  int _rank = Stream_desc_get()->mpi_rank;
4758 
4759  struct MALP_Trace_Event _container;
4760 
4761  /********************************/
4762  /* FILL MPI EVENT */
4763  /********************************/
4764 
4765  _container.event.mpi_event.type =
4766  T_MPI_ENUM(MPI_COMM_GROUP)
4767  ;
4768 
4769  /* Set default source & dest before override */
4770  _container.event.mpi_event.source = _rank;
4771  _container.event.mpi_event.dest = _rank;
4772 
4773 
4774 
4775 
4776 
4777 
4778  SET_COMM (comm)
4779 
4780  /* Fill in size informations if needed */
4781  int _size = 0;
4782  #if 0
4783 
4784  #endif
4785  _container.event.mpi_event.size = _size;
4786 
4787  /********************************/
4788  /* EMIT OTF ENTER */
4789  /********************************/
4790 
4791  struct MALP_Trace_Event otf_event;
4792 
4793  uint64_t _begin = Timer_tsc ();
4794 
4797  {
4798 
4799  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4800  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4801  MALP_EVENT_MPI, _container.event.mpi_event.type );
4802  Event_Packer_push(&otf_event);
4803  }
4804 
4805  /********************************/
4806  /* ACTUAL FUNCTION CALL */
4807  /********************************/
4808 
4810  int ret = PMPI_Comm_group( comm, group );
4812 
4813  /********************************/
4814  /* EMIT OTF END */
4815  /********************************/
4816 
4817  uint64_t _end = Timer_tsc();
4818  uint64_t _duration = _end - _begin;
4819 
4821  {
4823  {
4824 
4825  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4826  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4827  MALP_EVENT_MPI, _container.event.mpi_event.type );
4828 
4829 
4830  Event_Packer_push(&otf_event);
4831  }
4832 
4833  /********************************/
4834  /* EMIT MALP EVENT */
4835  /********************************/
4836 
4837  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4838 
4839  /* Submit event if MPI instrumented */
4840  Event_Packer_push(&_container);
4841  }
4842 
4843 
4844  return ret;
4845 }
4846 int MPI_Comm_join( int fd, MPI_Comm * intercomm )
4847 {
4848 
4849  /* Virtualize MPI */
4850 
4851 
4852  /* Pre instrum */
4853  int _rank = Stream_desc_get()->mpi_rank;
4854 
4855  struct MALP_Trace_Event _container;
4856 
4857  /********************************/
4858  /* FILL MPI EVENT */
4859  /********************************/
4860 
4861  _container.event.mpi_event.type =
4862  T_MPI_ENUM(MPI_COMM_JOIN)
4863  ;
4864 
4865  /* Set default source & dest before override */
4866  _container.event.mpi_event.source = _rank;
4867  _container.event.mpi_event.dest = _rank;
4868 
4869 
4870 
4871 
4872 
4873 
4874 
4875 
4876  /* Fill in size informations if needed */
4877  int _size = 0;
4878  #if 0
4879 
4880  #endif
4881  _container.event.mpi_event.size = _size;
4882 
4883  /********************************/
4884  /* EMIT OTF ENTER */
4885  /********************************/
4886 
4887  struct MALP_Trace_Event otf_event;
4888 
4889  uint64_t _begin = Timer_tsc ();
4890 
4893  {
4894 
4895  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4896  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4897  MALP_EVENT_MPI, _container.event.mpi_event.type );
4898  Event_Packer_push(&otf_event);
4899  }
4900 
4901  /********************************/
4902  /* ACTUAL FUNCTION CALL */
4903  /********************************/
4904 
4906  int ret = PMPI_Comm_join( fd, intercomm );
4908 
4909  /********************************/
4910  /* EMIT OTF END */
4911  /********************************/
4912 
4913  uint64_t _end = Timer_tsc();
4914  uint64_t _duration = _end - _begin;
4915 
4917  {
4919  {
4920 
4921  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
4922  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
4923  MALP_EVENT_MPI, _container.event.mpi_event.type );
4924 
4925 
4926  Event_Packer_push(&otf_event);
4927  }
4928 
4929  /********************************/
4930  /* EMIT MALP EVENT */
4931  /********************************/
4932 
4933  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
4934 
4935  /* Submit event if MPI instrumented */
4936  Event_Packer_push(&_container);
4937  }
4938 
4939 
4940  return ret;
4941 }
4942 int MPI_Comm_rank( MPI_Comm comm, int * rank )
4943 {
4944 
4945  /* Virtualize MPI */
4946  MACRO_MPI_Comm (comm)
4947 
4948  /* Pre instrum */
4949  int _rank = Stream_desc_get()->mpi_rank;
4950 
4951  struct MALP_Trace_Event _container;
4952 
4953  /********************************/
4954  /* FILL MPI EVENT */
4955  /********************************/
4956 
4957  _container.event.mpi_event.type =
4958  T_MPI_ENUM(MPI_COMM_RANK)
4959  ;
4960 
4961  /* Set default source & dest before override */
4962  _container.event.mpi_event.source = _rank;
4963  _container.event.mpi_event.dest = _rank;
4964 
4965 
4966 
4967 
4968 
4969 
4970  SET_COMM (comm)
4971 
4972  /* Fill in size informations if needed */
4973  int _size = 0;
4974  #if 0
4975 
4976  #endif
4977  _container.event.mpi_event.size = _size;
4978 
4979  /********************************/
4980  /* EMIT OTF ENTER */
4981  /********************************/
4982 
4983  struct MALP_Trace_Event otf_event;
4984 
4985  uint64_t _begin = Timer_tsc ();
4986 
4989  {
4990 
4991  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
4992  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
4993  MALP_EVENT_MPI, _container.event.mpi_event.type );
4994  Event_Packer_push(&otf_event);
4995  }
4996 
4997  /********************************/
4998  /* ACTUAL FUNCTION CALL */
4999  /********************************/
5000 
5002  int ret = PMPI_Comm_rank( comm, rank );
5004 
5005  /********************************/
5006  /* EMIT OTF END */
5007  /********************************/
5008 
5009  uint64_t _end = Timer_tsc();
5010  uint64_t _duration = _end - _begin;
5011 
5013  {
5015  {
5016 
5017  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5018  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5019  MALP_EVENT_MPI, _container.event.mpi_event.type );
5020 
5021 
5022  Event_Packer_push(&otf_event);
5023  }
5024 
5025  /********************************/
5026  /* EMIT MALP EVENT */
5027  /********************************/
5028 
5029  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5030 
5031  /* Submit event if MPI instrumented */
5032  Event_Packer_push(&_container);
5033  }
5034 
5035 
5036  return ret;
5037 }
5038 int MPI_Comm_remote_group( MPI_Comm comm, MPI_Group * group )
5039 {
5040 
5041  /* Virtualize MPI */
5042  MACRO_MPI_Comm (comm)
5043 
5044  /* Pre instrum */
5045  int _rank = Stream_desc_get()->mpi_rank;
5046 
5047  struct MALP_Trace_Event _container;
5048 
5049  /********************************/
5050  /* FILL MPI EVENT */
5051  /********************************/
5052 
5053  _container.event.mpi_event.type =
5054  T_MPI_ENUM(MPI_COMM_REMOTE_GROUP)
5055  ;
5056 
5057  /* Set default source & dest before override */
5058  _container.event.mpi_event.source = _rank;
5059  _container.event.mpi_event.dest = _rank;
5060 
5061 
5062 
5063 
5064 
5065 
5066  SET_COMM (comm)
5067 
5068  /* Fill in size informations if needed */
5069  int _size = 0;
5070  #if 0
5071 
5072  #endif
5073  _container.event.mpi_event.size = _size;
5074 
5075  /********************************/
5076  /* EMIT OTF ENTER */
5077  /********************************/
5078 
5079  struct MALP_Trace_Event otf_event;
5080 
5081  uint64_t _begin = Timer_tsc ();
5082 
5085  {
5086 
5087  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5088  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5089  MALP_EVENT_MPI, _container.event.mpi_event.type );
5090  Event_Packer_push(&otf_event);
5091  }
5092 
5093  /********************************/
5094  /* ACTUAL FUNCTION CALL */
5095  /********************************/
5096 
5098  int ret = PMPI_Comm_remote_group( comm, group );
5100 
5101  /********************************/
5102  /* EMIT OTF END */
5103  /********************************/
5104 
5105  uint64_t _end = Timer_tsc();
5106  uint64_t _duration = _end - _begin;
5107 
5109  {
5111  {
5112 
5113  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5114  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5115  MALP_EVENT_MPI, _container.event.mpi_event.type );
5116 
5117 
5118  Event_Packer_push(&otf_event);
5119  }
5120 
5121  /********************************/
5122  /* EMIT MALP EVENT */
5123  /********************************/
5124 
5125  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5126 
5127  /* Submit event if MPI instrumented */
5128  Event_Packer_push(&_container);
5129  }
5130 
5131 
5132  return ret;
5133 }
5134 int MPI_Comm_remote_size( MPI_Comm comm, int * size )
5135 {
5136 
5137  /* Virtualize MPI */
5138  MACRO_MPI_Comm (comm)
5139 
5140  /* Pre instrum */
5141  int _rank = Stream_desc_get()->mpi_rank;
5142 
5143  struct MALP_Trace_Event _container;
5144 
5145  /********************************/
5146  /* FILL MPI EVENT */
5147  /********************************/
5148 
5149  _container.event.mpi_event.type =
5150  T_MPI_ENUM(MPI_COMM_REMOTE_SIZE)
5151  ;
5152 
5153  /* Set default source & dest before override */
5154  _container.event.mpi_event.source = _rank;
5155  _container.event.mpi_event.dest = _rank;
5156 
5157 
5158 
5159 
5160 
5161 
5162  SET_COMM (comm)
5163 
5164  /* Fill in size informations if needed */
5165  int _size = 0;
5166  #if 0
5167 
5168  #endif
5169  _container.event.mpi_event.size = _size;
5170 
5171  /********************************/
5172  /* EMIT OTF ENTER */
5173  /********************************/
5174 
5175  struct MALP_Trace_Event otf_event;
5176 
5177  uint64_t _begin = Timer_tsc ();
5178 
5181  {
5182 
5183  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5184  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5185  MALP_EVENT_MPI, _container.event.mpi_event.type );
5186  Event_Packer_push(&otf_event);
5187  }
5188 
5189  /********************************/
5190  /* ACTUAL FUNCTION CALL */
5191  /********************************/
5192 
5194  int ret = PMPI_Comm_remote_size( comm, size );
5196 
5197  /********************************/
5198  /* EMIT OTF END */
5199  /********************************/
5200 
5201  uint64_t _end = Timer_tsc();
5202  uint64_t _duration = _end - _begin;
5203 
5205  {
5207  {
5208 
5209  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5210  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5211  MALP_EVENT_MPI, _container.event.mpi_event.type );
5212 
5213 
5214  Event_Packer_push(&otf_event);
5215  }
5216 
5217  /********************************/
5218  /* EMIT MALP EVENT */
5219  /********************************/
5220 
5221  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5222 
5223  /* Submit event if MPI instrumented */
5224  Event_Packer_push(&_container);
5225  }
5226 
5227 
5228  return ret;
5229 }
5230 int MPI_Comm_set_attr( MPI_Comm comm, int comm_keyval, void * attribute_val )
5231 {
5232 
5233  /* Virtualize MPI */
5234  MACRO_MPI_Comm (comm)
5235 
5236  /* Pre instrum */
5237  int _rank = Stream_desc_get()->mpi_rank;
5238 
5239  struct MALP_Trace_Event _container;
5240 
5241  /********************************/
5242  /* FILL MPI EVENT */
5243  /********************************/
5244 
5245  _container.event.mpi_event.type =
5246  T_MPI_ENUM(MPI_COMM_SET_ATTR)
5247  ;
5248 
5249  /* Set default source & dest before override */
5250  _container.event.mpi_event.source = _rank;
5251  _container.event.mpi_event.dest = _rank;
5252 
5253 
5254 
5255 
5256 
5257 
5258  SET_COMM (comm)
5259 
5260  /* Fill in size informations if needed */
5261  int _size = 0;
5262  #if 0
5263 
5264  #endif
5265  _container.event.mpi_event.size = _size;
5266 
5267  /********************************/
5268  /* EMIT OTF ENTER */
5269  /********************************/
5270 
5271  struct MALP_Trace_Event otf_event;
5272 
5273  uint64_t _begin = Timer_tsc ();
5274 
5277  {
5278 
5279  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5280  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5281  MALP_EVENT_MPI, _container.event.mpi_event.type );
5282  Event_Packer_push(&otf_event);
5283  }
5284 
5285  /********************************/
5286  /* ACTUAL FUNCTION CALL */
5287  /********************************/
5288 
5290  int ret = PMPI_Comm_set_attr( comm, comm_keyval, attribute_val );
5292 
5293  /********************************/
5294  /* EMIT OTF END */
5295  /********************************/
5296 
5297  uint64_t _end = Timer_tsc();
5298  uint64_t _duration = _end - _begin;
5299 
5301  {
5303  {
5304 
5305  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5306  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5307  MALP_EVENT_MPI, _container.event.mpi_event.type );
5308 
5309 
5310  Event_Packer_push(&otf_event);
5311  }
5312 
5313  /********************************/
5314  /* EMIT MALP EVENT */
5315  /********************************/
5316 
5317  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5318 
5319  /* Submit event if MPI instrumented */
5320  Event_Packer_push(&_container);
5321  }
5322 
5323 
5324  return ret;
5325 }
5326 int MPI_Comm_set_errhandler( MPI_Comm comm, MPI_Errhandler errhandler )
5327 {
5328 
5329  /* Virtualize MPI */
5330  MACRO_MPI_Comm (comm)
5331 
5332  /* Pre instrum */
5333  int _rank = Stream_desc_get()->mpi_rank;
5334 
5335  struct MALP_Trace_Event _container;
5336 
5337  /********************************/
5338  /* FILL MPI EVENT */
5339  /********************************/
5340 
5341  _container.event.mpi_event.type =
5342  T_MPI_ENUM(MPI_COMM_SET_ERRHANDLER)
5343  ;
5344 
5345  /* Set default source & dest before override */
5346  _container.event.mpi_event.source = _rank;
5347  _container.event.mpi_event.dest = _rank;
5348 
5349 
5350 
5351 
5352 
5353 
5354  SET_COMM (comm)
5355 
5356  /* Fill in size informations if needed */
5357  int _size = 0;
5358  #if 0
5359 
5360  #endif
5361  _container.event.mpi_event.size = _size;
5362 
5363  /********************************/
5364  /* EMIT OTF ENTER */
5365  /********************************/
5366 
5367  struct MALP_Trace_Event otf_event;
5368 
5369  uint64_t _begin = Timer_tsc ();
5370 
5373  {
5374 
5375  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5376  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5377  MALP_EVENT_MPI, _container.event.mpi_event.type );
5378  Event_Packer_push(&otf_event);
5379  }
5380 
5381  /********************************/
5382  /* ACTUAL FUNCTION CALL */
5383  /********************************/
5384 
5386  int ret = PMPI_Comm_set_errhandler( comm, errhandler );
5388 
5389  /********************************/
5390  /* EMIT OTF END */
5391  /********************************/
5392 
5393  uint64_t _end = Timer_tsc();
5394  uint64_t _duration = _end - _begin;
5395 
5397  {
5399  {
5400 
5401  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5402  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5403  MALP_EVENT_MPI, _container.event.mpi_event.type );
5404 
5405 
5406  Event_Packer_push(&otf_event);
5407  }
5408 
5409  /********************************/
5410  /* EMIT MALP EVENT */
5411  /********************************/
5412 
5413  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5414 
5415  /* Submit event if MPI instrumented */
5416  Event_Packer_push(&_container);
5417  }
5418 
5419 
5420  return ret;
5421 }
5422 int MPI_Comm_set_name( MPI_Comm comm, char * comm_name )
5423 {
5424 
5425  /* Virtualize MPI */
5426  MACRO_MPI_Comm (comm)
5427 
5428  /* Pre instrum */
5429  int _rank = Stream_desc_get()->mpi_rank;
5430 
5431  struct MALP_Trace_Event _container;
5432 
5433  /********************************/
5434  /* FILL MPI EVENT */
5435  /********************************/
5436 
5437  _container.event.mpi_event.type =
5438  T_MPI_ENUM(MPI_COMM_SET_NAME)
5439  ;
5440 
5441  /* Set default source & dest before override */
5442  _container.event.mpi_event.source = _rank;
5443  _container.event.mpi_event.dest = _rank;
5444 
5445 
5446 
5447 
5448 
5449 
5450  SET_COMM (comm)
5451 
5452  /* Fill in size informations if needed */
5453  int _size = 0;
5454  #if 0
5455 
5456  #endif
5457  _container.event.mpi_event.size = _size;
5458 
5459  /********************************/
5460  /* EMIT OTF ENTER */
5461  /********************************/
5462 
5463  struct MALP_Trace_Event otf_event;
5464 
5465  uint64_t _begin = Timer_tsc ();
5466 
5469  {
5470 
5471  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5472  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5473  MALP_EVENT_MPI, _container.event.mpi_event.type );
5474  Event_Packer_push(&otf_event);
5475  }
5476 
5477  /********************************/
5478  /* ACTUAL FUNCTION CALL */
5479  /********************************/
5480 
5482  int ret = PMPI_Comm_set_name( comm, comm_name );
5484 
5485  /********************************/
5486  /* EMIT OTF END */
5487  /********************************/
5488 
5489  uint64_t _end = Timer_tsc();
5490  uint64_t _duration = _end - _begin;
5491 
5493  {
5495  {
5496 
5497  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5498  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5499  MALP_EVENT_MPI, _container.event.mpi_event.type );
5500 
5501 
5502  Event_Packer_push(&otf_event);
5503  }
5504 
5505  /********************************/
5506  /* EMIT MALP EVENT */
5507  /********************************/
5508 
5509  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5510 
5511  /* Submit event if MPI instrumented */
5512  Event_Packer_push(&_container);
5513  }
5514 
5515 
5516  return ret;
5517 }
5518 int MPI_Comm_size( MPI_Comm comm, int * size )
5519 {
5520 
5521  /* Virtualize MPI */
5522  MACRO_MPI_Comm (comm)
5523 
5524  /* Pre instrum */
5525  int _rank = Stream_desc_get()->mpi_rank;
5526 
5527  struct MALP_Trace_Event _container;
5528 
5529  /********************************/
5530  /* FILL MPI EVENT */
5531  /********************************/
5532 
5533  _container.event.mpi_event.type =
5534  T_MPI_ENUM(MPI_COMM_SIZE)
5535  ;
5536 
5537  /* Set default source & dest before override */
5538  _container.event.mpi_event.source = _rank;
5539  _container.event.mpi_event.dest = _rank;
5540 
5541 
5542 
5543 
5544 
5545 
5546  SET_COMM (comm)
5547 
5548  /* Fill in size informations if needed */
5549  int _size = 0;
5550  #if 0
5551 
5552  #endif
5553  _container.event.mpi_event.size = _size;
5554 
5555  /********************************/
5556  /* EMIT OTF ENTER */
5557  /********************************/
5558 
5559  struct MALP_Trace_Event otf_event;
5560 
5561  uint64_t _begin = Timer_tsc ();
5562 
5565  {
5566 
5567  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5568  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5569  MALP_EVENT_MPI, _container.event.mpi_event.type );
5570  Event_Packer_push(&otf_event);
5571  }
5572 
5573  /********************************/
5574  /* ACTUAL FUNCTION CALL */
5575  /********************************/
5576 
5578  int ret = PMPI_Comm_size( comm, size );
5580 
5581  /********************************/
5582  /* EMIT OTF END */
5583  /********************************/
5584 
5585  uint64_t _end = Timer_tsc();
5586  uint64_t _duration = _end - _begin;
5587 
5589  {
5591  {
5592 
5593  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5594  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5595  MALP_EVENT_MPI, _container.event.mpi_event.type );
5596 
5597 
5598  Event_Packer_push(&otf_event);
5599  }
5600 
5601  /********************************/
5602  /* EMIT MALP EVENT */
5603  /********************************/
5604 
5605  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5606 
5607  /* Submit event if MPI instrumented */
5608  Event_Packer_push(&_container);
5609  }
5610 
5611 
5612  return ret;
5613 }
5614 int MPI_Comm_spawn( char * command, char ** argv, int maxprocs, MPI_Info info, int root, MPI_Comm comm, MPI_Comm * intercomm, int * array_of_errcodes )
5615 {
5616 
5617  /* Virtualize MPI */
5618  MACRO_MPI_Comm (comm)
5619 
5620  /* Pre instrum */
5621  int _rank = Stream_desc_get()->mpi_rank;
5622 
5623  struct MALP_Trace_Event _container;
5624 
5625  /********************************/
5626  /* FILL MPI EVENT */
5627  /********************************/
5628 
5629  _container.event.mpi_event.type =
5630  T_MPI_ENUM(MPI_COMM_SPAWN)
5631  ;
5632 
5633  /* Set default source & dest before override */
5634  _container.event.mpi_event.source = _rank;
5635  _container.event.mpi_event.dest = _rank;
5636 
5637 
5638 
5639 
5640 
5641 
5642  SET_COMM (comm)
5643 
5644  /* Fill in size informations if needed */
5645  int _size = 0;
5646  #if 0
5647 
5648  #endif
5649  _container.event.mpi_event.size = _size;
5650 
5651  /********************************/
5652  /* EMIT OTF ENTER */
5653  /********************************/
5654 
5655  struct MALP_Trace_Event otf_event;
5656 
5657  uint64_t _begin = Timer_tsc ();
5658 
5661  {
5662 
5663  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5664  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5665  MALP_EVENT_MPI, _container.event.mpi_event.type );
5666  Event_Packer_push(&otf_event);
5667  }
5668 
5669  /********************************/
5670  /* ACTUAL FUNCTION CALL */
5671  /********************************/
5672 
5674  int ret = PMPI_Comm_spawn( command, argv, maxprocs, info, root, comm, intercomm, array_of_errcodes );
5676 
5677  /********************************/
5678  /* EMIT OTF END */
5679  /********************************/
5680 
5681  uint64_t _end = Timer_tsc();
5682  uint64_t _duration = _end - _begin;
5683 
5685  {
5687  {
5688 
5689  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5690  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5691  MALP_EVENT_MPI, _container.event.mpi_event.type );
5692 
5693 
5694  Event_Packer_push(&otf_event);
5695  }
5696 
5697  /********************************/
5698  /* EMIT MALP EVENT */
5699  /********************************/
5700 
5701  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5702 
5703  /* Submit event if MPI instrumented */
5704  Event_Packer_push(&_container);
5705  }
5706 
5707 
5708  return ret;
5709 }
5710 int MPI_Comm_spawn_multiple( int count, char ** array_of_commands, char *** array_of_argv, int * array_of_maxprocs, MPI_Info * array_of_info, int root, MPI_Comm comm, MPI_Comm * intercomm, int * array_of_errcodes )
5711 {
5712 
5713  /* Virtualize MPI */
5714  MACRO_MPI_Comm (comm)
5715 
5716  /* Pre instrum */
5717  int _rank = Stream_desc_get()->mpi_rank;
5718 
5719  struct MALP_Trace_Event _container;
5720 
5721  /********************************/
5722  /* FILL MPI EVENT */
5723  /********************************/
5724 
5725  _container.event.mpi_event.type =
5726  T_MPI_ENUM(MPI_COMM_SPAWN_MULTIPLE)
5727  ;
5728 
5729  /* Set default source & dest before override */
5730  _container.event.mpi_event.source = _rank;
5731  _container.event.mpi_event.dest = _rank;
5732 
5733 
5734 
5735 
5736  SET_COUNT (count)
5737 
5738  SET_COMM (comm)
5739 
5740  /* Fill in size informations if needed */
5741  int _size = 0;
5742  #if 0
5743  COMP_SIZE (count)
5744  #endif
5745  _container.event.mpi_event.size = _size;
5746 
5747  /********************************/
5748  /* EMIT OTF ENTER */
5749  /********************************/
5750 
5751  struct MALP_Trace_Event otf_event;
5752 
5753  uint64_t _begin = Timer_tsc ();
5754 
5757  {
5758 
5759  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5760  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5761  MALP_EVENT_MPI, _container.event.mpi_event.type );
5762  Event_Packer_push(&otf_event);
5763  }
5764 
5765  /********************************/
5766  /* ACTUAL FUNCTION CALL */
5767  /********************************/
5768 
5770  int ret = PMPI_Comm_spawn_multiple( count, array_of_commands, array_of_argv, array_of_maxprocs, array_of_info, root, comm, intercomm, array_of_errcodes );
5772 
5773  /********************************/
5774  /* EMIT OTF END */
5775  /********************************/
5776 
5777  uint64_t _end = Timer_tsc();
5778  uint64_t _duration = _end - _begin;
5779 
5781  {
5783  {
5784 
5785  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5786  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5787  MALP_EVENT_MPI, _container.event.mpi_event.type );
5788 
5789 
5790  Event_Packer_push(&otf_event);
5791  }
5792 
5793  /********************************/
5794  /* EMIT MALP EVENT */
5795  /********************************/
5796 
5797  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5798 
5799  /* Submit event if MPI instrumented */
5800  Event_Packer_push(&_container);
5801  }
5802 
5803 
5804  return ret;
5805 }
5806 int MPI_Comm_split( MPI_Comm comm, int color, int key, MPI_Comm * newcomm )
5807 {
5808 
5809  /* Virtualize MPI */
5810  MACRO_MPI_Comm (comm)
5811 
5812  /* Pre instrum */
5813  int _rank = Stream_desc_get()->mpi_rank;
5814 
5815  struct MALP_Trace_Event _container;
5816 
5817  /********************************/
5818  /* FILL MPI EVENT */
5819  /********************************/
5820 
5821  _container.event.mpi_event.type =
5822  T_MPI_ENUM(MPI_COMM_SPLIT)
5823  ;
5824 
5825  /* Set default source & dest before override */
5826  _container.event.mpi_event.source = _rank;
5827  _container.event.mpi_event.dest = _rank;
5828 
5829 
5830 
5831 
5832 
5833 
5834  SET_COMM (comm)
5835 
5836  /* Fill in size informations if needed */
5837  int _size = 0;
5838  #if 0
5839 
5840  #endif
5841  _container.event.mpi_event.size = _size;
5842 
5843  /********************************/
5844  /* EMIT OTF ENTER */
5845  /********************************/
5846 
5847  struct MALP_Trace_Event otf_event;
5848 
5849  uint64_t _begin = Timer_tsc ();
5850 
5853  {
5854 
5855  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5856  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5857  MALP_EVENT_MPI, _container.event.mpi_event.type );
5858  Event_Packer_push(&otf_event);
5859  }
5860 
5861  /********************************/
5862  /* ACTUAL FUNCTION CALL */
5863  /********************************/
5864 
5866  int ret = PMPI_Comm_split( comm, color, key, newcomm );
5868 
5869  /********************************/
5870  /* EMIT OTF END */
5871  /********************************/
5872 
5873  uint64_t _end = Timer_tsc();
5874  uint64_t _duration = _end - _begin;
5875 
5877  {
5879  {
5880 
5881  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5882  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5883  MALP_EVENT_MPI, _container.event.mpi_event.type );
5884 
5885 
5886  Event_Packer_push(&otf_event);
5887  }
5888 
5889  /********************************/
5890  /* EMIT MALP EVENT */
5891  /********************************/
5892 
5893  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5894 
5895  /* Submit event if MPI instrumented */
5896  Event_Packer_push(&_container);
5897  }
5898 
5899 
5900  return ret;
5901 }
5902 int MPI_Comm_test_inter( MPI_Comm comm, int * flag )
5903 {
5904 
5905  /* Virtualize MPI */
5906  MACRO_MPI_Comm (comm)
5907 
5908  /* Pre instrum */
5909  int _rank = Stream_desc_get()->mpi_rank;
5910 
5911  struct MALP_Trace_Event _container;
5912 
5913  /********************************/
5914  /* FILL MPI EVENT */
5915  /********************************/
5916 
5917  _container.event.mpi_event.type =
5918  T_MPI_ENUM(MPI_COMM_TEST_INTER)
5919  ;
5920 
5921  /* Set default source & dest before override */
5922  _container.event.mpi_event.source = _rank;
5923  _container.event.mpi_event.dest = _rank;
5924 
5925 
5926 
5927 
5928 
5929 
5930  SET_COMM (comm)
5931 
5932  /* Fill in size informations if needed */
5933  int _size = 0;
5934  #if 0
5935 
5936  #endif
5937  _container.event.mpi_event.size = _size;
5938 
5939  /********************************/
5940  /* EMIT OTF ENTER */
5941  /********************************/
5942 
5943  struct MALP_Trace_Event otf_event;
5944 
5945  uint64_t _begin = Timer_tsc ();
5946 
5949  {
5950 
5951  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
5952  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
5953  MALP_EVENT_MPI, _container.event.mpi_event.type );
5954  Event_Packer_push(&otf_event);
5955  }
5956 
5957  /********************************/
5958  /* ACTUAL FUNCTION CALL */
5959  /********************************/
5960 
5962  int ret = PMPI_Comm_test_inter( comm, flag );
5964 
5965  /********************************/
5966  /* EMIT OTF END */
5967  /********************************/
5968 
5969  uint64_t _end = Timer_tsc();
5970  uint64_t _duration = _end - _begin;
5971 
5973  {
5975  {
5976 
5977  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
5978  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
5979  MALP_EVENT_MPI, _container.event.mpi_event.type );
5980 
5981 
5982  Event_Packer_push(&otf_event);
5983  }
5984 
5985  /********************************/
5986  /* EMIT MALP EVENT */
5987  /********************************/
5988 
5989  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
5990 
5991  /* Submit event if MPI instrumented */
5992  Event_Packer_push(&_container);
5993  }
5994 
5995 
5996  return ret;
5997 }
5998 int MPI_Dims_create( int nnodes, int ndims, int * dims )
5999 {
6000 
6001  /* Virtualize MPI */
6002 
6003 
6004  /* Pre instrum */
6005  int _rank = Stream_desc_get()->mpi_rank;
6006 
6007  struct MALP_Trace_Event _container;
6008 
6009  /********************************/
6010  /* FILL MPI EVENT */
6011  /********************************/
6012 
6013  _container.event.mpi_event.type =
6014  T_MPI_ENUM(MPI_DIMS_CREATE)
6015  ;
6016 
6017  /* Set default source & dest before override */
6018  _container.event.mpi_event.source = _rank;
6019  _container.event.mpi_event.dest = _rank;
6020 
6021 
6022 
6023 
6024 
6025 
6026 
6027 
6028  /* Fill in size informations if needed */
6029  int _size = 0;
6030  #if 0
6031 
6032  #endif
6033  _container.event.mpi_event.size = _size;
6034 
6035  /********************************/
6036  /* EMIT OTF ENTER */
6037  /********************************/
6038 
6039  struct MALP_Trace_Event otf_event;
6040 
6041  uint64_t _begin = Timer_tsc ();
6042 
6045  {
6046 
6047  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6048  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6049  MALP_EVENT_MPI, _container.event.mpi_event.type );
6050  Event_Packer_push(&otf_event);
6051  }
6052 
6053  /********************************/
6054  /* ACTUAL FUNCTION CALL */
6055  /********************************/
6056 
6058  int ret = PMPI_Dims_create( nnodes, ndims, dims );
6060 
6061  /********************************/
6062  /* EMIT OTF END */
6063  /********************************/
6064 
6065  uint64_t _end = Timer_tsc();
6066  uint64_t _duration = _end - _begin;
6067 
6069  {
6071  {
6072 
6073  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6074  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6075  MALP_EVENT_MPI, _container.event.mpi_event.type );
6076 
6077 
6078  Event_Packer_push(&otf_event);
6079  }
6080 
6081  /********************************/
6082  /* EMIT MALP EVENT */
6083  /********************************/
6084 
6085  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6086 
6087  /* Submit event if MPI instrumented */
6088  Event_Packer_push(&_container);
6089  }
6090 
6091 
6092  return ret;
6093 }
6094 int MPI_Errhandler_c2f( MPI_Errhandler errhandler )
6095 {
6096 
6097  /* Virtualize MPI */
6098 
6099 
6100  /* Pre instrum */
6101  int _rank = Stream_desc_get()->mpi_rank;
6102 
6103  struct MALP_Trace_Event _container;
6104 
6105  /********************************/
6106  /* FILL MPI EVENT */
6107  /********************************/
6108 
6109  _container.event.mpi_event.type =
6110  T_MPI_ENUM(MPI_ERRHANDLER_C2F)
6111  ;
6112 
6113  /* Set default source & dest before override */
6114  _container.event.mpi_event.source = _rank;
6115  _container.event.mpi_event.dest = _rank;
6116 
6117 
6118 
6119 
6120 
6121 
6122 
6123 
6124  /* Fill in size informations if needed */
6125  int _size = 0;
6126  #if 0
6127 
6128  #endif
6129  _container.event.mpi_event.size = _size;
6130 
6131  /********************************/
6132  /* EMIT OTF ENTER */
6133  /********************************/
6134 
6135  struct MALP_Trace_Event otf_event;
6136 
6137  uint64_t _begin = Timer_tsc ();
6138 
6141  {
6142 
6143  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6144  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6145  MALP_EVENT_MPI, _container.event.mpi_event.type );
6146  Event_Packer_push(&otf_event);
6147  }
6148 
6149  /********************************/
6150  /* ACTUAL FUNCTION CALL */
6151  /********************************/
6152 
6154  int ret = PMPI_Errhandler_c2f( errhandler );
6156 
6157  /********************************/
6158  /* EMIT OTF END */
6159  /********************************/
6160 
6161  uint64_t _end = Timer_tsc();
6162  uint64_t _duration = _end - _begin;
6163 
6165  {
6167  {
6168 
6169  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6170  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6171  MALP_EVENT_MPI, _container.event.mpi_event.type );
6172 
6173 
6174  Event_Packer_push(&otf_event);
6175  }
6176 
6177  /********************************/
6178  /* EMIT MALP EVENT */
6179  /********************************/
6180 
6181  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6182 
6183  /* Submit event if MPI instrumented */
6184  Event_Packer_push(&_container);
6185  }
6186 
6187 
6188  return ret;
6189 }
6190 int MPI_Errhandler_create( MPI_Handler_function * function, MPI_Errhandler * errhandler )
6191 {
6192 
6193  /* Virtualize MPI */
6194 
6195 
6196  /* Pre instrum */
6197  int _rank = Stream_desc_get()->mpi_rank;
6198 
6199  struct MALP_Trace_Event _container;
6200 
6201  /********************************/
6202  /* FILL MPI EVENT */
6203  /********************************/
6204 
6205  _container.event.mpi_event.type =
6206  T_MPI_ENUM(MPI_ERRHANDLER_CREATE)
6207  ;
6208 
6209  /* Set default source & dest before override */
6210  _container.event.mpi_event.source = _rank;
6211  _container.event.mpi_event.dest = _rank;
6212 
6213 
6214 
6215 
6216 
6217 
6218 
6219 
6220  /* Fill in size informations if needed */
6221  int _size = 0;
6222  #if 0
6223 
6224  #endif
6225  _container.event.mpi_event.size = _size;
6226 
6227  /********************************/
6228  /* EMIT OTF ENTER */
6229  /********************************/
6230 
6231  struct MALP_Trace_Event otf_event;
6232 
6233  uint64_t _begin = Timer_tsc ();
6234 
6237  {
6238 
6239  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6240  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6241  MALP_EVENT_MPI, _container.event.mpi_event.type );
6242  Event_Packer_push(&otf_event);
6243  }
6244 
6245  /********************************/
6246  /* ACTUAL FUNCTION CALL */
6247  /********************************/
6248 
6250  int ret = PMPI_Errhandler_create( function, errhandler );
6252 
6253  /********************************/
6254  /* EMIT OTF END */
6255  /********************************/
6256 
6257  uint64_t _end = Timer_tsc();
6258  uint64_t _duration = _end - _begin;
6259 
6261  {
6263  {
6264 
6265  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6266  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6267  MALP_EVENT_MPI, _container.event.mpi_event.type );
6268 
6269 
6270  Event_Packer_push(&otf_event);
6271  }
6272 
6273  /********************************/
6274  /* EMIT MALP EVENT */
6275  /********************************/
6276 
6277  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6278 
6279  /* Submit event if MPI instrumented */
6280  Event_Packer_push(&_container);
6281  }
6282 
6283 
6284  return ret;
6285 }
6286 int MPI_Errhandler_free( MPI_Errhandler * errhandler )
6287 {
6288 
6289  /* Virtualize MPI */
6290 
6291 
6292  /* Pre instrum */
6293  int _rank = Stream_desc_get()->mpi_rank;
6294 
6295  struct MALP_Trace_Event _container;
6296 
6297  /********************************/
6298  /* FILL MPI EVENT */
6299  /********************************/
6300 
6301  _container.event.mpi_event.type =
6302  T_MPI_ENUM(MPI_ERRHANDLER_FREE)
6303  ;
6304 
6305  /* Set default source & dest before override */
6306  _container.event.mpi_event.source = _rank;
6307  _container.event.mpi_event.dest = _rank;
6308 
6309 
6310 
6311 
6312 
6313 
6314 
6315 
6316  /* Fill in size informations if needed */
6317  int _size = 0;
6318  #if 0
6319 
6320  #endif
6321  _container.event.mpi_event.size = _size;
6322 
6323  /********************************/
6324  /* EMIT OTF ENTER */
6325  /********************************/
6326 
6327  struct MALP_Trace_Event otf_event;
6328 
6329  uint64_t _begin = Timer_tsc ();
6330 
6333  {
6334 
6335  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6336  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6337  MALP_EVENT_MPI, _container.event.mpi_event.type );
6338  Event_Packer_push(&otf_event);
6339  }
6340 
6341  /********************************/
6342  /* ACTUAL FUNCTION CALL */
6343  /********************************/
6344 
6346  int ret = PMPI_Errhandler_free( errhandler );
6348 
6349  /********************************/
6350  /* EMIT OTF END */
6351  /********************************/
6352 
6353  uint64_t _end = Timer_tsc();
6354  uint64_t _duration = _end - _begin;
6355 
6357  {
6359  {
6360 
6361  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6362  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6363  MALP_EVENT_MPI, _container.event.mpi_event.type );
6364 
6365 
6366  Event_Packer_push(&otf_event);
6367  }
6368 
6369  /********************************/
6370  /* EMIT MALP EVENT */
6371  /********************************/
6372 
6373  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6374 
6375  /* Submit event if MPI instrumented */
6376  Event_Packer_push(&_container);
6377  }
6378 
6379 
6380  return ret;
6381 }
6382 int MPI_Errhandler_get( MPI_Comm comm, MPI_Errhandler * errhandler )
6383 {
6384 
6385  /* Virtualize MPI */
6386  MACRO_MPI_Comm (comm)
6387 
6388  /* Pre instrum */
6389  int _rank = Stream_desc_get()->mpi_rank;
6390 
6391  struct MALP_Trace_Event _container;
6392 
6393  /********************************/
6394  /* FILL MPI EVENT */
6395  /********************************/
6396 
6397  _container.event.mpi_event.type =
6398  T_MPI_ENUM(MPI_ERRHANDLER_GET)
6399  ;
6400 
6401  /* Set default source & dest before override */
6402  _container.event.mpi_event.source = _rank;
6403  _container.event.mpi_event.dest = _rank;
6404 
6405 
6406 
6407 
6408 
6409 
6410  SET_COMM (comm)
6411 
6412  /* Fill in size informations if needed */
6413  int _size = 0;
6414  #if 0
6415 
6416  #endif
6417  _container.event.mpi_event.size = _size;
6418 
6419  /********************************/
6420  /* EMIT OTF ENTER */
6421  /********************************/
6422 
6423  struct MALP_Trace_Event otf_event;
6424 
6425  uint64_t _begin = Timer_tsc ();
6426 
6429  {
6430 
6431  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6432  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6433  MALP_EVENT_MPI, _container.event.mpi_event.type );
6434  Event_Packer_push(&otf_event);
6435  }
6436 
6437  /********************************/
6438  /* ACTUAL FUNCTION CALL */
6439  /********************************/
6440 
6442  int ret = PMPI_Errhandler_get( comm, errhandler );
6444 
6445  /********************************/
6446  /* EMIT OTF END */
6447  /********************************/
6448 
6449  uint64_t _end = Timer_tsc();
6450  uint64_t _duration = _end - _begin;
6451 
6453  {
6455  {
6456 
6457  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6458  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6459  MALP_EVENT_MPI, _container.event.mpi_event.type );
6460 
6461 
6462  Event_Packer_push(&otf_event);
6463  }
6464 
6465  /********************************/
6466  /* EMIT MALP EVENT */
6467  /********************************/
6468 
6469  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6470 
6471  /* Submit event if MPI instrumented */
6472  Event_Packer_push(&_container);
6473  }
6474 
6475 
6476  return ret;
6477 }
6478 int MPI_Errhandler_set( MPI_Comm comm, MPI_Errhandler errhandler )
6479 {
6480 
6481  /* Virtualize MPI */
6482  MACRO_MPI_Comm (comm)
6483 
6484  /* Pre instrum */
6485  int _rank = Stream_desc_get()->mpi_rank;
6486 
6487  struct MALP_Trace_Event _container;
6488 
6489  /********************************/
6490  /* FILL MPI EVENT */
6491  /********************************/
6492 
6493  _container.event.mpi_event.type =
6494  T_MPI_ENUM(MPI_ERRHANDLER_SET)
6495  ;
6496 
6497  /* Set default source & dest before override */
6498  _container.event.mpi_event.source = _rank;
6499  _container.event.mpi_event.dest = _rank;
6500 
6501 
6502 
6503 
6504 
6505 
6506  SET_COMM (comm)
6507 
6508  /* Fill in size informations if needed */
6509  int _size = 0;
6510  #if 0
6511 
6512  #endif
6513  _container.event.mpi_event.size = _size;
6514 
6515  /********************************/
6516  /* EMIT OTF ENTER */
6517  /********************************/
6518 
6519  struct MALP_Trace_Event otf_event;
6520 
6521  uint64_t _begin = Timer_tsc ();
6522 
6525  {
6526 
6527  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6528  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6529  MALP_EVENT_MPI, _container.event.mpi_event.type );
6530  Event_Packer_push(&otf_event);
6531  }
6532 
6533  /********************************/
6534  /* ACTUAL FUNCTION CALL */
6535  /********************************/
6536 
6538  int ret = PMPI_Errhandler_set( comm, errhandler );
6540 
6541  /********************************/
6542  /* EMIT OTF END */
6543  /********************************/
6544 
6545  uint64_t _end = Timer_tsc();
6546  uint64_t _duration = _end - _begin;
6547 
6549  {
6551  {
6552 
6553  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6554  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6555  MALP_EVENT_MPI, _container.event.mpi_event.type );
6556 
6557 
6558  Event_Packer_push(&otf_event);
6559  }
6560 
6561  /********************************/
6562  /* EMIT MALP EVENT */
6563  /********************************/
6564 
6565  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6566 
6567  /* Submit event if MPI instrumented */
6568  Event_Packer_push(&_container);
6569  }
6570 
6571 
6572  return ret;
6573 }
6574 int MPI_Error_class( int errorcode, int * errorclass )
6575 {
6576 
6577  /* Virtualize MPI */
6578 
6579 
6580  /* Pre instrum */
6581  int _rank = Stream_desc_get()->mpi_rank;
6582 
6583  struct MALP_Trace_Event _container;
6584 
6585  /********************************/
6586  /* FILL MPI EVENT */
6587  /********************************/
6588 
6589  _container.event.mpi_event.type =
6590  T_MPI_ENUM(MPI_ERROR_CLASS)
6591  ;
6592 
6593  /* Set default source & dest before override */
6594  _container.event.mpi_event.source = _rank;
6595  _container.event.mpi_event.dest = _rank;
6596 
6597 
6598 
6599 
6600 
6601 
6602 
6603 
6604  /* Fill in size informations if needed */
6605  int _size = 0;
6606  #if 0
6607 
6608  #endif
6609  _container.event.mpi_event.size = _size;
6610 
6611  /********************************/
6612  /* EMIT OTF ENTER */
6613  /********************************/
6614 
6615  struct MALP_Trace_Event otf_event;
6616 
6617  uint64_t _begin = Timer_tsc ();
6618 
6621  {
6622 
6623  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6624  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6625  MALP_EVENT_MPI, _container.event.mpi_event.type );
6626  Event_Packer_push(&otf_event);
6627  }
6628 
6629  /********************************/
6630  /* ACTUAL FUNCTION CALL */
6631  /********************************/
6632 
6634  int ret = PMPI_Error_class( errorcode, errorclass );
6636 
6637  /********************************/
6638  /* EMIT OTF END */
6639  /********************************/
6640 
6641  uint64_t _end = Timer_tsc();
6642  uint64_t _duration = _end - _begin;
6643 
6645  {
6647  {
6648 
6649  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6650  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6651  MALP_EVENT_MPI, _container.event.mpi_event.type );
6652 
6653 
6654  Event_Packer_push(&otf_event);
6655  }
6656 
6657  /********************************/
6658  /* EMIT MALP EVENT */
6659  /********************************/
6660 
6661  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6662 
6663  /* Submit event if MPI instrumented */
6664  Event_Packer_push(&_container);
6665  }
6666 
6667 
6668  return ret;
6669 }
6670 int MPI_Error_string( int errorcode, char * string, int * resultlen )
6671 {
6672 
6673  /* Virtualize MPI */
6674 
6675 
6676  /* Pre instrum */
6677  int _rank = Stream_desc_get()->mpi_rank;
6678 
6679  struct MALP_Trace_Event _container;
6680 
6681  /********************************/
6682  /* FILL MPI EVENT */
6683  /********************************/
6684 
6685  _container.event.mpi_event.type =
6686  T_MPI_ENUM(MPI_ERROR_STRING)
6687  ;
6688 
6689  /* Set default source & dest before override */
6690  _container.event.mpi_event.source = _rank;
6691  _container.event.mpi_event.dest = _rank;
6692 
6693 
6694 
6695 
6696 
6697 
6698 
6699 
6700  /* Fill in size informations if needed */
6701  int _size = 0;
6702  #if 0
6703 
6704  #endif
6705  _container.event.mpi_event.size = _size;
6706 
6707  /********************************/
6708  /* EMIT OTF ENTER */
6709  /********************************/
6710 
6711  struct MALP_Trace_Event otf_event;
6712 
6713  uint64_t _begin = Timer_tsc ();
6714 
6717  {
6718 
6719  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6720  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6721  MALP_EVENT_MPI, _container.event.mpi_event.type );
6722  Event_Packer_push(&otf_event);
6723  }
6724 
6725  /********************************/
6726  /* ACTUAL FUNCTION CALL */
6727  /********************************/
6728 
6730  int ret = PMPI_Error_string( errorcode, string, resultlen );
6732 
6733  /********************************/
6734  /* EMIT OTF END */
6735  /********************************/
6736 
6737  uint64_t _end = Timer_tsc();
6738  uint64_t _duration = _end - _begin;
6739 
6741  {
6743  {
6744 
6745  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6746  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6747  MALP_EVENT_MPI, _container.event.mpi_event.type );
6748 
6749 
6750  Event_Packer_push(&otf_event);
6751  }
6752 
6753  /********************************/
6754  /* EMIT MALP EVENT */
6755  /********************************/
6756 
6757  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6758 
6759  /* Submit event if MPI instrumented */
6760  Event_Packer_push(&_container);
6761  }
6762 
6763 
6764  return ret;
6765 }
6766 int MPI_Exscan( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
6767 {
6768 
6769  /* Virtualize MPI */
6770  MACRO_MPI_Comm (comm)
6771 
6772  /* Pre instrum */
6773  int _rank = Stream_desc_get()->mpi_rank;
6774 
6775  struct MALP_Trace_Event _container;
6776 
6777  /********************************/
6778  /* FILL MPI EVENT */
6779  /********************************/
6780 
6781  _container.event.mpi_event.type =
6782  T_MPI_ENUM(MPI_EXSCAN)
6783  ;
6784 
6785  /* Set default source & dest before override */
6786  _container.event.mpi_event.source = _rank;
6787  _container.event.mpi_event.dest = _rank;
6788 
6789 
6790 
6791 
6792  SET_COUNT (count)
6793  SET_DATATYPE (datatype)
6794  SET_COMM (comm)
6795 
6796  /* Fill in size informations if needed */
6797  int _size = 0;
6798  #if 1
6799  COMP_SIZE (count)
6800  #endif
6801  _container.event.mpi_event.size = _size;
6802 
6803  /********************************/
6804  /* EMIT OTF ENTER */
6805  /********************************/
6806 
6807  struct MALP_Trace_Event otf_event;
6808 
6809  uint64_t _begin = Timer_tsc ();
6810 
6813  {
6814 
6815  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6816  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6817  MALP_EVENT_MPI, _container.event.mpi_event.type );
6818  Event_Packer_push(&otf_event);
6819  }
6820 
6821  /********************************/
6822  /* ACTUAL FUNCTION CALL */
6823  /********************************/
6824 
6826  int ret = PMPI_Exscan( sendbuf, recvbuf, count, datatype, op, comm );
6828 
6829  /********************************/
6830  /* EMIT OTF END */
6831  /********************************/
6832 
6833  uint64_t _end = Timer_tsc();
6834  uint64_t _duration = _end - _begin;
6835 
6837  {
6839  {
6840 
6841  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6842  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6843  MALP_EVENT_MPI, _container.event.mpi_event.type );
6844 
6845 
6846  Event_Packer_push(&otf_event);
6847  }
6848 
6849  /********************************/
6850  /* EMIT MALP EVENT */
6851  /********************************/
6852 
6853  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6854 
6855  /* Submit event if MPI instrumented */
6856  Event_Packer_push(&_container);
6857  }
6858 
6859 
6860  return ret;
6861 }
6862 int MPI_File_c2f( MPI_File file )
6863 {
6864 
6865  /* Virtualize MPI */
6866 
6867 
6868  /* Pre instrum */
6869  int _rank = Stream_desc_get()->mpi_rank;
6870 
6871  struct MALP_Trace_Event _container;
6872 
6873  /********************************/
6874  /* FILL MPI EVENT */
6875  /********************************/
6876 
6877  _container.event.mpi_event.type =
6878  T_MPI_ENUM(MPI_FILE_C2F)
6879  ;
6880 
6881  /* Set default source & dest before override */
6882  _container.event.mpi_event.source = _rank;
6883  _container.event.mpi_event.dest = _rank;
6884 
6885 
6886 
6887 
6888 
6889 
6890 
6891 
6892  /* Fill in size informations if needed */
6893  int _size = 0;
6894  #if 0
6895 
6896  #endif
6897  _container.event.mpi_event.size = _size;
6898 
6899  /********************************/
6900  /* EMIT OTF ENTER */
6901  /********************************/
6902 
6903  struct MALP_Trace_Event otf_event;
6904 
6905  uint64_t _begin = Timer_tsc ();
6906 
6909  {
6910 
6911  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
6912  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
6913  MALP_EVENT_MPI, _container.event.mpi_event.type );
6914  Event_Packer_push(&otf_event);
6915  }
6916 
6917  /********************************/
6918  /* ACTUAL FUNCTION CALL */
6919  /********************************/
6920 
6922  int ret = PMPI_File_c2f( file );
6924 
6925  /********************************/
6926  /* EMIT OTF END */
6927  /********************************/
6928 
6929  uint64_t _end = Timer_tsc();
6930  uint64_t _duration = _end - _begin;
6931 
6933  {
6935  {
6936 
6937  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
6938  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
6939  MALP_EVENT_MPI, _container.event.mpi_event.type );
6940 
6941 
6942  Event_Packer_push(&otf_event);
6943  }
6944 
6945  /********************************/
6946  /* EMIT MALP EVENT */
6947  /********************************/
6948 
6949  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
6950 
6951  /* Submit event if MPI instrumented */
6952  Event_Packer_push(&_container);
6953  }
6954 
6955 
6956  return ret;
6957 }
6958 int MPI_File_call_errhandler( MPI_File fh, int errorcode )
6959 {
6960 
6961  /* Virtualize MPI */
6962 
6963 
6964  /* Pre instrum */
6965  int _rank = Stream_desc_get()->mpi_rank;
6966 
6967  struct MALP_Trace_Event _container;
6968 
6969  /********************************/
6970  /* FILL MPI EVENT */
6971  /********************************/
6972 
6973  _container.event.mpi_event.type =
6974  T_MPI_ENUM(MPI_FILE_CALL_ERRHANDLER)
6975  ;
6976 
6977  /* Set default source & dest before override */
6978  _container.event.mpi_event.source = _rank;
6979  _container.event.mpi_event.dest = _rank;
6980 
6981 
6982 
6983 
6984 
6985 
6986 
6987 
6988  /* Fill in size informations if needed */
6989  int _size = 0;
6990  #if 0
6991 
6992  #endif
6993  _container.event.mpi_event.size = _size;
6994 
6995  /********************************/
6996  /* EMIT OTF ENTER */
6997  /********************************/
6998 
6999  struct MALP_Trace_Event otf_event;
7000 
7001  uint64_t _begin = Timer_tsc ();
7002 
7005  {
7006 
7007  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7008  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7009  MALP_EVENT_MPI, _container.event.mpi_event.type );
7010  Event_Packer_push(&otf_event);
7011  }
7012 
7013  /********************************/
7014  /* ACTUAL FUNCTION CALL */
7015  /********************************/
7016 
7018  int ret = PMPI_File_call_errhandler( fh, errorcode );
7020 
7021  /********************************/
7022  /* EMIT OTF END */
7023  /********************************/
7024 
7025  uint64_t _end = Timer_tsc();
7026  uint64_t _duration = _end - _begin;
7027 
7029  {
7031  {
7032 
7033  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7034  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7035  MALP_EVENT_MPI, _container.event.mpi_event.type );
7036 
7037 
7038  Event_Packer_push(&otf_event);
7039  }
7040 
7041  /********************************/
7042  /* EMIT MALP EVENT */
7043  /********************************/
7044 
7045  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7046 
7047  /* Submit event if MPI instrumented */
7048  Event_Packer_push(&_container);
7049  }
7050 
7051 
7052  return ret;
7053 }
7054 int MPI_File_create_errhandler( MPI_File_errhandler_function * function, MPI_Errhandler * errhandler )
7055 {
7056 
7057  /* Virtualize MPI */
7058 
7059 
7060  /* Pre instrum */
7061  int _rank = Stream_desc_get()->mpi_rank;
7062 
7063  struct MALP_Trace_Event _container;
7064 
7065  /********************************/
7066  /* FILL MPI EVENT */
7067  /********************************/
7068 
7069  _container.event.mpi_event.type =
7070  T_MPI_ENUM(MPI_FILE_CREATE_ERRHANDLER)
7071  ;
7072 
7073  /* Set default source & dest before override */
7074  _container.event.mpi_event.source = _rank;
7075  _container.event.mpi_event.dest = _rank;
7076 
7077 
7078 
7079 
7080 
7081 
7082 
7083 
7084  /* Fill in size informations if needed */
7085  int _size = 0;
7086  #if 0
7087 
7088  #endif
7089  _container.event.mpi_event.size = _size;
7090 
7091  /********************************/
7092  /* EMIT OTF ENTER */
7093  /********************************/
7094 
7095  struct MALP_Trace_Event otf_event;
7096 
7097  uint64_t _begin = Timer_tsc ();
7098 
7101  {
7102 
7103  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7104  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7105  MALP_EVENT_MPI, _container.event.mpi_event.type );
7106  Event_Packer_push(&otf_event);
7107  }
7108 
7109  /********************************/
7110  /* ACTUAL FUNCTION CALL */
7111  /********************************/
7112 
7114  int ret = PMPI_File_create_errhandler( function, errhandler );
7116 
7117  /********************************/
7118  /* EMIT OTF END */
7119  /********************************/
7120 
7121  uint64_t _end = Timer_tsc();
7122  uint64_t _duration = _end - _begin;
7123 
7125  {
7127  {
7128 
7129  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7130  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7131  MALP_EVENT_MPI, _container.event.mpi_event.type );
7132 
7133 
7134  Event_Packer_push(&otf_event);
7135  }
7136 
7137  /********************************/
7138  /* EMIT MALP EVENT */
7139  /********************************/
7140 
7141  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7142 
7143  /* Submit event if MPI instrumented */
7144  Event_Packer_push(&_container);
7145  }
7146 
7147 
7148  return ret;
7149 }
7150 int MPI_File_set_errhandler( MPI_File file, MPI_Errhandler errhandler )
7151 {
7152 
7153  /* Virtualize MPI */
7154 
7155 
7156  /* Pre instrum */
7157  int _rank = Stream_desc_get()->mpi_rank;
7158 
7159  struct MALP_Trace_Event _container;
7160 
7161  /********************************/
7162  /* FILL MPI EVENT */
7163  /********************************/
7164 
7165  _container.event.mpi_event.type =
7166  T_MPI_ENUM(MPI_FILE_SET_ERRHANDLER)
7167  ;
7168 
7169  /* Set default source & dest before override */
7170  _container.event.mpi_event.source = _rank;
7171  _container.event.mpi_event.dest = _rank;
7172 
7173 
7174 
7175 
7176 
7177 
7178 
7179 
7180  /* Fill in size informations if needed */
7181  int _size = 0;
7182  #if 0
7183 
7184  #endif
7185  _container.event.mpi_event.size = _size;
7186 
7187  /********************************/
7188  /* EMIT OTF ENTER */
7189  /********************************/
7190 
7191  struct MALP_Trace_Event otf_event;
7192 
7193  uint64_t _begin = Timer_tsc ();
7194 
7197  {
7198 
7199  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7200  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7201  MALP_EVENT_MPI, _container.event.mpi_event.type );
7202  Event_Packer_push(&otf_event);
7203  }
7204 
7205  /********************************/
7206  /* ACTUAL FUNCTION CALL */
7207  /********************************/
7208 
7210  int ret = PMPI_File_set_errhandler( file, errhandler );
7212 
7213  /********************************/
7214  /* EMIT OTF END */
7215  /********************************/
7216 
7217  uint64_t _end = Timer_tsc();
7218  uint64_t _duration = _end - _begin;
7219 
7221  {
7223  {
7224 
7225  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7226  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7227  MALP_EVENT_MPI, _container.event.mpi_event.type );
7228 
7229 
7230  Event_Packer_push(&otf_event);
7231  }
7232 
7233  /********************************/
7234  /* EMIT MALP EVENT */
7235  /********************************/
7236 
7237  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7238 
7239  /* Submit event if MPI instrumented */
7240  Event_Packer_push(&_container);
7241  }
7242 
7243 
7244  return ret;
7245 }
7246 int MPI_File_get_errhandler( MPI_File file, MPI_Errhandler * errhandler )
7247 {
7248 
7249  /* Virtualize MPI */
7250 
7251 
7252  /* Pre instrum */
7253  int _rank = Stream_desc_get()->mpi_rank;
7254 
7255  struct MALP_Trace_Event _container;
7256 
7257  /********************************/
7258  /* FILL MPI EVENT */
7259  /********************************/
7260 
7261  _container.event.mpi_event.type =
7262  T_MPI_ENUM(MPI_FILE_GET_ERRHANDLER)
7263  ;
7264 
7265  /* Set default source & dest before override */
7266  _container.event.mpi_event.source = _rank;
7267  _container.event.mpi_event.dest = _rank;
7268 
7269 
7270 
7271 
7272 
7273 
7274 
7275 
7276  /* Fill in size informations if needed */
7277  int _size = 0;
7278  #if 0
7279 
7280  #endif
7281  _container.event.mpi_event.size = _size;
7282 
7283  /********************************/
7284  /* EMIT OTF ENTER */
7285  /********************************/
7286 
7287  struct MALP_Trace_Event otf_event;
7288 
7289  uint64_t _begin = Timer_tsc ();
7290 
7293  {
7294 
7295  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7296  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7297  MALP_EVENT_MPI, _container.event.mpi_event.type );
7298  Event_Packer_push(&otf_event);
7299  }
7300 
7301  /********************************/
7302  /* ACTUAL FUNCTION CALL */
7303  /********************************/
7304 
7306  int ret = PMPI_File_get_errhandler( file, errhandler );
7308 
7309  /********************************/
7310  /* EMIT OTF END */
7311  /********************************/
7312 
7313  uint64_t _end = Timer_tsc();
7314  uint64_t _duration = _end - _begin;
7315 
7317  {
7319  {
7320 
7321  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7322  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7323  MALP_EVENT_MPI, _container.event.mpi_event.type );
7324 
7325 
7326  Event_Packer_push(&otf_event);
7327  }
7328 
7329  /********************************/
7330  /* EMIT MALP EVENT */
7331  /********************************/
7332 
7333  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7334 
7335  /* Submit event if MPI instrumented */
7336  Event_Packer_push(&_container);
7337  }
7338 
7339 
7340  return ret;
7341 }
7342 int MPI_File_open( MPI_Comm comm, char * filename, int amode, MPI_Info info, MPI_File * fh )
7343 {
7344 
7345  /* Virtualize MPI */
7346  MACRO_MPI_Comm (comm)
7347 
7348  /* Pre instrum */
7349  int _rank = Stream_desc_get()->mpi_rank;
7350 
7351  struct MALP_Trace_Event _container;
7352 
7353  /********************************/
7354  /* FILL MPI EVENT */
7355  /********************************/
7356 
7357  _container.event.mpi_event.type =
7358  T_MPI_ENUM(MPI_FILE_OPEN)
7359  ;
7360 
7361  /* Set default source & dest before override */
7362  _container.event.mpi_event.source = _rank;
7363  _container.event.mpi_event.dest = _rank;
7364 
7365 
7366 
7367 
7368 
7369 
7370  SET_COMM (comm)
7371 
7372  /* Fill in size informations if needed */
7373  int _size = 0;
7374  #if 0
7375 
7376  #endif
7377  _container.event.mpi_event.size = _size;
7378 
7379  /********************************/
7380  /* EMIT OTF ENTER */
7381  /********************************/
7382 
7383  struct MALP_Trace_Event otf_event;
7384 
7385  uint64_t _begin = Timer_tsc ();
7386 
7389  {
7390 
7391  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7392  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7393  MALP_EVENT_MPI, _container.event.mpi_event.type );
7394  Event_Packer_push(&otf_event);
7395  }
7396 
7397  /********************************/
7398  /* ACTUAL FUNCTION CALL */
7399  /********************************/
7400 
7402  int ret = PMPI_File_open( comm, filename, amode, info, fh );
7404 
7405  /********************************/
7406  /* EMIT OTF END */
7407  /********************************/
7408 
7409  uint64_t _end = Timer_tsc();
7410  uint64_t _duration = _end - _begin;
7411 
7413  {
7415  {
7416 
7417  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7418  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7419  MALP_EVENT_MPI, _container.event.mpi_event.type );
7420 
7421 
7422  Event_Packer_push(&otf_event);
7423  }
7424 
7425  /********************************/
7426  /* EMIT MALP EVENT */
7427  /********************************/
7428 
7429  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7430 
7431  /* Submit event if MPI instrumented */
7432  Event_Packer_push(&_container);
7433  }
7434 
7435 
7436  return ret;
7437 }
7438 int MPI_File_close( MPI_File * fh )
7439 {
7440 
7441  /* Virtualize MPI */
7442 
7443 
7444  /* Pre instrum */
7445  int _rank = Stream_desc_get()->mpi_rank;
7446 
7447  struct MALP_Trace_Event _container;
7448 
7449  /********************************/
7450  /* FILL MPI EVENT */
7451  /********************************/
7452 
7453  _container.event.mpi_event.type =
7454  T_MPI_ENUM(MPI_FILE_CLOSE)
7455  ;
7456 
7457  /* Set default source & dest before override */
7458  _container.event.mpi_event.source = _rank;
7459  _container.event.mpi_event.dest = _rank;
7460 
7461 
7462 
7463 
7464 
7465 
7466 
7467 
7468  /* Fill in size informations if needed */
7469  int _size = 0;
7470  #if 0
7471 
7472  #endif
7473  _container.event.mpi_event.size = _size;
7474 
7475  /********************************/
7476  /* EMIT OTF ENTER */
7477  /********************************/
7478 
7479  struct MALP_Trace_Event otf_event;
7480 
7481  uint64_t _begin = Timer_tsc ();
7482 
7485  {
7486 
7487  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7488  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7489  MALP_EVENT_MPI, _container.event.mpi_event.type );
7490  Event_Packer_push(&otf_event);
7491  }
7492 
7493  /********************************/
7494  /* ACTUAL FUNCTION CALL */
7495  /********************************/
7496 
7498  int ret = PMPI_File_close( fh );
7500 
7501  /********************************/
7502  /* EMIT OTF END */
7503  /********************************/
7504 
7505  uint64_t _end = Timer_tsc();
7506  uint64_t _duration = _end - _begin;
7507 
7509  {
7511  {
7512 
7513  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7514  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7515  MALP_EVENT_MPI, _container.event.mpi_event.type );
7516 
7517 
7518  Event_Packer_push(&otf_event);
7519  }
7520 
7521  /********************************/
7522  /* EMIT MALP EVENT */
7523  /********************************/
7524 
7525  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7526 
7527  /* Submit event if MPI instrumented */
7528  Event_Packer_push(&_container);
7529  }
7530 
7531 
7532  return ret;
7533 }
7534 int MPI_File_delete( char * filename, MPI_Info info )
7535 {
7536 
7537  /* Virtualize MPI */
7538 
7539 
7540  /* Pre instrum */
7541  int _rank = Stream_desc_get()->mpi_rank;
7542 
7543  struct MALP_Trace_Event _container;
7544 
7545  /********************************/
7546  /* FILL MPI EVENT */
7547  /********************************/
7548 
7549  _container.event.mpi_event.type =
7550  T_MPI_ENUM(MPI_FILE_DELETE)
7551  ;
7552 
7553  /* Set default source & dest before override */
7554  _container.event.mpi_event.source = _rank;
7555  _container.event.mpi_event.dest = _rank;
7556 
7557 
7558 
7559 
7560 
7561 
7562 
7563 
7564  /* Fill in size informations if needed */
7565  int _size = 0;
7566  #if 0
7567 
7568  #endif
7569  _container.event.mpi_event.size = _size;
7570 
7571  /********************************/
7572  /* EMIT OTF ENTER */
7573  /********************************/
7574 
7575  struct MALP_Trace_Event otf_event;
7576 
7577  uint64_t _begin = Timer_tsc ();
7578 
7581  {
7582 
7583  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7584  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7585  MALP_EVENT_MPI, _container.event.mpi_event.type );
7586  Event_Packer_push(&otf_event);
7587  }
7588 
7589  /********************************/
7590  /* ACTUAL FUNCTION CALL */
7591  /********************************/
7592 
7594  int ret = PMPI_File_delete( filename, info );
7596 
7597  /********************************/
7598  /* EMIT OTF END */
7599  /********************************/
7600 
7601  uint64_t _end = Timer_tsc();
7602  uint64_t _duration = _end - _begin;
7603 
7605  {
7607  {
7608 
7609  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7610  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7611  MALP_EVENT_MPI, _container.event.mpi_event.type );
7612 
7613 
7614  Event_Packer_push(&otf_event);
7615  }
7616 
7617  /********************************/
7618  /* EMIT MALP EVENT */
7619  /********************************/
7620 
7621  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7622 
7623  /* Submit event if MPI instrumented */
7624  Event_Packer_push(&_container);
7625  }
7626 
7627 
7628  return ret;
7629 }
7630 int MPI_File_set_size( MPI_File fh, MPI_Offset size )
7631 {
7632 
7633  /* Virtualize MPI */
7634 
7635 
7636  /* Pre instrum */
7637  int _rank = Stream_desc_get()->mpi_rank;
7638 
7639  struct MALP_Trace_Event _container;
7640 
7641  /********************************/
7642  /* FILL MPI EVENT */
7643  /********************************/
7644 
7645  _container.event.mpi_event.type =
7646  T_MPI_ENUM(MPI_FILE_SET_SIZE)
7647  ;
7648 
7649  /* Set default source & dest before override */
7650  _container.event.mpi_event.source = _rank;
7651  _container.event.mpi_event.dest = _rank;
7652 
7653 
7654 
7655 
7656 
7657 
7658 
7659 
7660  /* Fill in size informations if needed */
7661  int _size = 0;
7662  #if 0
7663 
7664  #endif
7665  _container.event.mpi_event.size = _size;
7666 
7667  /********************************/
7668  /* EMIT OTF ENTER */
7669  /********************************/
7670 
7671  struct MALP_Trace_Event otf_event;
7672 
7673  uint64_t _begin = Timer_tsc ();
7674 
7677  {
7678 
7679  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7680  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7681  MALP_EVENT_MPI, _container.event.mpi_event.type );
7682  Event_Packer_push(&otf_event);
7683  }
7684 
7685  /********************************/
7686  /* ACTUAL FUNCTION CALL */
7687  /********************************/
7688 
7690  int ret = PMPI_File_set_size( fh, size );
7692 
7693  /********************************/
7694  /* EMIT OTF END */
7695  /********************************/
7696 
7697  uint64_t _end = Timer_tsc();
7698  uint64_t _duration = _end - _begin;
7699 
7701  {
7703  {
7704 
7705  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7706  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7707  MALP_EVENT_MPI, _container.event.mpi_event.type );
7708 
7709 
7710  Event_Packer_push(&otf_event);
7711  }
7712 
7713  /********************************/
7714  /* EMIT MALP EVENT */
7715  /********************************/
7716 
7717  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7718 
7719  /* Submit event if MPI instrumented */
7720  Event_Packer_push(&_container);
7721  }
7722 
7723 
7724  return ret;
7725 }
7726 int MPI_File_preallocate( MPI_File fh, MPI_Offset size )
7727 {
7728 
7729  /* Virtualize MPI */
7730 
7731 
7732  /* Pre instrum */
7733  int _rank = Stream_desc_get()->mpi_rank;
7734 
7735  struct MALP_Trace_Event _container;
7736 
7737  /********************************/
7738  /* FILL MPI EVENT */
7739  /********************************/
7740 
7741  _container.event.mpi_event.type =
7742  T_MPI_ENUM(MPI_FILE_PREALLOCATE)
7743  ;
7744 
7745  /* Set default source & dest before override */
7746  _container.event.mpi_event.source = _rank;
7747  _container.event.mpi_event.dest = _rank;
7748 
7749 
7750 
7751 
7752 
7753 
7754 
7755 
7756  /* Fill in size informations if needed */
7757  int _size = 0;
7758  #if 0
7759 
7760  #endif
7761  _container.event.mpi_event.size = _size;
7762 
7763  /********************************/
7764  /* EMIT OTF ENTER */
7765  /********************************/
7766 
7767  struct MALP_Trace_Event otf_event;
7768 
7769  uint64_t _begin = Timer_tsc ();
7770 
7773  {
7774 
7775  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7776  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7777  MALP_EVENT_MPI, _container.event.mpi_event.type );
7778  Event_Packer_push(&otf_event);
7779  }
7780 
7781  /********************************/
7782  /* ACTUAL FUNCTION CALL */
7783  /********************************/
7784 
7786  int ret = PMPI_File_preallocate( fh, size );
7788 
7789  /********************************/
7790  /* EMIT OTF END */
7791  /********************************/
7792 
7793  uint64_t _end = Timer_tsc();
7794  uint64_t _duration = _end - _begin;
7795 
7797  {
7799  {
7800 
7801  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7802  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7803  MALP_EVENT_MPI, _container.event.mpi_event.type );
7804 
7805 
7806  Event_Packer_push(&otf_event);
7807  }
7808 
7809  /********************************/
7810  /* EMIT MALP EVENT */
7811  /********************************/
7812 
7813  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7814 
7815  /* Submit event if MPI instrumented */
7816  Event_Packer_push(&_container);
7817  }
7818 
7819 
7820  return ret;
7821 }
7822 int MPI_File_get_size( MPI_File fh, MPI_Offset * size )
7823 {
7824 
7825  /* Virtualize MPI */
7826 
7827 
7828  /* Pre instrum */
7829  int _rank = Stream_desc_get()->mpi_rank;
7830 
7831  struct MALP_Trace_Event _container;
7832 
7833  /********************************/
7834  /* FILL MPI EVENT */
7835  /********************************/
7836 
7837  _container.event.mpi_event.type =
7838  T_MPI_ENUM(MPI_FILE_GET_SIZE)
7839  ;
7840 
7841  /* Set default source & dest before override */
7842  _container.event.mpi_event.source = _rank;
7843  _container.event.mpi_event.dest = _rank;
7844 
7845 
7846 
7847 
7848 
7849 
7850 
7851 
7852  /* Fill in size informations if needed */
7853  int _size = 0;
7854  #if 0
7855 
7856  #endif
7857  _container.event.mpi_event.size = _size;
7858 
7859  /********************************/
7860  /* EMIT OTF ENTER */
7861  /********************************/
7862 
7863  struct MALP_Trace_Event otf_event;
7864 
7865  uint64_t _begin = Timer_tsc ();
7866 
7869  {
7870 
7871  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7872  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7873  MALP_EVENT_MPI, _container.event.mpi_event.type );
7874  Event_Packer_push(&otf_event);
7875  }
7876 
7877  /********************************/
7878  /* ACTUAL FUNCTION CALL */
7879  /********************************/
7880 
7882  int ret = PMPI_File_get_size( fh, size );
7884 
7885  /********************************/
7886  /* EMIT OTF END */
7887  /********************************/
7888 
7889  uint64_t _end = Timer_tsc();
7890  uint64_t _duration = _end - _begin;
7891 
7893  {
7895  {
7896 
7897  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7898  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7899  MALP_EVENT_MPI, _container.event.mpi_event.type );
7900 
7901 
7902  Event_Packer_push(&otf_event);
7903  }
7904 
7905  /********************************/
7906  /* EMIT MALP EVENT */
7907  /********************************/
7908 
7909  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
7910 
7911  /* Submit event if MPI instrumented */
7912  Event_Packer_push(&_container);
7913  }
7914 
7915 
7916  return ret;
7917 }
7918 int MPI_File_get_group( MPI_File fh, MPI_Group * group )
7919 {
7920 
7921  /* Virtualize MPI */
7922 
7923 
7924  /* Pre instrum */
7925  int _rank = Stream_desc_get()->mpi_rank;
7926 
7927  struct MALP_Trace_Event _container;
7928 
7929  /********************************/
7930  /* FILL MPI EVENT */
7931  /********************************/
7932 
7933  _container.event.mpi_event.type =
7934  T_MPI_ENUM(MPI_FILE_GET_GROUP)
7935  ;
7936 
7937  /* Set default source & dest before override */
7938  _container.event.mpi_event.source = _rank;
7939  _container.event.mpi_event.dest = _rank;
7940 
7941 
7942 
7943 
7944 
7945 
7946 
7947 
7948  /* Fill in size informations if needed */
7949  int _size = 0;
7950  #if 0
7951 
7952  #endif
7953  _container.event.mpi_event.size = _size;
7954 
7955  /********************************/
7956  /* EMIT OTF ENTER */
7957  /********************************/
7958 
7959  struct MALP_Trace_Event otf_event;
7960 
7961  uint64_t _begin = Timer_tsc ();
7962 
7965  {
7966 
7967  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
7968  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
7969  MALP_EVENT_MPI, _container.event.mpi_event.type );
7970  Event_Packer_push(&otf_event);
7971  }
7972 
7973  /********************************/
7974  /* ACTUAL FUNCTION CALL */
7975  /********************************/
7976 
7978  int ret = PMPI_File_get_group( fh, group );
7980 
7981  /********************************/
7982  /* EMIT OTF END */
7983  /********************************/
7984 
7985  uint64_t _end = Timer_tsc();
7986  uint64_t _duration = _end - _begin;
7987 
7989  {
7991  {
7992 
7993  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
7994  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
7995  MALP_EVENT_MPI, _container.event.mpi_event.type );
7996 
7997 
7998  Event_Packer_push(&otf_event);
7999  }
8000 
8001  /********************************/
8002  /* EMIT MALP EVENT */
8003  /********************************/
8004 
8005  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8006 
8007  /* Submit event if MPI instrumented */
8008  Event_Packer_push(&_container);
8009  }
8010 
8011 
8012  return ret;
8013 }
8014 int MPI_File_get_amode( MPI_File fh, int * amode )
8015 {
8016 
8017  /* Virtualize MPI */
8018 
8019 
8020  /* Pre instrum */
8021  int _rank = Stream_desc_get()->mpi_rank;
8022 
8023  struct MALP_Trace_Event _container;
8024 
8025  /********************************/
8026  /* FILL MPI EVENT */
8027  /********************************/
8028 
8029  _container.event.mpi_event.type =
8030  T_MPI_ENUM(MPI_FILE_GET_AMODE)
8031  ;
8032 
8033  /* Set default source & dest before override */
8034  _container.event.mpi_event.source = _rank;
8035  _container.event.mpi_event.dest = _rank;
8036 
8037 
8038 
8039 
8040 
8041 
8042 
8043 
8044  /* Fill in size informations if needed */
8045  int _size = 0;
8046  #if 0
8047 
8048  #endif
8049  _container.event.mpi_event.size = _size;
8050 
8051  /********************************/
8052  /* EMIT OTF ENTER */
8053  /********************************/
8054 
8055  struct MALP_Trace_Event otf_event;
8056 
8057  uint64_t _begin = Timer_tsc ();
8058 
8061  {
8062 
8063  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8064  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8065  MALP_EVENT_MPI, _container.event.mpi_event.type );
8066  Event_Packer_push(&otf_event);
8067  }
8068 
8069  /********************************/
8070  /* ACTUAL FUNCTION CALL */
8071  /********************************/
8072 
8074  int ret = PMPI_File_get_amode( fh, amode );
8076 
8077  /********************************/
8078  /* EMIT OTF END */
8079  /********************************/
8080 
8081  uint64_t _end = Timer_tsc();
8082  uint64_t _duration = _end - _begin;
8083 
8085  {
8087  {
8088 
8089  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8090  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8091  MALP_EVENT_MPI, _container.event.mpi_event.type );
8092 
8093 
8094  Event_Packer_push(&otf_event);
8095  }
8096 
8097  /********************************/
8098  /* EMIT MALP EVENT */
8099  /********************************/
8100 
8101  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8102 
8103  /* Submit event if MPI instrumented */
8104  Event_Packer_push(&_container);
8105  }
8106 
8107 
8108  return ret;
8109 }
8110 int MPI_File_set_info( MPI_File fh, MPI_Info info )
8111 {
8112 
8113  /* Virtualize MPI */
8114 
8115 
8116  /* Pre instrum */
8117  int _rank = Stream_desc_get()->mpi_rank;
8118 
8119  struct MALP_Trace_Event _container;
8120 
8121  /********************************/
8122  /* FILL MPI EVENT */
8123  /********************************/
8124 
8125  _container.event.mpi_event.type =
8126  T_MPI_ENUM(MPI_FILE_SET_INFO)
8127  ;
8128 
8129  /* Set default source & dest before override */
8130  _container.event.mpi_event.source = _rank;
8131  _container.event.mpi_event.dest = _rank;
8132 
8133 
8134 
8135 
8136 
8137 
8138 
8139 
8140  /* Fill in size informations if needed */
8141  int _size = 0;
8142  #if 0
8143 
8144  #endif
8145  _container.event.mpi_event.size = _size;
8146 
8147  /********************************/
8148  /* EMIT OTF ENTER */
8149  /********************************/
8150 
8151  struct MALP_Trace_Event otf_event;
8152 
8153  uint64_t _begin = Timer_tsc ();
8154 
8157  {
8158 
8159  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8160  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8161  MALP_EVENT_MPI, _container.event.mpi_event.type );
8162  Event_Packer_push(&otf_event);
8163  }
8164 
8165  /********************************/
8166  /* ACTUAL FUNCTION CALL */
8167  /********************************/
8168 
8170  int ret = PMPI_File_set_info( fh, info );
8172 
8173  /********************************/
8174  /* EMIT OTF END */
8175  /********************************/
8176 
8177  uint64_t _end = Timer_tsc();
8178  uint64_t _duration = _end - _begin;
8179 
8181  {
8183  {
8184 
8185  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8186  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8187  MALP_EVENT_MPI, _container.event.mpi_event.type );
8188 
8189 
8190  Event_Packer_push(&otf_event);
8191  }
8192 
8193  /********************************/
8194  /* EMIT MALP EVENT */
8195  /********************************/
8196 
8197  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8198 
8199  /* Submit event if MPI instrumented */
8200  Event_Packer_push(&_container);
8201  }
8202 
8203 
8204  return ret;
8205 }
8206 int MPI_File_get_info( MPI_File fh, MPI_Info * info_used )
8207 {
8208 
8209  /* Virtualize MPI */
8210 
8211 
8212  /* Pre instrum */
8213  int _rank = Stream_desc_get()->mpi_rank;
8214 
8215  struct MALP_Trace_Event _container;
8216 
8217  /********************************/
8218  /* FILL MPI EVENT */
8219  /********************************/
8220 
8221  _container.event.mpi_event.type =
8222  T_MPI_ENUM(MPI_FILE_GET_INFO)
8223  ;
8224 
8225  /* Set default source & dest before override */
8226  _container.event.mpi_event.source = _rank;
8227  _container.event.mpi_event.dest = _rank;
8228 
8229 
8230 
8231 
8232 
8233 
8234 
8235 
8236  /* Fill in size informations if needed */
8237  int _size = 0;
8238  #if 0
8239 
8240  #endif
8241  _container.event.mpi_event.size = _size;
8242 
8243  /********************************/
8244  /* EMIT OTF ENTER */
8245  /********************************/
8246 
8247  struct MALP_Trace_Event otf_event;
8248 
8249  uint64_t _begin = Timer_tsc ();
8250 
8253  {
8254 
8255  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8256  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8257  MALP_EVENT_MPI, _container.event.mpi_event.type );
8258  Event_Packer_push(&otf_event);
8259  }
8260 
8261  /********************************/
8262  /* ACTUAL FUNCTION CALL */
8263  /********************************/
8264 
8266  int ret = PMPI_File_get_info( fh, info_used );
8268 
8269  /********************************/
8270  /* EMIT OTF END */
8271  /********************************/
8272 
8273  uint64_t _end = Timer_tsc();
8274  uint64_t _duration = _end - _begin;
8275 
8277  {
8279  {
8280 
8281  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8282  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8283  MALP_EVENT_MPI, _container.event.mpi_event.type );
8284 
8285 
8286  Event_Packer_push(&otf_event);
8287  }
8288 
8289  /********************************/
8290  /* EMIT MALP EVENT */
8291  /********************************/
8292 
8293  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8294 
8295  /* Submit event if MPI instrumented */
8296  Event_Packer_push(&_container);
8297  }
8298 
8299 
8300  return ret;
8301 }
8302 int MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, char * datarep, MPI_Info info )
8303 {
8304 
8305  /* Virtualize MPI */
8306 
8307 
8308  /* Pre instrum */
8309  int _rank = Stream_desc_get()->mpi_rank;
8310 
8311  struct MALP_Trace_Event _container;
8312 
8313  /********************************/
8314  /* FILL MPI EVENT */
8315  /********************************/
8316 
8317  _container.event.mpi_event.type =
8318  T_MPI_ENUM(MPI_FILE_SET_VIEW)
8319  ;
8320 
8321  /* Set default source & dest before override */
8322  _container.event.mpi_event.source = _rank;
8323  _container.event.mpi_event.dest = _rank;
8324 
8325 
8326 
8327 
8328 
8329 
8330 
8331 
8332  /* Fill in size informations if needed */
8333  int _size = 0;
8334  #if 0
8335 
8336  #endif
8337  _container.event.mpi_event.size = _size;
8338 
8339  /********************************/
8340  /* EMIT OTF ENTER */
8341  /********************************/
8342 
8343  struct MALP_Trace_Event otf_event;
8344 
8345  uint64_t _begin = Timer_tsc ();
8346 
8349  {
8350 
8351  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8352  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8353  MALP_EVENT_MPI, _container.event.mpi_event.type );
8354  Event_Packer_push(&otf_event);
8355  }
8356 
8357  /********************************/
8358  /* ACTUAL FUNCTION CALL */
8359  /********************************/
8360 
8362  int ret = PMPI_File_set_view( fh, disp, etype, filetype, datarep, info );
8364 
8365  /********************************/
8366  /* EMIT OTF END */
8367  /********************************/
8368 
8369  uint64_t _end = Timer_tsc();
8370  uint64_t _duration = _end - _begin;
8371 
8373  {
8375  {
8376 
8377  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8378  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8379  MALP_EVENT_MPI, _container.event.mpi_event.type );
8380 
8381 
8382  Event_Packer_push(&otf_event);
8383  }
8384 
8385  /********************************/
8386  /* EMIT MALP EVENT */
8387  /********************************/
8388 
8389  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8390 
8391  /* Submit event if MPI instrumented */
8392  Event_Packer_push(&_container);
8393  }
8394 
8395 
8396  return ret;
8397 }
8398 int MPI_File_get_view( MPI_File fh, MPI_Offset * disp, MPI_Datatype * etype, MPI_Datatype * filetype, char * datarep )
8399 {
8400 
8401  /* Virtualize MPI */
8402 
8403 
8404  /* Pre instrum */
8405  int _rank = Stream_desc_get()->mpi_rank;
8406 
8407  struct MALP_Trace_Event _container;
8408 
8409  /********************************/
8410  /* FILL MPI EVENT */
8411  /********************************/
8412 
8413  _container.event.mpi_event.type =
8414  T_MPI_ENUM(MPI_FILE_GET_VIEW)
8415  ;
8416 
8417  /* Set default source & dest before override */
8418  _container.event.mpi_event.source = _rank;
8419  _container.event.mpi_event.dest = _rank;
8420 
8421 
8422 
8423 
8424 
8425 
8426 
8427 
8428  /* Fill in size informations if needed */
8429  int _size = 0;
8430  #if 0
8431 
8432  #endif
8433  _container.event.mpi_event.size = _size;
8434 
8435  /********************************/
8436  /* EMIT OTF ENTER */
8437  /********************************/
8438 
8439  struct MALP_Trace_Event otf_event;
8440 
8441  uint64_t _begin = Timer_tsc ();
8442 
8445  {
8446 
8447  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8448  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8449  MALP_EVENT_MPI, _container.event.mpi_event.type );
8450  Event_Packer_push(&otf_event);
8451  }
8452 
8453  /********************************/
8454  /* ACTUAL FUNCTION CALL */
8455  /********************************/
8456 
8458  int ret = PMPI_File_get_view( fh, disp, etype, filetype, datarep );
8460 
8461  /********************************/
8462  /* EMIT OTF END */
8463  /********************************/
8464 
8465  uint64_t _end = Timer_tsc();
8466  uint64_t _duration = _end - _begin;
8467 
8469  {
8471  {
8472 
8473  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8474  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8475  MALP_EVENT_MPI, _container.event.mpi_event.type );
8476 
8477 
8478  Event_Packer_push(&otf_event);
8479  }
8480 
8481  /********************************/
8482  /* EMIT MALP EVENT */
8483  /********************************/
8484 
8485  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8486 
8487  /* Submit event if MPI instrumented */
8488  Event_Packer_push(&_container);
8489  }
8490 
8491 
8492  return ret;
8493 }
8494 int MPI_File_read_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
8495 {
8496 
8497  /* Virtualize MPI */
8498 
8499 
8500  /* Pre instrum */
8501  int _rank = Stream_desc_get()->mpi_rank;
8502 
8503  struct MALP_Trace_Event _container;
8504 
8505  /********************************/
8506  /* FILL MPI EVENT */
8507  /********************************/
8508 
8509  _container.event.mpi_event.type =
8510  T_MPI_ENUM(MPI_FILE_READ_AT)
8511  ;
8512 
8513  /* Set default source & dest before override */
8514  _container.event.mpi_event.source = _rank;
8515  _container.event.mpi_event.dest = _rank;
8516 
8517 
8518 
8519 
8520  SET_COUNT (count)
8521  SET_DATATYPE (datatype)
8522 
8523 
8524  /* Fill in size informations if needed */
8525  int _size = 0;
8526  #if 1
8527  COMP_SIZE (count)
8528  #endif
8529  _container.event.mpi_event.size = _size;
8530 
8531  /********************************/
8532  /* EMIT OTF ENTER */
8533  /********************************/
8534 
8535  struct MALP_Trace_Event otf_event;
8536 
8537  uint64_t _begin = Timer_tsc ();
8538 
8541  {
8542 
8543  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8544  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8545  MALP_EVENT_MPI, _container.event.mpi_event.type );
8546  Event_Packer_push(&otf_event);
8547  }
8548 
8549  /********************************/
8550  /* ACTUAL FUNCTION CALL */
8551  /********************************/
8552 
8554  int ret = PMPI_File_read_at( fh, offset, buf, count, datatype, status );
8556 
8557  /********************************/
8558  /* EMIT OTF END */
8559  /********************************/
8560 
8561  uint64_t _end = Timer_tsc();
8562  uint64_t _duration = _end - _begin;
8563 
8565  {
8567  {
8568 
8569  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8570  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8571  MALP_EVENT_MPI, _container.event.mpi_event.type );
8572 
8573 
8574  Event_Packer_push(&otf_event);
8575  }
8576 
8577  /********************************/
8578  /* EMIT MALP EVENT */
8579  /********************************/
8580 
8581  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8582 
8583  /* Submit event if MPI instrumented */
8584  Event_Packer_push(&_container);
8585  }
8586 
8587 
8588  return ret;
8589 }
8590 int MPI_File_read_at_all( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
8591 {
8592 
8593  /* Virtualize MPI */
8594 
8595 
8596  /* Pre instrum */
8597  int _rank = Stream_desc_get()->mpi_rank;
8598 
8599  struct MALP_Trace_Event _container;
8600 
8601  /********************************/
8602  /* FILL MPI EVENT */
8603  /********************************/
8604 
8605  _container.event.mpi_event.type =
8606  T_MPI_ENUM(MPI_FILE_READ_AT_ALL)
8607  ;
8608 
8609  /* Set default source & dest before override */
8610  _container.event.mpi_event.source = _rank;
8611  _container.event.mpi_event.dest = _rank;
8612 
8613 
8614 
8615 
8616  SET_COUNT (count)
8617  SET_DATATYPE (datatype)
8618 
8619 
8620  /* Fill in size informations if needed */
8621  int _size = 0;
8622  #if 1
8623  COMP_SIZE (count)
8624  #endif
8625  _container.event.mpi_event.size = _size;
8626 
8627  /********************************/
8628  /* EMIT OTF ENTER */
8629  /********************************/
8630 
8631  struct MALP_Trace_Event otf_event;
8632 
8633  uint64_t _begin = Timer_tsc ();
8634 
8637  {
8638 
8639  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8640  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8641  MALP_EVENT_MPI, _container.event.mpi_event.type );
8642  Event_Packer_push(&otf_event);
8643  }
8644 
8645  /********************************/
8646  /* ACTUAL FUNCTION CALL */
8647  /********************************/
8648 
8650  int ret = PMPI_File_read_at_all( fh, offset, buf, count, datatype, status );
8652 
8653  /********************************/
8654  /* EMIT OTF END */
8655  /********************************/
8656 
8657  uint64_t _end = Timer_tsc();
8658  uint64_t _duration = _end - _begin;
8659 
8661  {
8663  {
8664 
8665  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8666  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8667  MALP_EVENT_MPI, _container.event.mpi_event.type );
8668 
8669 
8670  Event_Packer_push(&otf_event);
8671  }
8672 
8673  /********************************/
8674  /* EMIT MALP EVENT */
8675  /********************************/
8676 
8677  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8678 
8679  /* Submit event if MPI instrumented */
8680  Event_Packer_push(&_container);
8681  }
8682 
8683 
8684  return ret;
8685 }
8686 int MPI_File_write_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
8687 {
8688 
8689  /* Virtualize MPI */
8690 
8691 
8692  /* Pre instrum */
8693  int _rank = Stream_desc_get()->mpi_rank;
8694 
8695  struct MALP_Trace_Event _container;
8696 
8697  /********************************/
8698  /* FILL MPI EVENT */
8699  /********************************/
8700 
8701  _container.event.mpi_event.type =
8702  T_MPI_ENUM(MPI_FILE_WRITE_AT)
8703  ;
8704 
8705  /* Set default source & dest before override */
8706  _container.event.mpi_event.source = _rank;
8707  _container.event.mpi_event.dest = _rank;
8708 
8709 
8710 
8711 
8712  SET_COUNT (count)
8713  SET_DATATYPE (datatype)
8714 
8715 
8716  /* Fill in size informations if needed */
8717  int _size = 0;
8718  #if 1
8719  COMP_SIZE (count)
8720  #endif
8721  _container.event.mpi_event.size = _size;
8722 
8723  /********************************/
8724  /* EMIT OTF ENTER */
8725  /********************************/
8726 
8727  struct MALP_Trace_Event otf_event;
8728 
8729  uint64_t _begin = Timer_tsc ();
8730 
8733  {
8734 
8735  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8736  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8737  MALP_EVENT_MPI, _container.event.mpi_event.type );
8738  Event_Packer_push(&otf_event);
8739  }
8740 
8741  /********************************/
8742  /* ACTUAL FUNCTION CALL */
8743  /********************************/
8744 
8746  int ret = PMPI_File_write_at( fh, offset, buf, count, datatype, status );
8748 
8749  /********************************/
8750  /* EMIT OTF END */
8751  /********************************/
8752 
8753  uint64_t _end = Timer_tsc();
8754  uint64_t _duration = _end - _begin;
8755 
8757  {
8759  {
8760 
8761  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8762  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8763  MALP_EVENT_MPI, _container.event.mpi_event.type );
8764 
8765 
8766  Event_Packer_push(&otf_event);
8767  }
8768 
8769  /********************************/
8770  /* EMIT MALP EVENT */
8771  /********************************/
8772 
8773  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8774 
8775  /* Submit event if MPI instrumented */
8776  Event_Packer_push(&_container);
8777  }
8778 
8779 
8780  return ret;
8781 }
8782 int MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
8783 {
8784 
8785  /* Virtualize MPI */
8786 
8787 
8788  /* Pre instrum */
8789  int _rank = Stream_desc_get()->mpi_rank;
8790 
8791  struct MALP_Trace_Event _container;
8792 
8793  /********************************/
8794  /* FILL MPI EVENT */
8795  /********************************/
8796 
8797  _container.event.mpi_event.type =
8798  T_MPI_ENUM(MPI_FILE_WRITE_AT_ALL)
8799  ;
8800 
8801  /* Set default source & dest before override */
8802  _container.event.mpi_event.source = _rank;
8803  _container.event.mpi_event.dest = _rank;
8804 
8805 
8806 
8807 
8808  SET_COUNT (count)
8809  SET_DATATYPE (datatype)
8810 
8811 
8812  /* Fill in size informations if needed */
8813  int _size = 0;
8814  #if 1
8815  COMP_SIZE (count)
8816  #endif
8817  _container.event.mpi_event.size = _size;
8818 
8819  /********************************/
8820  /* EMIT OTF ENTER */
8821  /********************************/
8822 
8823  struct MALP_Trace_Event otf_event;
8824 
8825  uint64_t _begin = Timer_tsc ();
8826 
8829  {
8830 
8831  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8832  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8833  MALP_EVENT_MPI, _container.event.mpi_event.type );
8834  Event_Packer_push(&otf_event);
8835  }
8836 
8837  /********************************/
8838  /* ACTUAL FUNCTION CALL */
8839  /********************************/
8840 
8842  int ret = PMPI_File_write_at_all( fh, offset, buf, count, datatype, status );
8844 
8845  /********************************/
8846  /* EMIT OTF END */
8847  /********************************/
8848 
8849  uint64_t _end = Timer_tsc();
8850  uint64_t _duration = _end - _begin;
8851 
8853  {
8855  {
8856 
8857  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8858  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8859  MALP_EVENT_MPI, _container.event.mpi_event.type );
8860 
8861 
8862  Event_Packer_push(&otf_event);
8863  }
8864 
8865  /********************************/
8866  /* EMIT MALP EVENT */
8867  /********************************/
8868 
8869  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8870 
8871  /* Submit event if MPI instrumented */
8872  Event_Packer_push(&_container);
8873  }
8874 
8875 
8876  return ret;
8877 }
8878 int MPI_File_iread_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
8879 {
8880 
8881  /* Virtualize MPI */
8882 
8883 
8884  /* Pre instrum */
8885  int _rank = Stream_desc_get()->mpi_rank;
8886 
8887  struct MALP_Trace_Event _container;
8888 
8889  /********************************/
8890  /* FILL MPI EVENT */
8891  /********************************/
8892 
8893  _container.event.mpi_event.type =
8894  T_MPI_ENUM(MPI_FILE_IREAD_AT)
8895  ;
8896 
8897  /* Set default source & dest before override */
8898  _container.event.mpi_event.source = _rank;
8899  _container.event.mpi_event.dest = _rank;
8900 
8901 
8902 
8903 
8904  SET_COUNT (count)
8905  SET_DATATYPE (datatype)
8906 
8907 
8908  /* Fill in size informations if needed */
8909  int _size = 0;
8910  #if 1
8911  COMP_SIZE (count)
8912  #endif
8913  _container.event.mpi_event.size = _size;
8914 
8915  /********************************/
8916  /* EMIT OTF ENTER */
8917  /********************************/
8918 
8919  struct MALP_Trace_Event otf_event;
8920 
8921  uint64_t _begin = Timer_tsc ();
8922 
8925  {
8926 
8927  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
8928  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
8929  MALP_EVENT_MPI, _container.event.mpi_event.type );
8930  Event_Packer_push(&otf_event);
8931  }
8932 
8933  /********************************/
8934  /* ACTUAL FUNCTION CALL */
8935  /********************************/
8936 
8938  int ret = PMPI_File_iread_at( fh, offset, buf, count, datatype, request );
8940 
8941  /********************************/
8942  /* EMIT OTF END */
8943  /********************************/
8944 
8945  uint64_t _end = Timer_tsc();
8946  uint64_t _duration = _end - _begin;
8947 
8949  {
8951  {
8952 
8953  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
8954  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
8955  MALP_EVENT_MPI, _container.event.mpi_event.type );
8956 
8957 
8958  Event_Packer_push(&otf_event);
8959  }
8960 
8961  /********************************/
8962  /* EMIT MALP EVENT */
8963  /********************************/
8964 
8965  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
8966 
8967  /* Submit event if MPI instrumented */
8968  Event_Packer_push(&_container);
8969  }
8970 
8971 
8972  return ret;
8973 }
8974 int MPI_File_iwrite_at( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
8975 {
8976 
8977  /* Virtualize MPI */
8978 
8979 
8980  /* Pre instrum */
8981  int _rank = Stream_desc_get()->mpi_rank;
8982 
8983  struct MALP_Trace_Event _container;
8984 
8985  /********************************/
8986  /* FILL MPI EVENT */
8987  /********************************/
8988 
8989  _container.event.mpi_event.type =
8990  T_MPI_ENUM(MPI_FILE_IWRITE_AT)
8991  ;
8992 
8993  /* Set default source & dest before override */
8994  _container.event.mpi_event.source = _rank;
8995  _container.event.mpi_event.dest = _rank;
8996 
8997 
8998 
8999 
9000  SET_COUNT (count)
9001  SET_DATATYPE (datatype)
9002 
9003 
9004  /* Fill in size informations if needed */
9005  int _size = 0;
9006  #if 1
9007  COMP_SIZE (count)
9008  #endif
9009  _container.event.mpi_event.size = _size;
9010 
9011  /********************************/
9012  /* EMIT OTF ENTER */
9013  /********************************/
9014 
9015  struct MALP_Trace_Event otf_event;
9016 
9017  uint64_t _begin = Timer_tsc ();
9018 
9021  {
9022 
9023  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9024  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9025  MALP_EVENT_MPI, _container.event.mpi_event.type );
9026  Event_Packer_push(&otf_event);
9027  }
9028 
9029  /********************************/
9030  /* ACTUAL FUNCTION CALL */
9031  /********************************/
9032 
9034  int ret = PMPI_File_iwrite_at( fh, offset, buf, count, datatype, request );
9036 
9037  /********************************/
9038  /* EMIT OTF END */
9039  /********************************/
9040 
9041  uint64_t _end = Timer_tsc();
9042  uint64_t _duration = _end - _begin;
9043 
9045  {
9047  {
9048 
9049  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9050  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9051  MALP_EVENT_MPI, _container.event.mpi_event.type );
9052 
9053 
9054  Event_Packer_push(&otf_event);
9055  }
9056 
9057  /********************************/
9058  /* EMIT MALP EVENT */
9059  /********************************/
9060 
9061  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9062 
9063  /* Submit event if MPI instrumented */
9064  Event_Packer_push(&_container);
9065  }
9066 
9067 
9068  return ret;
9069 }
9070 int MPI_File_read( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
9071 {
9072 
9073  /* Virtualize MPI */
9074 
9075 
9076  /* Pre instrum */
9077  int _rank = Stream_desc_get()->mpi_rank;
9078 
9079  struct MALP_Trace_Event _container;
9080 
9081  /********************************/
9082  /* FILL MPI EVENT */
9083  /********************************/
9084 
9085  _container.event.mpi_event.type =
9086  T_MPI_ENUM(MPI_FILE_READ)
9087  ;
9088 
9089  /* Set default source & dest before override */
9090  _container.event.mpi_event.source = _rank;
9091  _container.event.mpi_event.dest = _rank;
9092 
9093 
9094 
9095 
9096  SET_COUNT (count)
9097  SET_DATATYPE (datatype)
9098 
9099 
9100  /* Fill in size informations if needed */
9101  int _size = 0;
9102  #if 1
9103  COMP_SIZE (count)
9104  #endif
9105  _container.event.mpi_event.size = _size;
9106 
9107  /********************************/
9108  /* EMIT OTF ENTER */
9109  /********************************/
9110 
9111  struct MALP_Trace_Event otf_event;
9112 
9113  uint64_t _begin = Timer_tsc ();
9114 
9117  {
9118 
9119  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9120  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9121  MALP_EVENT_MPI, _container.event.mpi_event.type );
9122  Event_Packer_push(&otf_event);
9123  }
9124 
9125  /********************************/
9126  /* ACTUAL FUNCTION CALL */
9127  /********************************/
9128 
9130  int ret = PMPI_File_read( fh, buf, count, datatype, status );
9132 
9133  /********************************/
9134  /* EMIT OTF END */
9135  /********************************/
9136 
9137  uint64_t _end = Timer_tsc();
9138  uint64_t _duration = _end - _begin;
9139 
9141  {
9143  {
9144 
9145  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9146  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9147  MALP_EVENT_MPI, _container.event.mpi_event.type );
9148 
9149 
9150  Event_Packer_push(&otf_event);
9151  }
9152 
9153  /********************************/
9154  /* EMIT MALP EVENT */
9155  /********************************/
9156 
9157  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9158 
9159  /* Submit event if MPI instrumented */
9160  Event_Packer_push(&_container);
9161  }
9162 
9163 
9164  return ret;
9165 }
9166 int MPI_File_read_all( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
9167 {
9168 
9169  /* Virtualize MPI */
9170 
9171 
9172  /* Pre instrum */
9173  int _rank = Stream_desc_get()->mpi_rank;
9174 
9175  struct MALP_Trace_Event _container;
9176 
9177  /********************************/
9178  /* FILL MPI EVENT */
9179  /********************************/
9180 
9181  _container.event.mpi_event.type =
9182  T_MPI_ENUM(MPI_FILE_READ_ALL)
9183  ;
9184 
9185  /* Set default source & dest before override */
9186  _container.event.mpi_event.source = _rank;
9187  _container.event.mpi_event.dest = _rank;
9188 
9189 
9190 
9191 
9192  SET_COUNT (count)
9193  SET_DATATYPE (datatype)
9194 
9195 
9196  /* Fill in size informations if needed */
9197  int _size = 0;
9198  #if 1
9199  COMP_SIZE (count)
9200  #endif
9201  _container.event.mpi_event.size = _size;
9202 
9203  /********************************/
9204  /* EMIT OTF ENTER */
9205  /********************************/
9206 
9207  struct MALP_Trace_Event otf_event;
9208 
9209  uint64_t _begin = Timer_tsc ();
9210 
9213  {
9214 
9215  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9216  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9217  MALP_EVENT_MPI, _container.event.mpi_event.type );
9218  Event_Packer_push(&otf_event);
9219  }
9220 
9221  /********************************/
9222  /* ACTUAL FUNCTION CALL */
9223  /********************************/
9224 
9226  int ret = PMPI_File_read_all( fh, buf, count, datatype, status );
9228 
9229  /********************************/
9230  /* EMIT OTF END */
9231  /********************************/
9232 
9233  uint64_t _end = Timer_tsc();
9234  uint64_t _duration = _end - _begin;
9235 
9237  {
9239  {
9240 
9241  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9242  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9243  MALP_EVENT_MPI, _container.event.mpi_event.type );
9244 
9245 
9246  Event_Packer_push(&otf_event);
9247  }
9248 
9249  /********************************/
9250  /* EMIT MALP EVENT */
9251  /********************************/
9252 
9253  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9254 
9255  /* Submit event if MPI instrumented */
9256  Event_Packer_push(&_container);
9257  }
9258 
9259 
9260  return ret;
9261 }
9262 int MPI_File_write( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
9263 {
9264 
9265  /* Virtualize MPI */
9266 
9267 
9268  /* Pre instrum */
9269  int _rank = Stream_desc_get()->mpi_rank;
9270 
9271  struct MALP_Trace_Event _container;
9272 
9273  /********************************/
9274  /* FILL MPI EVENT */
9275  /********************************/
9276 
9277  _container.event.mpi_event.type =
9278  T_MPI_ENUM(MPI_FILE_WRITE)
9279  ;
9280 
9281  /* Set default source & dest before override */
9282  _container.event.mpi_event.source = _rank;
9283  _container.event.mpi_event.dest = _rank;
9284 
9285 
9286 
9287 
9288  SET_COUNT (count)
9289  SET_DATATYPE (datatype)
9290 
9291 
9292  /* Fill in size informations if needed */
9293  int _size = 0;
9294  #if 1
9295  COMP_SIZE (count)
9296  #endif
9297  _container.event.mpi_event.size = _size;
9298 
9299  /********************************/
9300  /* EMIT OTF ENTER */
9301  /********************************/
9302 
9303  struct MALP_Trace_Event otf_event;
9304 
9305  uint64_t _begin = Timer_tsc ();
9306 
9309  {
9310 
9311  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9312  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9313  MALP_EVENT_MPI, _container.event.mpi_event.type );
9314  Event_Packer_push(&otf_event);
9315  }
9316 
9317  /********************************/
9318  /* ACTUAL FUNCTION CALL */
9319  /********************************/
9320 
9322  int ret = PMPI_File_write( fh, buf, count, datatype, status );
9324 
9325  /********************************/
9326  /* EMIT OTF END */
9327  /********************************/
9328 
9329  uint64_t _end = Timer_tsc();
9330  uint64_t _duration = _end - _begin;
9331 
9333  {
9335  {
9336 
9337  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9338  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9339  MALP_EVENT_MPI, _container.event.mpi_event.type );
9340 
9341 
9342  Event_Packer_push(&otf_event);
9343  }
9344 
9345  /********************************/
9346  /* EMIT MALP EVENT */
9347  /********************************/
9348 
9349  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9350 
9351  /* Submit event if MPI instrumented */
9352  Event_Packer_push(&_container);
9353  }
9354 
9355 
9356  return ret;
9357 }
9358 int MPI_File_write_all( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
9359 {
9360 
9361  /* Virtualize MPI */
9362 
9363 
9364  /* Pre instrum */
9365  int _rank = Stream_desc_get()->mpi_rank;
9366 
9367  struct MALP_Trace_Event _container;
9368 
9369  /********************************/
9370  /* FILL MPI EVENT */
9371  /********************************/
9372 
9373  _container.event.mpi_event.type =
9374  T_MPI_ENUM(MPI_FILE_WRITE_ALL)
9375  ;
9376 
9377  /* Set default source & dest before override */
9378  _container.event.mpi_event.source = _rank;
9379  _container.event.mpi_event.dest = _rank;
9380 
9381 
9382 
9383 
9384  SET_COUNT (count)
9385  SET_DATATYPE (datatype)
9386 
9387 
9388  /* Fill in size informations if needed */
9389  int _size = 0;
9390  #if 1
9391  COMP_SIZE (count)
9392  #endif
9393  _container.event.mpi_event.size = _size;
9394 
9395  /********************************/
9396  /* EMIT OTF ENTER */
9397  /********************************/
9398 
9399  struct MALP_Trace_Event otf_event;
9400 
9401  uint64_t _begin = Timer_tsc ();
9402 
9405  {
9406 
9407  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9408  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9409  MALP_EVENT_MPI, _container.event.mpi_event.type );
9410  Event_Packer_push(&otf_event);
9411  }
9412 
9413  /********************************/
9414  /* ACTUAL FUNCTION CALL */
9415  /********************************/
9416 
9418  int ret = PMPI_File_write_all( fh, buf, count, datatype, status );
9420 
9421  /********************************/
9422  /* EMIT OTF END */
9423  /********************************/
9424 
9425  uint64_t _end = Timer_tsc();
9426  uint64_t _duration = _end - _begin;
9427 
9429  {
9431  {
9432 
9433  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9434  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9435  MALP_EVENT_MPI, _container.event.mpi_event.type );
9436 
9437 
9438  Event_Packer_push(&otf_event);
9439  }
9440 
9441  /********************************/
9442  /* EMIT MALP EVENT */
9443  /********************************/
9444 
9445  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9446 
9447  /* Submit event if MPI instrumented */
9448  Event_Packer_push(&_container);
9449  }
9450 
9451 
9452  return ret;
9453 }
9454 int MPI_File_iread( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
9455 {
9456 
9457  /* Virtualize MPI */
9458 
9459 
9460  /* Pre instrum */
9461  int _rank = Stream_desc_get()->mpi_rank;
9462 
9463  struct MALP_Trace_Event _container;
9464 
9465  /********************************/
9466  /* FILL MPI EVENT */
9467  /********************************/
9468 
9469  _container.event.mpi_event.type =
9470  T_MPI_ENUM(MPI_FILE_IREAD)
9471  ;
9472 
9473  /* Set default source & dest before override */
9474  _container.event.mpi_event.source = _rank;
9475  _container.event.mpi_event.dest = _rank;
9476 
9477 
9478 
9479 
9480  SET_COUNT (count)
9481  SET_DATATYPE (datatype)
9482 
9483 
9484  /* Fill in size informations if needed */
9485  int _size = 0;
9486  #if 1
9487  COMP_SIZE (count)
9488  #endif
9489  _container.event.mpi_event.size = _size;
9490 
9491  /********************************/
9492  /* EMIT OTF ENTER */
9493  /********************************/
9494 
9495  struct MALP_Trace_Event otf_event;
9496 
9497  uint64_t _begin = Timer_tsc ();
9498 
9501  {
9502 
9503  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9504  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9505  MALP_EVENT_MPI, _container.event.mpi_event.type );
9506  Event_Packer_push(&otf_event);
9507  }
9508 
9509  /********************************/
9510  /* ACTUAL FUNCTION CALL */
9511  /********************************/
9512 
9514  int ret = PMPI_File_iread( fh, buf, count, datatype, request );
9516 
9517  /********************************/
9518  /* EMIT OTF END */
9519  /********************************/
9520 
9521  uint64_t _end = Timer_tsc();
9522  uint64_t _duration = _end - _begin;
9523 
9525  {
9527  {
9528 
9529  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9530  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9531  MALP_EVENT_MPI, _container.event.mpi_event.type );
9532 
9533 
9534  Event_Packer_push(&otf_event);
9535  }
9536 
9537  /********************************/
9538  /* EMIT MALP EVENT */
9539  /********************************/
9540 
9541  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9542 
9543  /* Submit event if MPI instrumented */
9544  Event_Packer_push(&_container);
9545  }
9546 
9547 
9548  return ret;
9549 }
9550 int MPI_File_iwrite( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
9551 {
9552 
9553  /* Virtualize MPI */
9554 
9555 
9556  /* Pre instrum */
9557  int _rank = Stream_desc_get()->mpi_rank;
9558 
9559  struct MALP_Trace_Event _container;
9560 
9561  /********************************/
9562  /* FILL MPI EVENT */
9563  /********************************/
9564 
9565  _container.event.mpi_event.type =
9566  T_MPI_ENUM(MPI_FILE_IWRITE)
9567  ;
9568 
9569  /* Set default source & dest before override */
9570  _container.event.mpi_event.source = _rank;
9571  _container.event.mpi_event.dest = _rank;
9572 
9573 
9574 
9575 
9576  SET_COUNT (count)
9577  SET_DATATYPE (datatype)
9578 
9579 
9580  /* Fill in size informations if needed */
9581  int _size = 0;
9582  #if 1
9583  COMP_SIZE (count)
9584  #endif
9585  _container.event.mpi_event.size = _size;
9586 
9587  /********************************/
9588  /* EMIT OTF ENTER */
9589  /********************************/
9590 
9591  struct MALP_Trace_Event otf_event;
9592 
9593  uint64_t _begin = Timer_tsc ();
9594 
9597  {
9598 
9599  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9600  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9601  MALP_EVENT_MPI, _container.event.mpi_event.type );
9602  Event_Packer_push(&otf_event);
9603  }
9604 
9605  /********************************/
9606  /* ACTUAL FUNCTION CALL */
9607  /********************************/
9608 
9610  int ret = PMPI_File_iwrite( fh, buf, count, datatype, request );
9612 
9613  /********************************/
9614  /* EMIT OTF END */
9615  /********************************/
9616 
9617  uint64_t _end = Timer_tsc();
9618  uint64_t _duration = _end - _begin;
9619 
9621  {
9623  {
9624 
9625  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9626  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9627  MALP_EVENT_MPI, _container.event.mpi_event.type );
9628 
9629 
9630  Event_Packer_push(&otf_event);
9631  }
9632 
9633  /********************************/
9634  /* EMIT MALP EVENT */
9635  /********************************/
9636 
9637  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9638 
9639  /* Submit event if MPI instrumented */
9640  Event_Packer_push(&_container);
9641  }
9642 
9643 
9644  return ret;
9645 }
9646 int MPI_File_seek( MPI_File fh, MPI_Offset offset, int whence )
9647 {
9648 
9649  /* Virtualize MPI */
9650 
9651 
9652  /* Pre instrum */
9653  int _rank = Stream_desc_get()->mpi_rank;
9654 
9655  struct MALP_Trace_Event _container;
9656 
9657  /********************************/
9658  /* FILL MPI EVENT */
9659  /********************************/
9660 
9661  _container.event.mpi_event.type =
9662  T_MPI_ENUM(MPI_FILE_SEEK)
9663  ;
9664 
9665  /* Set default source & dest before override */
9666  _container.event.mpi_event.source = _rank;
9667  _container.event.mpi_event.dest = _rank;
9668 
9669 
9670 
9671 
9672 
9673 
9674 
9675 
9676  /* Fill in size informations if needed */
9677  int _size = 0;
9678  #if 0
9679 
9680  #endif
9681  _container.event.mpi_event.size = _size;
9682 
9683  /********************************/
9684  /* EMIT OTF ENTER */
9685  /********************************/
9686 
9687  struct MALP_Trace_Event otf_event;
9688 
9689  uint64_t _begin = Timer_tsc ();
9690 
9693  {
9694 
9695  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9696  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9697  MALP_EVENT_MPI, _container.event.mpi_event.type );
9698  Event_Packer_push(&otf_event);
9699  }
9700 
9701  /********************************/
9702  /* ACTUAL FUNCTION CALL */
9703  /********************************/
9704 
9706  int ret = PMPI_File_seek( fh, offset, whence );
9708 
9709  /********************************/
9710  /* EMIT OTF END */
9711  /********************************/
9712 
9713  uint64_t _end = Timer_tsc();
9714  uint64_t _duration = _end - _begin;
9715 
9717  {
9719  {
9720 
9721  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9722  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9723  MALP_EVENT_MPI, _container.event.mpi_event.type );
9724 
9725 
9726  Event_Packer_push(&otf_event);
9727  }
9728 
9729  /********************************/
9730  /* EMIT MALP EVENT */
9731  /********************************/
9732 
9733  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9734 
9735  /* Submit event if MPI instrumented */
9736  Event_Packer_push(&_container);
9737  }
9738 
9739 
9740  return ret;
9741 }
9742 int MPI_File_get_position( MPI_File fh, MPI_Offset * offset )
9743 {
9744 
9745  /* Virtualize MPI */
9746 
9747 
9748  /* Pre instrum */
9749  int _rank = Stream_desc_get()->mpi_rank;
9750 
9751  struct MALP_Trace_Event _container;
9752 
9753  /********************************/
9754  /* FILL MPI EVENT */
9755  /********************************/
9756 
9757  _container.event.mpi_event.type =
9758  T_MPI_ENUM(MPI_FILE_GET_POSITION)
9759  ;
9760 
9761  /* Set default source & dest before override */
9762  _container.event.mpi_event.source = _rank;
9763  _container.event.mpi_event.dest = _rank;
9764 
9765 
9766 
9767 
9768 
9769 
9770 
9771 
9772  /* Fill in size informations if needed */
9773  int _size = 0;
9774  #if 0
9775 
9776  #endif
9777  _container.event.mpi_event.size = _size;
9778 
9779  /********************************/
9780  /* EMIT OTF ENTER */
9781  /********************************/
9782 
9783  struct MALP_Trace_Event otf_event;
9784 
9785  uint64_t _begin = Timer_tsc ();
9786 
9789  {
9790 
9791  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9792  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9793  MALP_EVENT_MPI, _container.event.mpi_event.type );
9794  Event_Packer_push(&otf_event);
9795  }
9796 
9797  /********************************/
9798  /* ACTUAL FUNCTION CALL */
9799  /********************************/
9800 
9802  int ret = PMPI_File_get_position( fh, offset );
9804 
9805  /********************************/
9806  /* EMIT OTF END */
9807  /********************************/
9808 
9809  uint64_t _end = Timer_tsc();
9810  uint64_t _duration = _end - _begin;
9811 
9813  {
9815  {
9816 
9817  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9818  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9819  MALP_EVENT_MPI, _container.event.mpi_event.type );
9820 
9821 
9822  Event_Packer_push(&otf_event);
9823  }
9824 
9825  /********************************/
9826  /* EMIT MALP EVENT */
9827  /********************************/
9828 
9829  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9830 
9831  /* Submit event if MPI instrumented */
9832  Event_Packer_push(&_container);
9833  }
9834 
9835 
9836  return ret;
9837 }
9838 int MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset, MPI_Offset * disp )
9839 {
9840 
9841  /* Virtualize MPI */
9842 
9843 
9844  /* Pre instrum */
9845  int _rank = Stream_desc_get()->mpi_rank;
9846 
9847  struct MALP_Trace_Event _container;
9848 
9849  /********************************/
9850  /* FILL MPI EVENT */
9851  /********************************/
9852 
9853  _container.event.mpi_event.type =
9854  T_MPI_ENUM(MPI_FILE_GET_BYTE_OFFSET)
9855  ;
9856 
9857  /* Set default source & dest before override */
9858  _container.event.mpi_event.source = _rank;
9859  _container.event.mpi_event.dest = _rank;
9860 
9861 
9862 
9863 
9864 
9865 
9866 
9867 
9868  /* Fill in size informations if needed */
9869  int _size = 0;
9870  #if 0
9871 
9872  #endif
9873  _container.event.mpi_event.size = _size;
9874 
9875  /********************************/
9876  /* EMIT OTF ENTER */
9877  /********************************/
9878 
9879  struct MALP_Trace_Event otf_event;
9880 
9881  uint64_t _begin = Timer_tsc ();
9882 
9885  {
9886 
9887  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9888  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9889  MALP_EVENT_MPI, _container.event.mpi_event.type );
9890  Event_Packer_push(&otf_event);
9891  }
9892 
9893  /********************************/
9894  /* ACTUAL FUNCTION CALL */
9895  /********************************/
9896 
9898  int ret = PMPI_File_get_byte_offset( fh, offset, disp );
9900 
9901  /********************************/
9902  /* EMIT OTF END */
9903  /********************************/
9904 
9905  uint64_t _end = Timer_tsc();
9906  uint64_t _duration = _end - _begin;
9907 
9909  {
9911  {
9912 
9913  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
9914  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
9915  MALP_EVENT_MPI, _container.event.mpi_event.type );
9916 
9917 
9918  Event_Packer_push(&otf_event);
9919  }
9920 
9921  /********************************/
9922  /* EMIT MALP EVENT */
9923  /********************************/
9924 
9925  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
9926 
9927  /* Submit event if MPI instrumented */
9928  Event_Packer_push(&_container);
9929  }
9930 
9931 
9932  return ret;
9933 }
9934 int MPI_File_read_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
9935 {
9936 
9937  /* Virtualize MPI */
9938 
9939 
9940  /* Pre instrum */
9941  int _rank = Stream_desc_get()->mpi_rank;
9942 
9943  struct MALP_Trace_Event _container;
9944 
9945  /********************************/
9946  /* FILL MPI EVENT */
9947  /********************************/
9948 
9949  _container.event.mpi_event.type =
9950  T_MPI_ENUM(MPI_FILE_READ_SHARED)
9951  ;
9952 
9953  /* Set default source & dest before override */
9954  _container.event.mpi_event.source = _rank;
9955  _container.event.mpi_event.dest = _rank;
9956 
9957 
9958 
9959 
9960  SET_COUNT (count)
9961  SET_DATATYPE (datatype)
9962 
9963 
9964  /* Fill in size informations if needed */
9965  int _size = 0;
9966  #if 1
9967  COMP_SIZE (count)
9968  #endif
9969  _container.event.mpi_event.size = _size;
9970 
9971  /********************************/
9972  /* EMIT OTF ENTER */
9973  /********************************/
9974 
9975  struct MALP_Trace_Event otf_event;
9976 
9977  uint64_t _begin = Timer_tsc ();
9978 
9981  {
9982 
9983  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
9984  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
9985  MALP_EVENT_MPI, _container.event.mpi_event.type );
9986  Event_Packer_push(&otf_event);
9987  }
9988 
9989  /********************************/
9990  /* ACTUAL FUNCTION CALL */
9991  /********************************/
9992 
9994  int ret = PMPI_File_read_shared( fh, buf, count, datatype, status );
9996 
9997  /********************************/
9998  /* EMIT OTF END */
9999  /********************************/
10000 
10001  uint64_t _end = Timer_tsc();
10002  uint64_t _duration = _end - _begin;
10003 
10005  {
10007  {
10008 
10009  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10010  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10011  MALP_EVENT_MPI, _container.event.mpi_event.type );
10012 
10013 
10014  Event_Packer_push(&otf_event);
10015  }
10016 
10017  /********************************/
10018  /* EMIT MALP EVENT */
10019  /********************************/
10020 
10021  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10022 
10023  /* Submit event if MPI instrumented */
10024  Event_Packer_push(&_container);
10025  }
10026 
10027 
10028  return ret;
10029 }
10030 int MPI_File_write_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
10031 {
10032 
10033  /* Virtualize MPI */
10034 
10035 
10036  /* Pre instrum */
10037  int _rank = Stream_desc_get()->mpi_rank;
10038 
10039  struct MALP_Trace_Event _container;
10040 
10041  /********************************/
10042  /* FILL MPI EVENT */
10043  /********************************/
10044 
10045  _container.event.mpi_event.type =
10046  T_MPI_ENUM(MPI_FILE_WRITE_SHARED)
10047  ;
10048 
10049  /* Set default source & dest before override */
10050  _container.event.mpi_event.source = _rank;
10051  _container.event.mpi_event.dest = _rank;
10052 
10053 
10054 
10055 
10056  SET_COUNT (count)
10057  SET_DATATYPE (datatype)
10058 
10059 
10060  /* Fill in size informations if needed */
10061  int _size = 0;
10062  #if 1
10063  COMP_SIZE (count)
10064  #endif
10065  _container.event.mpi_event.size = _size;
10066 
10067  /********************************/
10068  /* EMIT OTF ENTER */
10069  /********************************/
10070 
10071  struct MALP_Trace_Event otf_event;
10072 
10073  uint64_t _begin = Timer_tsc ();
10074 
10077  {
10078 
10079  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10080  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10081  MALP_EVENT_MPI, _container.event.mpi_event.type );
10082  Event_Packer_push(&otf_event);
10083  }
10084 
10085  /********************************/
10086  /* ACTUAL FUNCTION CALL */
10087  /********************************/
10088 
10090  int ret = PMPI_File_write_shared( fh, buf, count, datatype, status );
10092 
10093  /********************************/
10094  /* EMIT OTF END */
10095  /********************************/
10096 
10097  uint64_t _end = Timer_tsc();
10098  uint64_t _duration = _end - _begin;
10099 
10101  {
10103  {
10104 
10105  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10106  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10107  MALP_EVENT_MPI, _container.event.mpi_event.type );
10108 
10109 
10110  Event_Packer_push(&otf_event);
10111  }
10112 
10113  /********************************/
10114  /* EMIT MALP EVENT */
10115  /********************************/
10116 
10117  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10118 
10119  /* Submit event if MPI instrumented */
10120  Event_Packer_push(&_container);
10121  }
10122 
10123 
10124  return ret;
10125 }
10126 int MPI_File_iread_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
10127 {
10128 
10129  /* Virtualize MPI */
10130 
10131 
10132  /* Pre instrum */
10133  int _rank = Stream_desc_get()->mpi_rank;
10134 
10135  struct MALP_Trace_Event _container;
10136 
10137  /********************************/
10138  /* FILL MPI EVENT */
10139  /********************************/
10140 
10141  _container.event.mpi_event.type =
10142  T_MPI_ENUM(MPI_FILE_IREAD_SHARED)
10143  ;
10144 
10145  /* Set default source & dest before override */
10146  _container.event.mpi_event.source = _rank;
10147  _container.event.mpi_event.dest = _rank;
10148 
10149 
10150 
10151 
10152  SET_COUNT (count)
10153  SET_DATATYPE (datatype)
10154 
10155 
10156  /* Fill in size informations if needed */
10157  int _size = 0;
10158  #if 1
10159  COMP_SIZE (count)
10160  #endif
10161  _container.event.mpi_event.size = _size;
10162 
10163  /********************************/
10164  /* EMIT OTF ENTER */
10165  /********************************/
10166 
10167  struct MALP_Trace_Event otf_event;
10168 
10169  uint64_t _begin = Timer_tsc ();
10170 
10173  {
10174 
10175  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10176  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10177  MALP_EVENT_MPI, _container.event.mpi_event.type );
10178  Event_Packer_push(&otf_event);
10179  }
10180 
10181  /********************************/
10182  /* ACTUAL FUNCTION CALL */
10183  /********************************/
10184 
10186  int ret = PMPI_File_iread_shared( fh, buf, count, datatype, request );
10188 
10189  /********************************/
10190  /* EMIT OTF END */
10191  /********************************/
10192 
10193  uint64_t _end = Timer_tsc();
10194  uint64_t _duration = _end - _begin;
10195 
10197  {
10199  {
10200 
10201  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10202  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10203  MALP_EVENT_MPI, _container.event.mpi_event.type );
10204 
10205 
10206  Event_Packer_push(&otf_event);
10207  }
10208 
10209  /********************************/
10210  /* EMIT MALP EVENT */
10211  /********************************/
10212 
10213  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10214 
10215  /* Submit event if MPI instrumented */
10216  Event_Packer_push(&_container);
10217  }
10218 
10219 
10220  return ret;
10221 }
10222 int MPI_File_iwrite_shared( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Request * request )
10223 {
10224 
10225  /* Virtualize MPI */
10226 
10227 
10228  /* Pre instrum */
10229  int _rank = Stream_desc_get()->mpi_rank;
10230 
10231  struct MALP_Trace_Event _container;
10232 
10233  /********************************/
10234  /* FILL MPI EVENT */
10235  /********************************/
10236 
10237  _container.event.mpi_event.type =
10238  T_MPI_ENUM(MPI_FILE_IWRITE_SHARED)
10239  ;
10240 
10241  /* Set default source & dest before override */
10242  _container.event.mpi_event.source = _rank;
10243  _container.event.mpi_event.dest = _rank;
10244 
10245 
10246 
10247 
10248  SET_COUNT (count)
10249  SET_DATATYPE (datatype)
10250 
10251 
10252  /* Fill in size informations if needed */
10253  int _size = 0;
10254  #if 1
10255  COMP_SIZE (count)
10256  #endif
10257  _container.event.mpi_event.size = _size;
10258 
10259  /********************************/
10260  /* EMIT OTF ENTER */
10261  /********************************/
10262 
10263  struct MALP_Trace_Event otf_event;
10264 
10265  uint64_t _begin = Timer_tsc ();
10266 
10269  {
10270 
10271  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10272  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10273  MALP_EVENT_MPI, _container.event.mpi_event.type );
10274  Event_Packer_push(&otf_event);
10275  }
10276 
10277  /********************************/
10278  /* ACTUAL FUNCTION CALL */
10279  /********************************/
10280 
10282  int ret = PMPI_File_iwrite_shared( fh, buf, count, datatype, request );
10284 
10285  /********************************/
10286  /* EMIT OTF END */
10287  /********************************/
10288 
10289  uint64_t _end = Timer_tsc();
10290  uint64_t _duration = _end - _begin;
10291 
10293  {
10295  {
10296 
10297  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10298  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10299  MALP_EVENT_MPI, _container.event.mpi_event.type );
10300 
10301 
10302  Event_Packer_push(&otf_event);
10303  }
10304 
10305  /********************************/
10306  /* EMIT MALP EVENT */
10307  /********************************/
10308 
10309  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10310 
10311  /* Submit event if MPI instrumented */
10312  Event_Packer_push(&_container);
10313  }
10314 
10315 
10316  return ret;
10317 }
10318 int MPI_File_read_ordered( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
10319 {
10320 
10321  /* Virtualize MPI */
10322 
10323 
10324  /* Pre instrum */
10325  int _rank = Stream_desc_get()->mpi_rank;
10326 
10327  struct MALP_Trace_Event _container;
10328 
10329  /********************************/
10330  /* FILL MPI EVENT */
10331  /********************************/
10332 
10333  _container.event.mpi_event.type =
10334  T_MPI_ENUM(MPI_FILE_READ_ORDERED)
10335  ;
10336 
10337  /* Set default source & dest before override */
10338  _container.event.mpi_event.source = _rank;
10339  _container.event.mpi_event.dest = _rank;
10340 
10341 
10342 
10343 
10344  SET_COUNT (count)
10345  SET_DATATYPE (datatype)
10346 
10347 
10348  /* Fill in size informations if needed */
10349  int _size = 0;
10350  #if 1
10351  COMP_SIZE (count)
10352  #endif
10353  _container.event.mpi_event.size = _size;
10354 
10355  /********************************/
10356  /* EMIT OTF ENTER */
10357  /********************************/
10358 
10359  struct MALP_Trace_Event otf_event;
10360 
10361  uint64_t _begin = Timer_tsc ();
10362 
10365  {
10366 
10367  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10368  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10369  MALP_EVENT_MPI, _container.event.mpi_event.type );
10370  Event_Packer_push(&otf_event);
10371  }
10372 
10373  /********************************/
10374  /* ACTUAL FUNCTION CALL */
10375  /********************************/
10376 
10378  int ret = PMPI_File_read_ordered( fh, buf, count, datatype, status );
10380 
10381  /********************************/
10382  /* EMIT OTF END */
10383  /********************************/
10384 
10385  uint64_t _end = Timer_tsc();
10386  uint64_t _duration = _end - _begin;
10387 
10389  {
10391  {
10392 
10393  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10394  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10395  MALP_EVENT_MPI, _container.event.mpi_event.type );
10396 
10397 
10398  Event_Packer_push(&otf_event);
10399  }
10400 
10401  /********************************/
10402  /* EMIT MALP EVENT */
10403  /********************************/
10404 
10405  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10406 
10407  /* Submit event if MPI instrumented */
10408  Event_Packer_push(&_container);
10409  }
10410 
10411 
10412  return ret;
10413 }
10414 int MPI_File_write_ordered( MPI_File fh, void * buf, int count, MPI_Datatype datatype, MPI_Status * status )
10415 {
10416 
10417  /* Virtualize MPI */
10418 
10419 
10420  /* Pre instrum */
10421  int _rank = Stream_desc_get()->mpi_rank;
10422 
10423  struct MALP_Trace_Event _container;
10424 
10425  /********************************/
10426  /* FILL MPI EVENT */
10427  /********************************/
10428 
10429  _container.event.mpi_event.type =
10430  T_MPI_ENUM(MPI_FILE_WRITE_ORDERED)
10431  ;
10432 
10433  /* Set default source & dest before override */
10434  _container.event.mpi_event.source = _rank;
10435  _container.event.mpi_event.dest = _rank;
10436 
10437 
10438 
10439 
10440  SET_COUNT (count)
10441  SET_DATATYPE (datatype)
10442 
10443 
10444  /* Fill in size informations if needed */
10445  int _size = 0;
10446  #if 1
10447  COMP_SIZE (count)
10448  #endif
10449  _container.event.mpi_event.size = _size;
10450 
10451  /********************************/
10452  /* EMIT OTF ENTER */
10453  /********************************/
10454 
10455  struct MALP_Trace_Event otf_event;
10456 
10457  uint64_t _begin = Timer_tsc ();
10458 
10461  {
10462 
10463  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10464  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10465  MALP_EVENT_MPI, _container.event.mpi_event.type );
10466  Event_Packer_push(&otf_event);
10467  }
10468 
10469  /********************************/
10470  /* ACTUAL FUNCTION CALL */
10471  /********************************/
10472 
10474  int ret = PMPI_File_write_ordered( fh, buf, count, datatype, status );
10476 
10477  /********************************/
10478  /* EMIT OTF END */
10479  /********************************/
10480 
10481  uint64_t _end = Timer_tsc();
10482  uint64_t _duration = _end - _begin;
10483 
10485  {
10487  {
10488 
10489  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10490  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10491  MALP_EVENT_MPI, _container.event.mpi_event.type );
10492 
10493 
10494  Event_Packer_push(&otf_event);
10495  }
10496 
10497  /********************************/
10498  /* EMIT MALP EVENT */
10499  /********************************/
10500 
10501  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10502 
10503  /* Submit event if MPI instrumented */
10504  Event_Packer_push(&_container);
10505  }
10506 
10507 
10508  return ret;
10509 }
10510 int MPI_File_seek_shared( MPI_File fh, MPI_Offset offset, int whence )
10511 {
10512 
10513  /* Virtualize MPI */
10514 
10515 
10516  /* Pre instrum */
10517  int _rank = Stream_desc_get()->mpi_rank;
10518 
10519  struct MALP_Trace_Event _container;
10520 
10521  /********************************/
10522  /* FILL MPI EVENT */
10523  /********************************/
10524 
10525  _container.event.mpi_event.type =
10526  T_MPI_ENUM(MPI_FILE_SEEK_SHARED)
10527  ;
10528 
10529  /* Set default source & dest before override */
10530  _container.event.mpi_event.source = _rank;
10531  _container.event.mpi_event.dest = _rank;
10532 
10533 
10534 
10535 
10536 
10537 
10538 
10539 
10540  /* Fill in size informations if needed */
10541  int _size = 0;
10542  #if 0
10543 
10544  #endif
10545  _container.event.mpi_event.size = _size;
10546 
10547  /********************************/
10548  /* EMIT OTF ENTER */
10549  /********************************/
10550 
10551  struct MALP_Trace_Event otf_event;
10552 
10553  uint64_t _begin = Timer_tsc ();
10554 
10557  {
10558 
10559  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10560  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10561  MALP_EVENT_MPI, _container.event.mpi_event.type );
10562  Event_Packer_push(&otf_event);
10563  }
10564 
10565  /********************************/
10566  /* ACTUAL FUNCTION CALL */
10567  /********************************/
10568 
10570  int ret = PMPI_File_seek_shared( fh, offset, whence );
10572 
10573  /********************************/
10574  /* EMIT OTF END */
10575  /********************************/
10576 
10577  uint64_t _end = Timer_tsc();
10578  uint64_t _duration = _end - _begin;
10579 
10581  {
10583  {
10584 
10585  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10586  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10587  MALP_EVENT_MPI, _container.event.mpi_event.type );
10588 
10589 
10590  Event_Packer_push(&otf_event);
10591  }
10592 
10593  /********************************/
10594  /* EMIT MALP EVENT */
10595  /********************************/
10596 
10597  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10598 
10599  /* Submit event if MPI instrumented */
10600  Event_Packer_push(&_container);
10601  }
10602 
10603 
10604  return ret;
10605 }
10606 int MPI_File_get_position_shared( MPI_File fh, MPI_Offset * offset )
10607 {
10608 
10609  /* Virtualize MPI */
10610 
10611 
10612  /* Pre instrum */
10613  int _rank = Stream_desc_get()->mpi_rank;
10614 
10615  struct MALP_Trace_Event _container;
10616 
10617  /********************************/
10618  /* FILL MPI EVENT */
10619  /********************************/
10620 
10621  _container.event.mpi_event.type =
10622  T_MPI_ENUM(MPI_FILE_GET_POSITION_SHARED)
10623  ;
10624 
10625  /* Set default source & dest before override */
10626  _container.event.mpi_event.source = _rank;
10627  _container.event.mpi_event.dest = _rank;
10628 
10629 
10630 
10631 
10632 
10633 
10634 
10635 
10636  /* Fill in size informations if needed */
10637  int _size = 0;
10638  #if 0
10639 
10640  #endif
10641  _container.event.mpi_event.size = _size;
10642 
10643  /********************************/
10644  /* EMIT OTF ENTER */
10645  /********************************/
10646 
10647  struct MALP_Trace_Event otf_event;
10648 
10649  uint64_t _begin = Timer_tsc ();
10650 
10653  {
10654 
10655  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10656  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10657  MALP_EVENT_MPI, _container.event.mpi_event.type );
10658  Event_Packer_push(&otf_event);
10659  }
10660 
10661  /********************************/
10662  /* ACTUAL FUNCTION CALL */
10663  /********************************/
10664 
10666  int ret = PMPI_File_get_position_shared( fh, offset );
10668 
10669  /********************************/
10670  /* EMIT OTF END */
10671  /********************************/
10672 
10673  uint64_t _end = Timer_tsc();
10674  uint64_t _duration = _end - _begin;
10675 
10677  {
10679  {
10680 
10681  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10682  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10683  MALP_EVENT_MPI, _container.event.mpi_event.type );
10684 
10685 
10686  Event_Packer_push(&otf_event);
10687  }
10688 
10689  /********************************/
10690  /* EMIT MALP EVENT */
10691  /********************************/
10692 
10693  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10694 
10695  /* Submit event if MPI instrumented */
10696  Event_Packer_push(&_container);
10697  }
10698 
10699 
10700  return ret;
10701 }
10702 int MPI_File_read_at_all_begin( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype )
10703 {
10704 
10705  /* Virtualize MPI */
10706 
10707 
10708  /* Pre instrum */
10709  int _rank = Stream_desc_get()->mpi_rank;
10710 
10711  struct MALP_Trace_Event _container;
10712 
10713  /********************************/
10714  /* FILL MPI EVENT */
10715  /********************************/
10716 
10717  _container.event.mpi_event.type =
10718  T_MPI_ENUM(MPI_FILE_READ_AT_ALL_BEGIN)
10719  ;
10720 
10721  /* Set default source & dest before override */
10722  _container.event.mpi_event.source = _rank;
10723  _container.event.mpi_event.dest = _rank;
10724 
10725 
10726 
10727 
10728  SET_COUNT (count)
10729  SET_DATATYPE (datatype)
10730 
10731 
10732  /* Fill in size informations if needed */
10733  int _size = 0;
10734  #if 1
10735  COMP_SIZE (count)
10736  #endif
10737  _container.event.mpi_event.size = _size;
10738 
10739  /********************************/
10740  /* EMIT OTF ENTER */
10741  /********************************/
10742 
10743  struct MALP_Trace_Event otf_event;
10744 
10745  uint64_t _begin = Timer_tsc ();
10746 
10749  {
10750 
10751  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10752  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10753  MALP_EVENT_MPI, _container.event.mpi_event.type );
10754  Event_Packer_push(&otf_event);
10755  }
10756 
10757  /********************************/
10758  /* ACTUAL FUNCTION CALL */
10759  /********************************/
10760 
10762  int ret = PMPI_File_read_at_all_begin( fh, offset, buf, count, datatype );
10764 
10765  /********************************/
10766  /* EMIT OTF END */
10767  /********************************/
10768 
10769  uint64_t _end = Timer_tsc();
10770  uint64_t _duration = _end - _begin;
10771 
10773  {
10775  {
10776 
10777  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10778  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10779  MALP_EVENT_MPI, _container.event.mpi_event.type );
10780 
10781 
10782  Event_Packer_push(&otf_event);
10783  }
10784 
10785  /********************************/
10786  /* EMIT MALP EVENT */
10787  /********************************/
10788 
10789  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10790 
10791  /* Submit event if MPI instrumented */
10792  Event_Packer_push(&_container);
10793  }
10794 
10795 
10796  return ret;
10797 }
10798 int MPI_File_read_at_all_end( MPI_File fh, void * buf, MPI_Status * status )
10799 {
10800 
10801  /* Virtualize MPI */
10802 
10803 
10804  /* Pre instrum */
10805  int _rank = Stream_desc_get()->mpi_rank;
10806 
10807  struct MALP_Trace_Event _container;
10808 
10809  /********************************/
10810  /* FILL MPI EVENT */
10811  /********************************/
10812 
10813  _container.event.mpi_event.type =
10814  T_MPI_ENUM(MPI_FILE_READ_AT_ALL_END)
10815  ;
10816 
10817  /* Set default source & dest before override */
10818  _container.event.mpi_event.source = _rank;
10819  _container.event.mpi_event.dest = _rank;
10820 
10821 
10822 
10823 
10824 
10825 
10826 
10827 
10828  /* Fill in size informations if needed */
10829  int _size = 0;
10830  #if 0
10831 
10832  #endif
10833  _container.event.mpi_event.size = _size;
10834 
10835  /********************************/
10836  /* EMIT OTF ENTER */
10837  /********************************/
10838 
10839  struct MALP_Trace_Event otf_event;
10840 
10841  uint64_t _begin = Timer_tsc ();
10842 
10845  {
10846 
10847  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10848  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10849  MALP_EVENT_MPI, _container.event.mpi_event.type );
10850  Event_Packer_push(&otf_event);
10851  }
10852 
10853  /********************************/
10854  /* ACTUAL FUNCTION CALL */
10855  /********************************/
10856 
10858  int ret = PMPI_File_read_at_all_end( fh, buf, status );
10860 
10861  /********************************/
10862  /* EMIT OTF END */
10863  /********************************/
10864 
10865  uint64_t _end = Timer_tsc();
10866  uint64_t _duration = _end - _begin;
10867 
10869  {
10871  {
10872 
10873  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10874  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10875  MALP_EVENT_MPI, _container.event.mpi_event.type );
10876 
10877 
10878  Event_Packer_push(&otf_event);
10879  }
10880 
10881  /********************************/
10882  /* EMIT MALP EVENT */
10883  /********************************/
10884 
10885  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10886 
10887  /* Submit event if MPI instrumented */
10888  Event_Packer_push(&_container);
10889  }
10890 
10891 
10892  return ret;
10893 }
10894 int MPI_File_write_at_all_begin( MPI_File fh, MPI_Offset offset, void * buf, int count, MPI_Datatype datatype )
10895 {
10896 
10897  /* Virtualize MPI */
10898 
10899 
10900  /* Pre instrum */
10901  int _rank = Stream_desc_get()->mpi_rank;
10902 
10903  struct MALP_Trace_Event _container;
10904 
10905  /********************************/
10906  /* FILL MPI EVENT */
10907  /********************************/
10908 
10909  _container.event.mpi_event.type =
10910  T_MPI_ENUM(MPI_FILE_WRITE_AT_ALL_BEGIN)
10911  ;
10912 
10913  /* Set default source & dest before override */
10914  _container.event.mpi_event.source = _rank;
10915  _container.event.mpi_event.dest = _rank;
10916 
10917 
10918 
10919 
10920  SET_COUNT (count)
10921  SET_DATATYPE (datatype)
10922 
10923 
10924  /* Fill in size informations if needed */
10925  int _size = 0;
10926  #if 1
10927  COMP_SIZE (count)
10928  #endif
10929  _container.event.mpi_event.size = _size;
10930 
10931  /********************************/
10932  /* EMIT OTF ENTER */
10933  /********************************/
10934 
10935  struct MALP_Trace_Event otf_event;
10936 
10937  uint64_t _begin = Timer_tsc ();
10938 
10941  {
10942 
10943  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
10944  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
10945  MALP_EVENT_MPI, _container.event.mpi_event.type );
10946  Event_Packer_push(&otf_event);
10947  }
10948 
10949  /********************************/
10950  /* ACTUAL FUNCTION CALL */
10951  /********************************/
10952 
10954  int ret = PMPI_File_write_at_all_begin( fh, offset, buf, count, datatype );
10956 
10957  /********************************/
10958  /* EMIT OTF END */
10959  /********************************/
10960 
10961  uint64_t _end = Timer_tsc();
10962  uint64_t _duration = _end - _begin;
10963 
10965  {
10967  {
10968 
10969  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
10970  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
10971  MALP_EVENT_MPI, _container.event.mpi_event.type );
10972 
10973 
10974  Event_Packer_push(&otf_event);
10975  }
10976 
10977  /********************************/
10978  /* EMIT MALP EVENT */
10979  /********************************/
10980 
10981  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
10982 
10983  /* Submit event if MPI instrumented */
10984  Event_Packer_push(&_container);
10985  }
10986 
10987 
10988  return ret;
10989 }
10990 int MPI_File_write_at_all_end( MPI_File fh, void * buf, MPI_Status * status )
10991 {
10992 
10993  /* Virtualize MPI */
10994 
10995 
10996  /* Pre instrum */
10997  int _rank = Stream_desc_get()->mpi_rank;
10998 
10999  struct MALP_Trace_Event _container;
11000 
11001  /********************************/
11002  /* FILL MPI EVENT */
11003  /********************************/
11004 
11005  _container.event.mpi_event.type =
11006  T_MPI_ENUM(MPI_FILE_WRITE_AT_ALL_END)
11007  ;
11008 
11009  /* Set default source & dest before override */
11010  _container.event.mpi_event.source = _rank;
11011  _container.event.mpi_event.dest = _rank;
11012 
11013 
11014 
11015 
11016 
11017 
11018 
11019 
11020  /* Fill in size informations if needed */
11021  int _size = 0;
11022  #if 0
11023 
11024  #endif
11025  _container.event.mpi_event.size = _size;
11026 
11027  /********************************/
11028  /* EMIT OTF ENTER */
11029  /********************************/
11030 
11031  struct MALP_Trace_Event otf_event;
11032 
11033  uint64_t _begin = Timer_tsc ();
11034 
11037  {
11038 
11039  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11040  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11041  MALP_EVENT_MPI, _container.event.mpi_event.type );
11042  Event_Packer_push(&otf_event);
11043  }
11044 
11045  /********************************/
11046  /* ACTUAL FUNCTION CALL */
11047  /********************************/
11048 
11050  int ret = PMPI_File_write_at_all_end( fh, buf, status );
11052 
11053  /********************************/
11054  /* EMIT OTF END */
11055  /********************************/
11056 
11057  uint64_t _end = Timer_tsc();
11058  uint64_t _duration = _end - _begin;
11059 
11061  {
11063  {
11064 
11065  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11066  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11067  MALP_EVENT_MPI, _container.event.mpi_event.type );
11068 
11069 
11070  Event_Packer_push(&otf_event);
11071  }
11072 
11073  /********************************/
11074  /* EMIT MALP EVENT */
11075  /********************************/
11076 
11077  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11078 
11079  /* Submit event if MPI instrumented */
11080  Event_Packer_push(&_container);
11081  }
11082 
11083 
11084  return ret;
11085 }
11086 int MPI_File_read_all_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
11087 {
11088 
11089  /* Virtualize MPI */
11090 
11091 
11092  /* Pre instrum */
11093  int _rank = Stream_desc_get()->mpi_rank;
11094 
11095  struct MALP_Trace_Event _container;
11096 
11097  /********************************/
11098  /* FILL MPI EVENT */
11099  /********************************/
11100 
11101  _container.event.mpi_event.type =
11102  T_MPI_ENUM(MPI_FILE_READ_ALL_BEGIN)
11103  ;
11104 
11105  /* Set default source & dest before override */
11106  _container.event.mpi_event.source = _rank;
11107  _container.event.mpi_event.dest = _rank;
11108 
11109 
11110 
11111 
11112  SET_COUNT (count)
11113  SET_DATATYPE (datatype)
11114 
11115 
11116  /* Fill in size informations if needed */
11117  int _size = 0;
11118  #if 1
11119  COMP_SIZE (count)
11120  #endif
11121  _container.event.mpi_event.size = _size;
11122 
11123  /********************************/
11124  /* EMIT OTF ENTER */
11125  /********************************/
11126 
11127  struct MALP_Trace_Event otf_event;
11128 
11129  uint64_t _begin = Timer_tsc ();
11130 
11133  {
11134 
11135  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11136  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11137  MALP_EVENT_MPI, _container.event.mpi_event.type );
11138  Event_Packer_push(&otf_event);
11139  }
11140 
11141  /********************************/
11142  /* ACTUAL FUNCTION CALL */
11143  /********************************/
11144 
11146  int ret = PMPI_File_read_all_begin( fh, buf, count, datatype );
11148 
11149  /********************************/
11150  /* EMIT OTF END */
11151  /********************************/
11152 
11153  uint64_t _end = Timer_tsc();
11154  uint64_t _duration = _end - _begin;
11155 
11157  {
11159  {
11160 
11161  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11162  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11163  MALP_EVENT_MPI, _container.event.mpi_event.type );
11164 
11165 
11166  Event_Packer_push(&otf_event);
11167  }
11168 
11169  /********************************/
11170  /* EMIT MALP EVENT */
11171  /********************************/
11172 
11173  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11174 
11175  /* Submit event if MPI instrumented */
11176  Event_Packer_push(&_container);
11177  }
11178 
11179 
11180  return ret;
11181 }
11182 int MPI_File_read_all_end( MPI_File fh, void * buf, MPI_Status * status )
11183 {
11184 
11185  /* Virtualize MPI */
11186 
11187 
11188  /* Pre instrum */
11189  int _rank = Stream_desc_get()->mpi_rank;
11190 
11191  struct MALP_Trace_Event _container;
11192 
11193  /********************************/
11194  /* FILL MPI EVENT */
11195  /********************************/
11196 
11197  _container.event.mpi_event.type =
11198  T_MPI_ENUM(MPI_FILE_READ_ALL_END)
11199  ;
11200 
11201  /* Set default source & dest before override */
11202  _container.event.mpi_event.source = _rank;
11203  _container.event.mpi_event.dest = _rank;
11204 
11205 
11206 
11207 
11208 
11209 
11210 
11211 
11212  /* Fill in size informations if needed */
11213  int _size = 0;
11214  #if 0
11215 
11216  #endif
11217  _container.event.mpi_event.size = _size;
11218 
11219  /********************************/
11220  /* EMIT OTF ENTER */
11221  /********************************/
11222 
11223  struct MALP_Trace_Event otf_event;
11224 
11225  uint64_t _begin = Timer_tsc ();
11226 
11229  {
11230 
11231  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11232  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11233  MALP_EVENT_MPI, _container.event.mpi_event.type );
11234  Event_Packer_push(&otf_event);
11235  }
11236 
11237  /********************************/
11238  /* ACTUAL FUNCTION CALL */
11239  /********************************/
11240 
11242  int ret = PMPI_File_read_all_end( fh, buf, status );
11244 
11245  /********************************/
11246  /* EMIT OTF END */
11247  /********************************/
11248 
11249  uint64_t _end = Timer_tsc();
11250  uint64_t _duration = _end - _begin;
11251 
11253  {
11255  {
11256 
11257  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11258  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11259  MALP_EVENT_MPI, _container.event.mpi_event.type );
11260 
11261 
11262  Event_Packer_push(&otf_event);
11263  }
11264 
11265  /********************************/
11266  /* EMIT MALP EVENT */
11267  /********************************/
11268 
11269  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11270 
11271  /* Submit event if MPI instrumented */
11272  Event_Packer_push(&_container);
11273  }
11274 
11275 
11276  return ret;
11277 }
11278 int MPI_File_write_all_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
11279 {
11280 
11281  /* Virtualize MPI */
11282 
11283 
11284  /* Pre instrum */
11285  int _rank = Stream_desc_get()->mpi_rank;
11286 
11287  struct MALP_Trace_Event _container;
11288 
11289  /********************************/
11290  /* FILL MPI EVENT */
11291  /********************************/
11292 
11293  _container.event.mpi_event.type =
11294  T_MPI_ENUM(MPI_FILE_WRITE_ALL_BEGIN)
11295  ;
11296 
11297  /* Set default source & dest before override */
11298  _container.event.mpi_event.source = _rank;
11299  _container.event.mpi_event.dest = _rank;
11300 
11301 
11302 
11303 
11304  SET_COUNT (count)
11305  SET_DATATYPE (datatype)
11306 
11307 
11308  /* Fill in size informations if needed */
11309  int _size = 0;
11310  #if 1
11311  COMP_SIZE (count)
11312  #endif
11313  _container.event.mpi_event.size = _size;
11314 
11315  /********************************/
11316  /* EMIT OTF ENTER */
11317  /********************************/
11318 
11319  struct MALP_Trace_Event otf_event;
11320 
11321  uint64_t _begin = Timer_tsc ();
11322 
11325  {
11326 
11327  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11328  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11329  MALP_EVENT_MPI, _container.event.mpi_event.type );
11330  Event_Packer_push(&otf_event);
11331  }
11332 
11333  /********************************/
11334  /* ACTUAL FUNCTION CALL */
11335  /********************************/
11336 
11338  int ret = PMPI_File_write_all_begin( fh, buf, count, datatype );
11340 
11341  /********************************/
11342  /* EMIT OTF END */
11343  /********************************/
11344 
11345  uint64_t _end = Timer_tsc();
11346  uint64_t _duration = _end - _begin;
11347 
11349  {
11351  {
11352 
11353  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11354  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11355  MALP_EVENT_MPI, _container.event.mpi_event.type );
11356 
11357 
11358  Event_Packer_push(&otf_event);
11359  }
11360 
11361  /********************************/
11362  /* EMIT MALP EVENT */
11363  /********************************/
11364 
11365  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11366 
11367  /* Submit event if MPI instrumented */
11368  Event_Packer_push(&_container);
11369  }
11370 
11371 
11372  return ret;
11373 }
11374 int MPI_File_write_all_end( MPI_File fh, void * buf, MPI_Status * status )
11375 {
11376 
11377  /* Virtualize MPI */
11378 
11379 
11380  /* Pre instrum */
11381  int _rank = Stream_desc_get()->mpi_rank;
11382 
11383  struct MALP_Trace_Event _container;
11384 
11385  /********************************/
11386  /* FILL MPI EVENT */
11387  /********************************/
11388 
11389  _container.event.mpi_event.type =
11390  T_MPI_ENUM(MPI_FILE_WRITE_ALL_END)
11391  ;
11392 
11393  /* Set default source & dest before override */
11394  _container.event.mpi_event.source = _rank;
11395  _container.event.mpi_event.dest = _rank;
11396 
11397 
11398 
11399 
11400 
11401 
11402 
11403 
11404  /* Fill in size informations if needed */
11405  int _size = 0;
11406  #if 0
11407 
11408  #endif
11409  _container.event.mpi_event.size = _size;
11410 
11411  /********************************/
11412  /* EMIT OTF ENTER */
11413  /********************************/
11414 
11415  struct MALP_Trace_Event otf_event;
11416 
11417  uint64_t _begin = Timer_tsc ();
11418 
11421  {
11422 
11423  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11424  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11425  MALP_EVENT_MPI, _container.event.mpi_event.type );
11426  Event_Packer_push(&otf_event);
11427  }
11428 
11429  /********************************/
11430  /* ACTUAL FUNCTION CALL */
11431  /********************************/
11432 
11434  int ret = PMPI_File_write_all_end( fh, buf, status );
11436 
11437  /********************************/
11438  /* EMIT OTF END */
11439  /********************************/
11440 
11441  uint64_t _end = Timer_tsc();
11442  uint64_t _duration = _end - _begin;
11443 
11445  {
11447  {
11448 
11449  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11450  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11451  MALP_EVENT_MPI, _container.event.mpi_event.type );
11452 
11453 
11454  Event_Packer_push(&otf_event);
11455  }
11456 
11457  /********************************/
11458  /* EMIT MALP EVENT */
11459  /********************************/
11460 
11461  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11462 
11463  /* Submit event if MPI instrumented */
11464  Event_Packer_push(&_container);
11465  }
11466 
11467 
11468  return ret;
11469 }
11470 int MPI_File_read_ordered_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
11471 {
11472 
11473  /* Virtualize MPI */
11474 
11475 
11476  /* Pre instrum */
11477  int _rank = Stream_desc_get()->mpi_rank;
11478 
11479  struct MALP_Trace_Event _container;
11480 
11481  /********************************/
11482  /* FILL MPI EVENT */
11483  /********************************/
11484 
11485  _container.event.mpi_event.type =
11486  T_MPI_ENUM(MPI_FILE_READ_ORDERED_BEGIN)
11487  ;
11488 
11489  /* Set default source & dest before override */
11490  _container.event.mpi_event.source = _rank;
11491  _container.event.mpi_event.dest = _rank;
11492 
11493 
11494 
11495 
11496  SET_COUNT (count)
11497  SET_DATATYPE (datatype)
11498 
11499 
11500  /* Fill in size informations if needed */
11501  int _size = 0;
11502  #if 1
11503  COMP_SIZE (count)
11504  #endif
11505  _container.event.mpi_event.size = _size;
11506 
11507  /********************************/
11508  /* EMIT OTF ENTER */
11509  /********************************/
11510 
11511  struct MALP_Trace_Event otf_event;
11512 
11513  uint64_t _begin = Timer_tsc ();
11514 
11517  {
11518 
11519  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11520  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11521  MALP_EVENT_MPI, _container.event.mpi_event.type );
11522  Event_Packer_push(&otf_event);
11523  }
11524 
11525  /********************************/
11526  /* ACTUAL FUNCTION CALL */
11527  /********************************/
11528 
11530  int ret = PMPI_File_read_ordered_begin( fh, buf, count, datatype );
11532 
11533  /********************************/
11534  /* EMIT OTF END */
11535  /********************************/
11536 
11537  uint64_t _end = Timer_tsc();
11538  uint64_t _duration = _end - _begin;
11539 
11541  {
11543  {
11544 
11545  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11546  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11547  MALP_EVENT_MPI, _container.event.mpi_event.type );
11548 
11549 
11550  Event_Packer_push(&otf_event);
11551  }
11552 
11553  /********************************/
11554  /* EMIT MALP EVENT */
11555  /********************************/
11556 
11557  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11558 
11559  /* Submit event if MPI instrumented */
11560  Event_Packer_push(&_container);
11561  }
11562 
11563 
11564  return ret;
11565 }
11566 int MPI_File_read_ordered_end( MPI_File fh, void * buf, MPI_Status * status )
11567 {
11568 
11569  /* Virtualize MPI */
11570 
11571 
11572  /* Pre instrum */
11573  int _rank = Stream_desc_get()->mpi_rank;
11574 
11575  struct MALP_Trace_Event _container;
11576 
11577  /********************************/
11578  /* FILL MPI EVENT */
11579  /********************************/
11580 
11581  _container.event.mpi_event.type =
11582  T_MPI_ENUM(MPI_FILE_READ_ORDERED_END)
11583  ;
11584 
11585  /* Set default source & dest before override */
11586  _container.event.mpi_event.source = _rank;
11587  _container.event.mpi_event.dest = _rank;
11588 
11589 
11590 
11591 
11592 
11593 
11594 
11595 
11596  /* Fill in size informations if needed */
11597  int _size = 0;
11598  #if 0
11599 
11600  #endif
11601  _container.event.mpi_event.size = _size;
11602 
11603  /********************************/
11604  /* EMIT OTF ENTER */
11605  /********************************/
11606 
11607  struct MALP_Trace_Event otf_event;
11608 
11609  uint64_t _begin = Timer_tsc ();
11610 
11613  {
11614 
11615  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11616  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11617  MALP_EVENT_MPI, _container.event.mpi_event.type );
11618  Event_Packer_push(&otf_event);
11619  }
11620 
11621  /********************************/
11622  /* ACTUAL FUNCTION CALL */
11623  /********************************/
11624 
11626  int ret = PMPI_File_read_ordered_end( fh, buf, status );
11628 
11629  /********************************/
11630  /* EMIT OTF END */
11631  /********************************/
11632 
11633  uint64_t _end = Timer_tsc();
11634  uint64_t _duration = _end - _begin;
11635 
11637  {
11639  {
11640 
11641  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11642  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11643  MALP_EVENT_MPI, _container.event.mpi_event.type );
11644 
11645 
11646  Event_Packer_push(&otf_event);
11647  }
11648 
11649  /********************************/
11650  /* EMIT MALP EVENT */
11651  /********************************/
11652 
11653  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11654 
11655  /* Submit event if MPI instrumented */
11656  Event_Packer_push(&_container);
11657  }
11658 
11659 
11660  return ret;
11661 }
11662 int MPI_File_write_ordered_begin( MPI_File fh, void * buf, int count, MPI_Datatype datatype )
11663 {
11664 
11665  /* Virtualize MPI */
11666 
11667 
11668  /* Pre instrum */
11669  int _rank = Stream_desc_get()->mpi_rank;
11670 
11671  struct MALP_Trace_Event _container;
11672 
11673  /********************************/
11674  /* FILL MPI EVENT */
11675  /********************************/
11676 
11677  _container.event.mpi_event.type =
11678  T_MPI_ENUM(MPI_FILE_WRITE_ORDERED_BEGIN)
11679  ;
11680 
11681  /* Set default source & dest before override */
11682  _container.event.mpi_event.source = _rank;
11683  _container.event.mpi_event.dest = _rank;
11684 
11685 
11686 
11687 
11688  SET_COUNT (count)
11689  SET_DATATYPE (datatype)
11690 
11691 
11692  /* Fill in size informations if needed */
11693  int _size = 0;
11694  #if 1
11695  COMP_SIZE (count)
11696  #endif
11697  _container.event.mpi_event.size = _size;
11698 
11699  /********************************/
11700  /* EMIT OTF ENTER */
11701  /********************************/
11702 
11703  struct MALP_Trace_Event otf_event;
11704 
11705  uint64_t _begin = Timer_tsc ();
11706 
11709  {
11710 
11711  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11712  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11713  MALP_EVENT_MPI, _container.event.mpi_event.type );
11714  Event_Packer_push(&otf_event);
11715  }
11716 
11717  /********************************/
11718  /* ACTUAL FUNCTION CALL */
11719  /********************************/
11720 
11722  int ret = PMPI_File_write_ordered_begin( fh, buf, count, datatype );
11724 
11725  /********************************/
11726  /* EMIT OTF END */
11727  /********************************/
11728 
11729  uint64_t _end = Timer_tsc();
11730  uint64_t _duration = _end - _begin;
11731 
11733  {
11735  {
11736 
11737  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11738  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11739  MALP_EVENT_MPI, _container.event.mpi_event.type );
11740 
11741 
11742  Event_Packer_push(&otf_event);
11743  }
11744 
11745  /********************************/
11746  /* EMIT MALP EVENT */
11747  /********************************/
11748 
11749  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11750 
11751  /* Submit event if MPI instrumented */
11752  Event_Packer_push(&_container);
11753  }
11754 
11755 
11756  return ret;
11757 }
11758 int MPI_File_write_ordered_end( MPI_File fh, void * buf, MPI_Status * status )
11759 {
11760 
11761  /* Virtualize MPI */
11762 
11763 
11764  /* Pre instrum */
11765  int _rank = Stream_desc_get()->mpi_rank;
11766 
11767  struct MALP_Trace_Event _container;
11768 
11769  /********************************/
11770  /* FILL MPI EVENT */
11771  /********************************/
11772 
11773  _container.event.mpi_event.type =
11774  T_MPI_ENUM(MPI_FILE_WRITE_ORDERED_END)
11775  ;
11776 
11777  /* Set default source & dest before override */
11778  _container.event.mpi_event.source = _rank;
11779  _container.event.mpi_event.dest = _rank;
11780 
11781 
11782 
11783 
11784 
11785 
11786 
11787 
11788  /* Fill in size informations if needed */
11789  int _size = 0;
11790  #if 0
11791 
11792  #endif
11793  _container.event.mpi_event.size = _size;
11794 
11795  /********************************/
11796  /* EMIT OTF ENTER */
11797  /********************************/
11798 
11799  struct MALP_Trace_Event otf_event;
11800 
11801  uint64_t _begin = Timer_tsc ();
11802 
11805  {
11806 
11807  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11808  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11809  MALP_EVENT_MPI, _container.event.mpi_event.type );
11810  Event_Packer_push(&otf_event);
11811  }
11812 
11813  /********************************/
11814  /* ACTUAL FUNCTION CALL */
11815  /********************************/
11816 
11818  int ret = PMPI_File_write_ordered_end( fh, buf, status );
11820 
11821  /********************************/
11822  /* EMIT OTF END */
11823  /********************************/
11824 
11825  uint64_t _end = Timer_tsc();
11826  uint64_t _duration = _end - _begin;
11827 
11829  {
11831  {
11832 
11833  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11834  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11835  MALP_EVENT_MPI, _container.event.mpi_event.type );
11836 
11837 
11838  Event_Packer_push(&otf_event);
11839  }
11840 
11841  /********************************/
11842  /* EMIT MALP EVENT */
11843  /********************************/
11844 
11845  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11846 
11847  /* Submit event if MPI instrumented */
11848  Event_Packer_push(&_container);
11849  }
11850 
11851 
11852  return ret;
11853 }
11854 int MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype, MPI_Aint * extent )
11855 {
11856 
11857  /* Virtualize MPI */
11858 
11859 
11860  /* Pre instrum */
11861  int _rank = Stream_desc_get()->mpi_rank;
11862 
11863  struct MALP_Trace_Event _container;
11864 
11865  /********************************/
11866  /* FILL MPI EVENT */
11867  /********************************/
11868 
11869  _container.event.mpi_event.type =
11870  T_MPI_ENUM(MPI_FILE_GET_TYPE_EXTENT)
11871  ;
11872 
11873  /* Set default source & dest before override */
11874  _container.event.mpi_event.source = _rank;
11875  _container.event.mpi_event.dest = _rank;
11876 
11877 
11878 
11879 
11880 
11881  SET_DATATYPE (datatype)
11882 
11883 
11884  /* Fill in size informations if needed */
11885  int _size = 0;
11886  #if 1
11887 
11888  #endif
11889  _container.event.mpi_event.size = _size;
11890 
11891  /********************************/
11892  /* EMIT OTF ENTER */
11893  /********************************/
11894 
11895  struct MALP_Trace_Event otf_event;
11896 
11897  uint64_t _begin = Timer_tsc ();
11898 
11901  {
11902 
11903  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
11904  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
11905  MALP_EVENT_MPI, _container.event.mpi_event.type );
11906  Event_Packer_push(&otf_event);
11907  }
11908 
11909  /********************************/
11910  /* ACTUAL FUNCTION CALL */
11911  /********************************/
11912 
11914  int ret = PMPI_File_get_type_extent( fh, datatype, extent );
11916 
11917  /********************************/
11918  /* EMIT OTF END */
11919  /********************************/
11920 
11921  uint64_t _end = Timer_tsc();
11922  uint64_t _duration = _end - _begin;
11923 
11925  {
11927  {
11928 
11929  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
11930  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
11931  MALP_EVENT_MPI, _container.event.mpi_event.type );
11932 
11933 
11934  Event_Packer_push(&otf_event);
11935  }
11936 
11937  /********************************/
11938  /* EMIT MALP EVENT */
11939  /********************************/
11940 
11941  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
11942 
11943  /* Submit event if MPI instrumented */
11944  Event_Packer_push(&_container);
11945  }
11946 
11947 
11948  return ret;
11949 }
11950 int MPI_File_set_atomicity( MPI_File fh, int flag )
11951 {
11952 
11953  /* Virtualize MPI */
11954 
11955 
11956  /* Pre instrum */
11957  int _rank = Stream_desc_get()->mpi_rank;
11958 
11959  struct MALP_Trace_Event _container;
11960 
11961  /********************************/
11962  /* FILL MPI EVENT */
11963  /********************************/
11964 
11965  _container.event.mpi_event.type =
11966  T_MPI_ENUM(MPI_FILE_SET_ATOMICITY)
11967  ;
11968 
11969  /* Set default source & dest before override */
11970  _container.event.mpi_event.source = _rank;
11971  _container.event.mpi_event.dest = _rank;
11972 
11973 
11974 
11975 
11976 
11977 
11978 
11979 
11980  /* Fill in size informations if needed */
11981  int _size = 0;
11982  #if 0
11983 
11984  #endif
11985  _container.event.mpi_event.size = _size;
11986 
11987  /********************************/
11988  /* EMIT OTF ENTER */
11989  /********************************/
11990 
11991  struct MALP_Trace_Event otf_event;
11992 
11993  uint64_t _begin = Timer_tsc ();
11994 
11997  {
11998 
11999  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12000  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12001  MALP_EVENT_MPI, _container.event.mpi_event.type );
12002  Event_Packer_push(&otf_event);
12003  }
12004 
12005  /********************************/
12006  /* ACTUAL FUNCTION CALL */
12007  /********************************/
12008 
12010  int ret = PMPI_File_set_atomicity( fh, flag );
12012 
12013  /********************************/
12014  /* EMIT OTF END */
12015  /********************************/
12016 
12017  uint64_t _end = Timer_tsc();
12018  uint64_t _duration = _end - _begin;
12019 
12021  {
12023  {
12024 
12025  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12026  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12027  MALP_EVENT_MPI, _container.event.mpi_event.type );
12028 
12029 
12030  Event_Packer_push(&otf_event);
12031  }
12032 
12033  /********************************/
12034  /* EMIT MALP EVENT */
12035  /********************************/
12036 
12037  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12038 
12039  /* Submit event if MPI instrumented */
12040  Event_Packer_push(&_container);
12041  }
12042 
12043 
12044  return ret;
12045 }
12046 int MPI_File_get_atomicity( MPI_File fh, int * flag )
12047 {
12048 
12049  /* Virtualize MPI */
12050 
12051 
12052  /* Pre instrum */
12053  int _rank = Stream_desc_get()->mpi_rank;
12054 
12055  struct MALP_Trace_Event _container;
12056 
12057  /********************************/
12058  /* FILL MPI EVENT */
12059  /********************************/
12060 
12061  _container.event.mpi_event.type =
12062  T_MPI_ENUM(MPI_FILE_GET_ATOMICITY)
12063  ;
12064 
12065  /* Set default source & dest before override */
12066  _container.event.mpi_event.source = _rank;
12067  _container.event.mpi_event.dest = _rank;
12068 
12069 
12070 
12071 
12072 
12073 
12074 
12075 
12076  /* Fill in size informations if needed */
12077  int _size = 0;
12078  #if 0
12079 
12080  #endif
12081  _container.event.mpi_event.size = _size;
12082 
12083  /********************************/
12084  /* EMIT OTF ENTER */
12085  /********************************/
12086 
12087  struct MALP_Trace_Event otf_event;
12088 
12089  uint64_t _begin = Timer_tsc ();
12090 
12093  {
12094 
12095  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12096  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12097  MALP_EVENT_MPI, _container.event.mpi_event.type );
12098  Event_Packer_push(&otf_event);
12099  }
12100 
12101  /********************************/
12102  /* ACTUAL FUNCTION CALL */
12103  /********************************/
12104 
12106  int ret = PMPI_File_get_atomicity( fh, flag );
12108 
12109  /********************************/
12110  /* EMIT OTF END */
12111  /********************************/
12112 
12113  uint64_t _end = Timer_tsc();
12114  uint64_t _duration = _end - _begin;
12115 
12117  {
12119  {
12120 
12121  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12122  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12123  MALP_EVENT_MPI, _container.event.mpi_event.type );
12124 
12125 
12126  Event_Packer_push(&otf_event);
12127  }
12128 
12129  /********************************/
12130  /* EMIT MALP EVENT */
12131  /********************************/
12132 
12133  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12134 
12135  /* Submit event if MPI instrumented */
12136  Event_Packer_push(&_container);
12137  }
12138 
12139 
12140  return ret;
12141 }
12142 int MPI_File_sync( MPI_File fh )
12143 {
12144 
12145  /* Virtualize MPI */
12146 
12147 
12148  /* Pre instrum */
12149  int _rank = Stream_desc_get()->mpi_rank;
12150 
12151  struct MALP_Trace_Event _container;
12152 
12153  /********************************/
12154  /* FILL MPI EVENT */
12155  /********************************/
12156 
12157  _container.event.mpi_event.type =
12158  T_MPI_ENUM(MPI_FILE_SYNC)
12159  ;
12160 
12161  /* Set default source & dest before override */
12162  _container.event.mpi_event.source = _rank;
12163  _container.event.mpi_event.dest = _rank;
12164 
12165 
12166 
12167 
12168 
12169 
12170 
12171 
12172  /* Fill in size informations if needed */
12173  int _size = 0;
12174  #if 0
12175 
12176  #endif
12177  _container.event.mpi_event.size = _size;
12178 
12179  /********************************/
12180  /* EMIT OTF ENTER */
12181  /********************************/
12182 
12183  struct MALP_Trace_Event otf_event;
12184 
12185  uint64_t _begin = Timer_tsc ();
12186 
12189  {
12190 
12191  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12192  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12193  MALP_EVENT_MPI, _container.event.mpi_event.type );
12194  Event_Packer_push(&otf_event);
12195  }
12196 
12197  /********************************/
12198  /* ACTUAL FUNCTION CALL */
12199  /********************************/
12200 
12202  int ret = PMPI_File_sync( fh );
12204 
12205  /********************************/
12206  /* EMIT OTF END */
12207  /********************************/
12208 
12209  uint64_t _end = Timer_tsc();
12210  uint64_t _duration = _end - _begin;
12211 
12213  {
12215  {
12216 
12217  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12218  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12219  MALP_EVENT_MPI, _container.event.mpi_event.type );
12220 
12221 
12222  Event_Packer_push(&otf_event);
12223  }
12224 
12225  /********************************/
12226  /* EMIT MALP EVENT */
12227  /********************************/
12228 
12229  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12230 
12231  /* Submit event if MPI instrumented */
12232  Event_Packer_push(&_container);
12233  }
12234 
12235 
12236  return ret;
12237 }
12238 int MPI_Finalized( int * flag )
12239 {
12240 
12241  /* Virtualize MPI */
12242 
12243 
12244  /* Pre instrum */
12245  int _rank = Stream_desc_get()->mpi_rank;
12246 
12247  struct MALP_Trace_Event _container;
12248 
12249  /********************************/
12250  /* FILL MPI EVENT */
12251  /********************************/
12252 
12253  _container.event.mpi_event.type =
12254  T_MPI_ENUM(MPI_FINALIZED)
12255  ;
12256 
12257  /* Set default source & dest before override */
12258  _container.event.mpi_event.source = _rank;
12259  _container.event.mpi_event.dest = _rank;
12260 
12261 
12262 
12263 
12264 
12265 
12266 
12267 
12268  /* Fill in size informations if needed */
12269  int _size = 0;
12270  #if 0
12271 
12272  #endif
12273  _container.event.mpi_event.size = _size;
12274 
12275  /********************************/
12276  /* EMIT OTF ENTER */
12277  /********************************/
12278 
12279  struct MALP_Trace_Event otf_event;
12280 
12281  uint64_t _begin = Timer_tsc ();
12282 
12285  {
12286 
12287  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12288  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12289  MALP_EVENT_MPI, _container.event.mpi_event.type );
12290  Event_Packer_push(&otf_event);
12291  }
12292 
12293  /********************************/
12294  /* ACTUAL FUNCTION CALL */
12295  /********************************/
12296 
12298  int ret = PMPI_Finalized( flag );
12300 
12301  /********************************/
12302  /* EMIT OTF END */
12303  /********************************/
12304 
12305  uint64_t _end = Timer_tsc();
12306  uint64_t _duration = _end - _begin;
12307 
12309  {
12311  {
12312 
12313  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12314  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12315  MALP_EVENT_MPI, _container.event.mpi_event.type );
12316 
12317 
12318  Event_Packer_push(&otf_event);
12319  }
12320 
12321  /********************************/
12322  /* EMIT MALP EVENT */
12323  /********************************/
12324 
12325  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12326 
12327  /* Submit event if MPI instrumented */
12328  Event_Packer_push(&_container);
12329  }
12330 
12331 
12332  return ret;
12333 }
12334 int MPI_Free_mem( void * base )
12335 {
12336 
12337  /* Virtualize MPI */
12338 
12339 
12340  /* Pre instrum */
12341  int _rank = Stream_desc_get()->mpi_rank;
12342 
12343  struct MALP_Trace_Event _container;
12344 
12345  /********************************/
12346  /* FILL MPI EVENT */
12347  /********************************/
12348 
12349  _container.event.mpi_event.type =
12350  T_MPI_ENUM(MPI_FREE_MEM)
12351  ;
12352 
12353  /* Set default source & dest before override */
12354  _container.event.mpi_event.source = _rank;
12355  _container.event.mpi_event.dest = _rank;
12356 
12357 
12358 
12359 
12360 
12361 
12362 
12363 
12364  /* Fill in size informations if needed */
12365  int _size = 0;
12366  #if 0
12367 
12368  #endif
12369  _container.event.mpi_event.size = _size;
12370 
12371  /********************************/
12372  /* EMIT OTF ENTER */
12373  /********************************/
12374 
12375  struct MALP_Trace_Event otf_event;
12376 
12377  uint64_t _begin = Timer_tsc ();
12378 
12381  {
12382 
12383  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12384  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12385  MALP_EVENT_MPI, _container.event.mpi_event.type );
12386  Event_Packer_push(&otf_event);
12387  }
12388 
12389  /********************************/
12390  /* ACTUAL FUNCTION CALL */
12391  /********************************/
12392 
12394  int ret = PMPI_Free_mem( base );
12396 
12397  /********************************/
12398  /* EMIT OTF END */
12399  /********************************/
12400 
12401  uint64_t _end = Timer_tsc();
12402  uint64_t _duration = _end - _begin;
12403 
12405  {
12407  {
12408 
12409  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12410  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12411  MALP_EVENT_MPI, _container.event.mpi_event.type );
12412 
12413 
12414  Event_Packer_push(&otf_event);
12415  }
12416 
12417  /********************************/
12418  /* EMIT MALP EVENT */
12419  /********************************/
12420 
12421  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12422 
12423  /* Submit event if MPI instrumented */
12424  Event_Packer_push(&_container);
12425  }
12426 
12427 
12428  return ret;
12429 }
12430 int MPI_Gather( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm )
12431 {
12432 
12433  /* Virtualize MPI */
12434  MACRO_MPI_Comm (comm)
12435 
12436  /* Pre instrum */
12437  int _rank = Stream_desc_get()->mpi_rank;
12438 
12439  struct MALP_Trace_Event _container;
12440 
12441  /********************************/
12442  /* FILL MPI EVENT */
12443  /********************************/
12444 
12445  _container.event.mpi_event.type =
12446  T_MPI_ENUM(MPI_GATHER)
12447  ;
12448 
12449  /* Set default source & dest before override */
12450  _container.event.mpi_event.source = _rank;
12451  _container.event.mpi_event.dest = _rank;
12452 
12453 
12454 
12455 
12456 
12457 
12458  SET_COMM (comm)
12459 
12460  /* Fill in size informations if needed */
12461  int _size = 0;
12462  #if 0
12463 
12464  #endif
12465  _container.event.mpi_event.size = _size;
12466 
12467  /********************************/
12468  /* EMIT OTF ENTER */
12469  /********************************/
12470 
12471  struct MALP_Trace_Event otf_event;
12472 
12473  uint64_t _begin = Timer_tsc ();
12474 
12477  {
12478 
12479  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12480  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12481  MALP_EVENT_MPI, _container.event.mpi_event.type );
12482  Event_Packer_push(&otf_event);
12483  }
12484 
12485  /********************************/
12486  /* ACTUAL FUNCTION CALL */
12487  /********************************/
12488 
12490  int ret = PMPI_Gather( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm );
12492 
12493  /********************************/
12494  /* EMIT OTF END */
12495  /********************************/
12496 
12497  uint64_t _end = Timer_tsc();
12498  uint64_t _duration = _end - _begin;
12499 
12501  {
12503  {
12504 
12505  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12506  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12507  MALP_EVENT_MPI, _container.event.mpi_event.type );
12508 
12509 
12510  Event_Packer_push(&otf_event);
12511  }
12512 
12513  /********************************/
12514  /* EMIT MALP EVENT */
12515  /********************************/
12516 
12517  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12518 
12519  /* Submit event if MPI instrumented */
12520  Event_Packer_push(&_container);
12521  }
12522 
12523 
12524  return ret;
12525 }
12526 int MPI_Gatherv( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int * recvcounts, int * displs, MPI_Datatype recvtype, int root, MPI_Comm comm )
12527 {
12528 
12529  /* Virtualize MPI */
12530  MACRO_MPI_Comm (comm)
12531 
12532  /* Pre instrum */
12533  int _rank = Stream_desc_get()->mpi_rank;
12534 
12535  struct MALP_Trace_Event _container;
12536 
12537  /********************************/
12538  /* FILL MPI EVENT */
12539  /********************************/
12540 
12541  _container.event.mpi_event.type =
12542  T_MPI_ENUM(MPI_GATHERV)
12543  ;
12544 
12545  /* Set default source & dest before override */
12546  _container.event.mpi_event.source = _rank;
12547  _container.event.mpi_event.dest = _rank;
12548 
12549 
12550 
12551 
12552 
12553 
12554  SET_COMM (comm)
12555 
12556  /* Fill in size informations if needed */
12557  int _size = 0;
12558  #if 0
12559 
12560  #endif
12561  _container.event.mpi_event.size = _size;
12562 
12563  /********************************/
12564  /* EMIT OTF ENTER */
12565  /********************************/
12566 
12567  struct MALP_Trace_Event otf_event;
12568 
12569  uint64_t _begin = Timer_tsc ();
12570 
12573  {
12574 
12575  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12576  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12577  MALP_EVENT_MPI, _container.event.mpi_event.type );
12578  Event_Packer_push(&otf_event);
12579  }
12580 
12581  /********************************/
12582  /* ACTUAL FUNCTION CALL */
12583  /********************************/
12584 
12586  int ret = PMPI_Gatherv( sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, root, comm );
12588 
12589  /********************************/
12590  /* EMIT OTF END */
12591  /********************************/
12592 
12593  uint64_t _end = Timer_tsc();
12594  uint64_t _duration = _end - _begin;
12595 
12597  {
12599  {
12600 
12601  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12602  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12603  MALP_EVENT_MPI, _container.event.mpi_event.type );
12604 
12605 
12606  Event_Packer_push(&otf_event);
12607  }
12608 
12609  /********************************/
12610  /* EMIT MALP EVENT */
12611  /********************************/
12612 
12613  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12614 
12615  /* Submit event if MPI instrumented */
12616  Event_Packer_push(&_container);
12617  }
12618 
12619 
12620  return ret;
12621 }
12622 int MPI_Get_address( void * location, MPI_Aint * address )
12623 {
12624 
12625  /* Virtualize MPI */
12626 
12627 
12628  /* Pre instrum */
12629  int _rank = Stream_desc_get()->mpi_rank;
12630 
12631  struct MALP_Trace_Event _container;
12632 
12633  /********************************/
12634  /* FILL MPI EVENT */
12635  /********************************/
12636 
12637  _container.event.mpi_event.type =
12638  T_MPI_ENUM(MPI_GET_ADDRESS)
12639  ;
12640 
12641  /* Set default source & dest before override */
12642  _container.event.mpi_event.source = _rank;
12643  _container.event.mpi_event.dest = _rank;
12644 
12645 
12646 
12647 
12648 
12649 
12650 
12651 
12652  /* Fill in size informations if needed */
12653  int _size = 0;
12654  #if 0
12655 
12656  #endif
12657  _container.event.mpi_event.size = _size;
12658 
12659  /********************************/
12660  /* EMIT OTF ENTER */
12661  /********************************/
12662 
12663  struct MALP_Trace_Event otf_event;
12664 
12665  uint64_t _begin = Timer_tsc ();
12666 
12669  {
12670 
12671  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12672  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12673  MALP_EVENT_MPI, _container.event.mpi_event.type );
12674  Event_Packer_push(&otf_event);
12675  }
12676 
12677  /********************************/
12678  /* ACTUAL FUNCTION CALL */
12679  /********************************/
12680 
12682  int ret = PMPI_Get_address( location, address );
12684 
12685  /********************************/
12686  /* EMIT OTF END */
12687  /********************************/
12688 
12689  uint64_t _end = Timer_tsc();
12690  uint64_t _duration = _end - _begin;
12691 
12693  {
12695  {
12696 
12697  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12698  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12699  MALP_EVENT_MPI, _container.event.mpi_event.type );
12700 
12701 
12702  Event_Packer_push(&otf_event);
12703  }
12704 
12705  /********************************/
12706  /* EMIT MALP EVENT */
12707  /********************************/
12708 
12709  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12710 
12711  /* Submit event if MPI instrumented */
12712  Event_Packer_push(&_container);
12713  }
12714 
12715 
12716  return ret;
12717 }
12718 int MPI_Get_count( MPI_Status * status, MPI_Datatype datatype, int * count )
12719 {
12720 
12721  /* Virtualize MPI */
12722 
12723 
12724  /* Pre instrum */
12725  int _rank = Stream_desc_get()->mpi_rank;
12726 
12727  struct MALP_Trace_Event _container;
12728 
12729  /********************************/
12730  /* FILL MPI EVENT */
12731  /********************************/
12732 
12733  _container.event.mpi_event.type =
12734  T_MPI_ENUM(MPI_GET_COUNT)
12735  ;
12736 
12737  /* Set default source & dest before override */
12738  _container.event.mpi_event.source = _rank;
12739  _container.event.mpi_event.dest = _rank;
12740 
12741 
12742 
12743 
12744 
12745  SET_DATATYPE (datatype)
12746 
12747 
12748  /* Fill in size informations if needed */
12749  int _size = 0;
12750  #if 1
12751 
12752  #endif
12753  _container.event.mpi_event.size = _size;
12754 
12755  /********************************/
12756  /* EMIT OTF ENTER */
12757  /********************************/
12758 
12759  struct MALP_Trace_Event otf_event;
12760 
12761  uint64_t _begin = Timer_tsc ();
12762 
12765  {
12766 
12767  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12768  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12769  MALP_EVENT_MPI, _container.event.mpi_event.type );
12770  Event_Packer_push(&otf_event);
12771  }
12772 
12773  /********************************/
12774  /* ACTUAL FUNCTION CALL */
12775  /********************************/
12776 
12778  int ret = PMPI_Get_count( status, datatype, count );
12780 
12781  /********************************/
12782  /* EMIT OTF END */
12783  /********************************/
12784 
12785  uint64_t _end = Timer_tsc();
12786  uint64_t _duration = _end - _begin;
12787 
12789  {
12791  {
12792 
12793  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12794  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12795  MALP_EVENT_MPI, _container.event.mpi_event.type );
12796 
12797 
12798  Event_Packer_push(&otf_event);
12799  }
12800 
12801  /********************************/
12802  /* EMIT MALP EVENT */
12803  /********************************/
12804 
12805  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12806 
12807  /* Submit event if MPI instrumented */
12808  Event_Packer_push(&_container);
12809  }
12810 
12811 
12812  return ret;
12813 }
12814 int MPI_Get_elements( MPI_Status * status, MPI_Datatype datatype, int * count )
12815 {
12816 
12817  /* Virtualize MPI */
12818 
12819 
12820  /* Pre instrum */
12821  int _rank = Stream_desc_get()->mpi_rank;
12822 
12823  struct MALP_Trace_Event _container;
12824 
12825  /********************************/
12826  /* FILL MPI EVENT */
12827  /********************************/
12828 
12829  _container.event.mpi_event.type =
12830  T_MPI_ENUM(MPI_GET_ELEMENTS)
12831  ;
12832 
12833  /* Set default source & dest before override */
12834  _container.event.mpi_event.source = _rank;
12835  _container.event.mpi_event.dest = _rank;
12836 
12837 
12838 
12839 
12840 
12841  SET_DATATYPE (datatype)
12842 
12843 
12844  /* Fill in size informations if needed */
12845  int _size = 0;
12846  #if 1
12847 
12848  #endif
12849  _container.event.mpi_event.size = _size;
12850 
12851  /********************************/
12852  /* EMIT OTF ENTER */
12853  /********************************/
12854 
12855  struct MALP_Trace_Event otf_event;
12856 
12857  uint64_t _begin = Timer_tsc ();
12858 
12861  {
12862 
12863  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12864  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12865  MALP_EVENT_MPI, _container.event.mpi_event.type );
12866  Event_Packer_push(&otf_event);
12867  }
12868 
12869  /********************************/
12870  /* ACTUAL FUNCTION CALL */
12871  /********************************/
12872 
12874  int ret = PMPI_Get_elements( status, datatype, count );
12876 
12877  /********************************/
12878  /* EMIT OTF END */
12879  /********************************/
12880 
12881  uint64_t _end = Timer_tsc();
12882  uint64_t _duration = _end - _begin;
12883 
12885  {
12887  {
12888 
12889  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12890  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12891  MALP_EVENT_MPI, _container.event.mpi_event.type );
12892 
12893 
12894  Event_Packer_push(&otf_event);
12895  }
12896 
12897  /********************************/
12898  /* EMIT MALP EVENT */
12899  /********************************/
12900 
12901  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12902 
12903  /* Submit event if MPI instrumented */
12904  Event_Packer_push(&_container);
12905  }
12906 
12907 
12908  return ret;
12909 }
12910 int MPI_Get( void * origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win )
12911 {
12912 
12913  /* Virtualize MPI */
12914 
12915 
12916  /* Pre instrum */
12917  int _rank = Stream_desc_get()->mpi_rank;
12918 
12919  struct MALP_Trace_Event _container;
12920 
12921  /********************************/
12922  /* FILL MPI EVENT */
12923  /********************************/
12924 
12925  _container.event.mpi_event.type =
12926  T_MPI_ENUM(MPI_GET)
12927  ;
12928 
12929  /* Set default source & dest before override */
12930  _container.event.mpi_event.source = _rank;
12931  _container.event.mpi_event.dest = _rank;
12932 
12933 
12934 
12935 
12936 
12937 
12938 
12939 
12940  /* Fill in size informations if needed */
12941  int _size = 0;
12942  #if 0
12943 
12944  #endif
12945  _container.event.mpi_event.size = _size;
12946 
12947  /********************************/
12948  /* EMIT OTF ENTER */
12949  /********************************/
12950 
12951  struct MALP_Trace_Event otf_event;
12952 
12953  uint64_t _begin = Timer_tsc ();
12954 
12957  {
12958 
12959  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
12960  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
12961  MALP_EVENT_MPI, _container.event.mpi_event.type );
12962  Event_Packer_push(&otf_event);
12963  }
12964 
12965  /********************************/
12966  /* ACTUAL FUNCTION CALL */
12967  /********************************/
12968 
12970  int ret = PMPI_Get( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win );
12972 
12973  /********************************/
12974  /* EMIT OTF END */
12975  /********************************/
12976 
12977  uint64_t _end = Timer_tsc();
12978  uint64_t _duration = _end - _begin;
12979 
12981  {
12983  {
12984 
12985  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
12986  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
12987  MALP_EVENT_MPI, _container.event.mpi_event.type );
12988 
12989 
12990  Event_Packer_push(&otf_event);
12991  }
12992 
12993  /********************************/
12994  /* EMIT MALP EVENT */
12995  /********************************/
12996 
12997  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
12998 
12999  /* Submit event if MPI instrumented */
13000  Event_Packer_push(&_container);
13001  }
13002 
13003 
13004  return ret;
13005 }
13006 int MPI_Get_processor_name( char * name, int * resultlen )
13007 {
13008 
13009  /* Virtualize MPI */
13010 
13011 
13012  /* Pre instrum */
13013  int _rank = Stream_desc_get()->mpi_rank;
13014 
13015  struct MALP_Trace_Event _container;
13016 
13017  /********************************/
13018  /* FILL MPI EVENT */
13019  /********************************/
13020 
13021  _container.event.mpi_event.type =
13022  T_MPI_ENUM(MPI_GET_PROCESSOR_NAME)
13023  ;
13024 
13025  /* Set default source & dest before override */
13026  _container.event.mpi_event.source = _rank;
13027  _container.event.mpi_event.dest = _rank;
13028 
13029 
13030 
13031 
13032 
13033 
13034 
13035 
13036  /* Fill in size informations if needed */
13037  int _size = 0;
13038  #if 0
13039 
13040  #endif
13041  _container.event.mpi_event.size = _size;
13042 
13043  /********************************/
13044  /* EMIT OTF ENTER */
13045  /********************************/
13046 
13047  struct MALP_Trace_Event otf_event;
13048 
13049  uint64_t _begin = Timer_tsc ();
13050 
13053  {
13054 
13055  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13056  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13057  MALP_EVENT_MPI, _container.event.mpi_event.type );
13058  Event_Packer_push(&otf_event);
13059  }
13060 
13061  /********************************/
13062  /* ACTUAL FUNCTION CALL */
13063  /********************************/
13064 
13066  int ret = PMPI_Get_processor_name( name, resultlen );
13068 
13069  /********************************/
13070  /* EMIT OTF END */
13071  /********************************/
13072 
13073  uint64_t _end = Timer_tsc();
13074  uint64_t _duration = _end - _begin;
13075 
13077  {
13079  {
13080 
13081  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13082  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13083  MALP_EVENT_MPI, _container.event.mpi_event.type );
13084 
13085 
13086  Event_Packer_push(&otf_event);
13087  }
13088 
13089  /********************************/
13090  /* EMIT MALP EVENT */
13091  /********************************/
13092 
13093  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13094 
13095  /* Submit event if MPI instrumented */
13096  Event_Packer_push(&_container);
13097  }
13098 
13099 
13100  return ret;
13101 }
13102 int MPI_Get_version( int * version, int * subversion )
13103 {
13104 
13105  /* Virtualize MPI */
13106 
13107 
13108  /* Pre instrum */
13109  int _rank = Stream_desc_get()->mpi_rank;
13110 
13111  struct MALP_Trace_Event _container;
13112 
13113  /********************************/
13114  /* FILL MPI EVENT */
13115  /********************************/
13116 
13117  _container.event.mpi_event.type =
13118  T_MPI_ENUM(MPI_GET_VERSION)
13119  ;
13120 
13121  /* Set default source & dest before override */
13122  _container.event.mpi_event.source = _rank;
13123  _container.event.mpi_event.dest = _rank;
13124 
13125 
13126 
13127 
13128 
13129 
13130 
13131 
13132  /* Fill in size informations if needed */
13133  int _size = 0;
13134  #if 0
13135 
13136  #endif
13137  _container.event.mpi_event.size = _size;
13138 
13139  /********************************/
13140  /* EMIT OTF ENTER */
13141  /********************************/
13142 
13143  struct MALP_Trace_Event otf_event;
13144 
13145  uint64_t _begin = Timer_tsc ();
13146 
13149  {
13150 
13151  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13152  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13153  MALP_EVENT_MPI, _container.event.mpi_event.type );
13154  Event_Packer_push(&otf_event);
13155  }
13156 
13157  /********************************/
13158  /* ACTUAL FUNCTION CALL */
13159  /********************************/
13160 
13162  int ret = PMPI_Get_version( version, subversion );
13164 
13165  /********************************/
13166  /* EMIT OTF END */
13167  /********************************/
13168 
13169  uint64_t _end = Timer_tsc();
13170  uint64_t _duration = _end - _begin;
13171 
13173  {
13175  {
13176 
13177  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13178  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13179  MALP_EVENT_MPI, _container.event.mpi_event.type );
13180 
13181 
13182  Event_Packer_push(&otf_event);
13183  }
13184 
13185  /********************************/
13186  /* EMIT MALP EVENT */
13187  /********************************/
13188 
13189  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13190 
13191  /* Submit event if MPI instrumented */
13192  Event_Packer_push(&_container);
13193  }
13194 
13195 
13196  return ret;
13197 }
13198 int MPI_Graph_create( MPI_Comm comm_old, int nnodes, int * index, int * edges, int reorder, MPI_Comm * comm_graph )
13199 {
13200 
13201  /* Virtualize MPI */
13202  MACRO_MPI_Comm (comm_old)
13203 
13204  /* Pre instrum */
13205  int _rank = Stream_desc_get()->mpi_rank;
13206 
13207  struct MALP_Trace_Event _container;
13208 
13209  /********************************/
13210  /* FILL MPI EVENT */
13211  /********************************/
13212 
13213  _container.event.mpi_event.type =
13214  T_MPI_ENUM(MPI_GRAPH_CREATE)
13215  ;
13216 
13217  /* Set default source & dest before override */
13218  _container.event.mpi_event.source = _rank;
13219  _container.event.mpi_event.dest = _rank;
13220 
13221 
13222 
13223 
13224 
13225 
13226 
13227 
13228  /* Fill in size informations if needed */
13229  int _size = 0;
13230  #if 0
13231 
13232  #endif
13233  _container.event.mpi_event.size = _size;
13234 
13235  /********************************/
13236  /* EMIT OTF ENTER */
13237  /********************************/
13238 
13239  struct MALP_Trace_Event otf_event;
13240 
13241  uint64_t _begin = Timer_tsc ();
13242 
13245  {
13246 
13247  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13248  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13249  MALP_EVENT_MPI, _container.event.mpi_event.type );
13250  Event_Packer_push(&otf_event);
13251  }
13252 
13253  /********************************/
13254  /* ACTUAL FUNCTION CALL */
13255  /********************************/
13256 
13258  int ret = PMPI_Graph_create( comm_old, nnodes, index, edges, reorder, comm_graph );
13260 
13261  /********************************/
13262  /* EMIT OTF END */
13263  /********************************/
13264 
13265  uint64_t _end = Timer_tsc();
13266  uint64_t _duration = _end - _begin;
13267 
13269  {
13271  {
13272 
13273  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13274  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13275  MALP_EVENT_MPI, _container.event.mpi_event.type );
13276 
13277 
13278  Event_Packer_push(&otf_event);
13279  }
13280 
13281  /********************************/
13282  /* EMIT MALP EVENT */
13283  /********************************/
13284 
13285  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13286 
13287  /* Submit event if MPI instrumented */
13288  Event_Packer_push(&_container);
13289  }
13290 
13291 
13292  return ret;
13293 }
13294 int MPI_Graph_get( MPI_Comm comm, int maxindex, int maxedges, int * index, int * edges )
13295 {
13296 
13297  /* Virtualize MPI */
13298  MACRO_MPI_Comm (comm)
13299 
13300  /* Pre instrum */
13301  int _rank = Stream_desc_get()->mpi_rank;
13302 
13303  struct MALP_Trace_Event _container;
13304 
13305  /********************************/
13306  /* FILL MPI EVENT */
13307  /********************************/
13308 
13309  _container.event.mpi_event.type =
13310  T_MPI_ENUM(MPI_GRAPH_GET)
13311  ;
13312 
13313  /* Set default source & dest before override */
13314  _container.event.mpi_event.source = _rank;
13315  _container.event.mpi_event.dest = _rank;
13316 
13317 
13318 
13319 
13320 
13321 
13322  SET_COMM (comm)
13323 
13324  /* Fill in size informations if needed */
13325  int _size = 0;
13326  #if 0
13327 
13328  #endif
13329  _container.event.mpi_event.size = _size;
13330 
13331  /********************************/
13332  /* EMIT OTF ENTER */
13333  /********************************/
13334 
13335  struct MALP_Trace_Event otf_event;
13336 
13337  uint64_t _begin = Timer_tsc ();
13338 
13341  {
13342 
13343  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13344  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13345  MALP_EVENT_MPI, _container.event.mpi_event.type );
13346  Event_Packer_push(&otf_event);
13347  }
13348 
13349  /********************************/
13350  /* ACTUAL FUNCTION CALL */
13351  /********************************/
13352 
13354  int ret = PMPI_Graph_get( comm, maxindex, maxedges, index, edges );
13356 
13357  /********************************/
13358  /* EMIT OTF END */
13359  /********************************/
13360 
13361  uint64_t _end = Timer_tsc();
13362  uint64_t _duration = _end - _begin;
13363 
13365  {
13367  {
13368 
13369  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13370  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13371  MALP_EVENT_MPI, _container.event.mpi_event.type );
13372 
13373 
13374  Event_Packer_push(&otf_event);
13375  }
13376 
13377  /********************************/
13378  /* EMIT MALP EVENT */
13379  /********************************/
13380 
13381  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13382 
13383  /* Submit event if MPI instrumented */
13384  Event_Packer_push(&_container);
13385  }
13386 
13387 
13388  return ret;
13389 }
13390 int MPI_Graph_map( MPI_Comm comm, int nnodes, int * index, int * edges, int * newrank )
13391 {
13392 
13393  /* Virtualize MPI */
13394  MACRO_MPI_Comm (comm)
13395 
13396  /* Pre instrum */
13397  int _rank = Stream_desc_get()->mpi_rank;
13398 
13399  struct MALP_Trace_Event _container;
13400 
13401  /********************************/
13402  /* FILL MPI EVENT */
13403  /********************************/
13404 
13405  _container.event.mpi_event.type =
13406  T_MPI_ENUM(MPI_GRAPH_MAP)
13407  ;
13408 
13409  /* Set default source & dest before override */
13410  _container.event.mpi_event.source = _rank;
13411  _container.event.mpi_event.dest = _rank;
13412 
13413 
13414 
13415 
13416 
13417 
13418  SET_COMM (comm)
13419 
13420  /* Fill in size informations if needed */
13421  int _size = 0;
13422  #if 0
13423 
13424  #endif
13425  _container.event.mpi_event.size = _size;
13426 
13427  /********************************/
13428  /* EMIT OTF ENTER */
13429  /********************************/
13430 
13431  struct MALP_Trace_Event otf_event;
13432 
13433  uint64_t _begin = Timer_tsc ();
13434 
13437  {
13438 
13439  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13440  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13441  MALP_EVENT_MPI, _container.event.mpi_event.type );
13442  Event_Packer_push(&otf_event);
13443  }
13444 
13445  /********************************/
13446  /* ACTUAL FUNCTION CALL */
13447  /********************************/
13448 
13450  int ret = PMPI_Graph_map( comm, nnodes, index, edges, newrank );
13452 
13453  /********************************/
13454  /* EMIT OTF END */
13455  /********************************/
13456 
13457  uint64_t _end = Timer_tsc();
13458  uint64_t _duration = _end - _begin;
13459 
13461  {
13463  {
13464 
13465  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13466  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13467  MALP_EVENT_MPI, _container.event.mpi_event.type );
13468 
13469 
13470  Event_Packer_push(&otf_event);
13471  }
13472 
13473  /********************************/
13474  /* EMIT MALP EVENT */
13475  /********************************/
13476 
13477  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13478 
13479  /* Submit event if MPI instrumented */
13480  Event_Packer_push(&_container);
13481  }
13482 
13483 
13484  return ret;
13485 }
13486 int MPI_Graph_neighbors_count( MPI_Comm comm, int rank, int * nneighbors )
13487 {
13488 
13489  /* Virtualize MPI */
13490  MACRO_MPI_Comm (comm)
13491 
13492  /* Pre instrum */
13493  int _rank = Stream_desc_get()->mpi_rank;
13494 
13495  struct MALP_Trace_Event _container;
13496 
13497  /********************************/
13498  /* FILL MPI EVENT */
13499  /********************************/
13500 
13501  _container.event.mpi_event.type =
13502  T_MPI_ENUM(MPI_GRAPH_NEIGHBORS_COUNT)
13503  ;
13504 
13505  /* Set default source & dest before override */
13506  _container.event.mpi_event.source = _rank;
13507  _container.event.mpi_event.dest = _rank;
13508 
13509 
13510 
13511 
13512 
13513 
13514  SET_COMM (comm)
13515 
13516  /* Fill in size informations if needed */
13517  int _size = 0;
13518  #if 0
13519 
13520  #endif
13521  _container.event.mpi_event.size = _size;
13522 
13523  /********************************/
13524  /* EMIT OTF ENTER */
13525  /********************************/
13526 
13527  struct MALP_Trace_Event otf_event;
13528 
13529  uint64_t _begin = Timer_tsc ();
13530 
13533  {
13534 
13535  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13536  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13537  MALP_EVENT_MPI, _container.event.mpi_event.type );
13538  Event_Packer_push(&otf_event);
13539  }
13540 
13541  /********************************/
13542  /* ACTUAL FUNCTION CALL */
13543  /********************************/
13544 
13546  int ret = PMPI_Graph_neighbors_count( comm, rank, nneighbors );
13548 
13549  /********************************/
13550  /* EMIT OTF END */
13551  /********************************/
13552 
13553  uint64_t _end = Timer_tsc();
13554  uint64_t _duration = _end - _begin;
13555 
13557  {
13559  {
13560 
13561  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13562  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13563  MALP_EVENT_MPI, _container.event.mpi_event.type );
13564 
13565 
13566  Event_Packer_push(&otf_event);
13567  }
13568 
13569  /********************************/
13570  /* EMIT MALP EVENT */
13571  /********************************/
13572 
13573  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13574 
13575  /* Submit event if MPI instrumented */
13576  Event_Packer_push(&_container);
13577  }
13578 
13579 
13580  return ret;
13581 }
13582 int MPI_Graph_neighbors( MPI_Comm comm, int rank, int maxneighbors, int * neighbors )
13583 {
13584 
13585  /* Virtualize MPI */
13586  MACRO_MPI_Comm (comm)
13587 
13588  /* Pre instrum */
13589  int _rank = Stream_desc_get()->mpi_rank;
13590 
13591  struct MALP_Trace_Event _container;
13592 
13593  /********************************/
13594  /* FILL MPI EVENT */
13595  /********************************/
13596 
13597  _container.event.mpi_event.type =
13598  T_MPI_ENUM(MPI_GRAPH_NEIGHBORS)
13599  ;
13600 
13601  /* Set default source & dest before override */
13602  _container.event.mpi_event.source = _rank;
13603  _container.event.mpi_event.dest = _rank;
13604 
13605 
13606 
13607 
13608 
13609 
13610  SET_COMM (comm)
13611 
13612  /* Fill in size informations if needed */
13613  int _size = 0;
13614  #if 0
13615 
13616  #endif
13617  _container.event.mpi_event.size = _size;
13618 
13619  /********************************/
13620  /* EMIT OTF ENTER */
13621  /********************************/
13622 
13623  struct MALP_Trace_Event otf_event;
13624 
13625  uint64_t _begin = Timer_tsc ();
13626 
13629  {
13630 
13631  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13632  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13633  MALP_EVENT_MPI, _container.event.mpi_event.type );
13634  Event_Packer_push(&otf_event);
13635  }
13636 
13637  /********************************/
13638  /* ACTUAL FUNCTION CALL */
13639  /********************************/
13640 
13642  int ret = PMPI_Graph_neighbors( comm, rank, maxneighbors, neighbors );
13644 
13645  /********************************/
13646  /* EMIT OTF END */
13647  /********************************/
13648 
13649  uint64_t _end = Timer_tsc();
13650  uint64_t _duration = _end - _begin;
13651 
13653  {
13655  {
13656 
13657  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13658  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13659  MALP_EVENT_MPI, _container.event.mpi_event.type );
13660 
13661 
13662  Event_Packer_push(&otf_event);
13663  }
13664 
13665  /********************************/
13666  /* EMIT MALP EVENT */
13667  /********************************/
13668 
13669  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13670 
13671  /* Submit event if MPI instrumented */
13672  Event_Packer_push(&_container);
13673  }
13674 
13675 
13676  return ret;
13677 }
13678 int MPI_Graphdims_get( MPI_Comm comm, int * nnodes, int * nedges )
13679 {
13680 
13681  /* Virtualize MPI */
13682  MACRO_MPI_Comm (comm)
13683 
13684  /* Pre instrum */
13685  int _rank = Stream_desc_get()->mpi_rank;
13686 
13687  struct MALP_Trace_Event _container;
13688 
13689  /********************************/
13690  /* FILL MPI EVENT */
13691  /********************************/
13692 
13693  _container.event.mpi_event.type =
13694  T_MPI_ENUM(MPI_GRAPHDIMS_GET)
13695  ;
13696 
13697  /* Set default source & dest before override */
13698  _container.event.mpi_event.source = _rank;
13699  _container.event.mpi_event.dest = _rank;
13700 
13701 
13702 
13703 
13704 
13705 
13706  SET_COMM (comm)
13707 
13708  /* Fill in size informations if needed */
13709  int _size = 0;
13710  #if 0
13711 
13712  #endif
13713  _container.event.mpi_event.size = _size;
13714 
13715  /********************************/
13716  /* EMIT OTF ENTER */
13717  /********************************/
13718 
13719  struct MALP_Trace_Event otf_event;
13720 
13721  uint64_t _begin = Timer_tsc ();
13722 
13725  {
13726 
13727  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13728  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13729  MALP_EVENT_MPI, _container.event.mpi_event.type );
13730  Event_Packer_push(&otf_event);
13731  }
13732 
13733  /********************************/
13734  /* ACTUAL FUNCTION CALL */
13735  /********************************/
13736 
13738  int ret = PMPI_Graphdims_get( comm, nnodes, nedges );
13740 
13741  /********************************/
13742  /* EMIT OTF END */
13743  /********************************/
13744 
13745  uint64_t _end = Timer_tsc();
13746  uint64_t _duration = _end - _begin;
13747 
13749  {
13751  {
13752 
13753  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13754  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13755  MALP_EVENT_MPI, _container.event.mpi_event.type );
13756 
13757 
13758  Event_Packer_push(&otf_event);
13759  }
13760 
13761  /********************************/
13762  /* EMIT MALP EVENT */
13763  /********************************/
13764 
13765  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13766 
13767  /* Submit event if MPI instrumented */
13768  Event_Packer_push(&_container);
13769  }
13770 
13771 
13772  return ret;
13773 }
13774 int MPI_Grequest_complete( MPI_Request request )
13775 {
13776 
13777  /* Virtualize MPI */
13778 
13779 
13780  /* Pre instrum */
13781  int _rank = Stream_desc_get()->mpi_rank;
13782 
13783  struct MALP_Trace_Event _container;
13784 
13785  /********************************/
13786  /* FILL MPI EVENT */
13787  /********************************/
13788 
13789  _container.event.mpi_event.type =
13790  T_MPI_ENUM(MPI_GREQUEST_COMPLETE)
13791  ;
13792 
13793  /* Set default source & dest before override */
13794  _container.event.mpi_event.source = _rank;
13795  _container.event.mpi_event.dest = _rank;
13796 
13797 
13798 
13799 
13800 
13801 
13802 
13803 
13804  /* Fill in size informations if needed */
13805  int _size = 0;
13806  #if 0
13807 
13808  #endif
13809  _container.event.mpi_event.size = _size;
13810 
13811  /********************************/
13812  /* EMIT OTF ENTER */
13813  /********************************/
13814 
13815  struct MALP_Trace_Event otf_event;
13816 
13817  uint64_t _begin = Timer_tsc ();
13818 
13821  {
13822 
13823  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13824  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13825  MALP_EVENT_MPI, _container.event.mpi_event.type );
13826  Event_Packer_push(&otf_event);
13827  }
13828 
13829  /********************************/
13830  /* ACTUAL FUNCTION CALL */
13831  /********************************/
13832 
13834  int ret = PMPI_Grequest_complete( request );
13836 
13837  /********************************/
13838  /* EMIT OTF END */
13839  /********************************/
13840 
13841  uint64_t _end = Timer_tsc();
13842  uint64_t _duration = _end - _begin;
13843 
13845  {
13847  {
13848 
13849  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13850  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13851  MALP_EVENT_MPI, _container.event.mpi_event.type );
13852 
13853 
13854  Event_Packer_push(&otf_event);
13855  }
13856 
13857  /********************************/
13858  /* EMIT MALP EVENT */
13859  /********************************/
13860 
13861  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13862 
13863  /* Submit event if MPI instrumented */
13864  Event_Packer_push(&_container);
13865  }
13866 
13867 
13868  return ret;
13869 }
13870 int MPI_Grequest_start( MPI_Grequest_query_function * query_fn, MPI_Grequest_free_function * free_fn, MPI_Grequest_cancel_function * cancel_fn, void * extra_state, MPI_Request * request )
13871 {
13872 
13873  /* Virtualize MPI */
13874 
13875 
13876  /* Pre instrum */
13877  int _rank = Stream_desc_get()->mpi_rank;
13878 
13879  struct MALP_Trace_Event _container;
13880 
13881  /********************************/
13882  /* FILL MPI EVENT */
13883  /********************************/
13884 
13885  _container.event.mpi_event.type =
13886  T_MPI_ENUM(MPI_GREQUEST_START)
13887  ;
13888 
13889  /* Set default source & dest before override */
13890  _container.event.mpi_event.source = _rank;
13891  _container.event.mpi_event.dest = _rank;
13892 
13893 
13894 
13895 
13896 
13897 
13898 
13899 
13900  /* Fill in size informations if needed */
13901  int _size = 0;
13902  #if 0
13903 
13904  #endif
13905  _container.event.mpi_event.size = _size;
13906 
13907  /********************************/
13908  /* EMIT OTF ENTER */
13909  /********************************/
13910 
13911  struct MALP_Trace_Event otf_event;
13912 
13913  uint64_t _begin = Timer_tsc ();
13914 
13917  {
13918 
13919  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
13920  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
13921  MALP_EVENT_MPI, _container.event.mpi_event.type );
13922  Event_Packer_push(&otf_event);
13923  }
13924 
13925  /********************************/
13926  /* ACTUAL FUNCTION CALL */
13927  /********************************/
13928 
13930  int ret = PMPI_Grequest_start( query_fn, free_fn, cancel_fn, extra_state, request );
13932 
13933  /********************************/
13934  /* EMIT OTF END */
13935  /********************************/
13936 
13937  uint64_t _end = Timer_tsc();
13938  uint64_t _duration = _end - _begin;
13939 
13941  {
13943  {
13944 
13945  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
13946  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
13947  MALP_EVENT_MPI, _container.event.mpi_event.type );
13948 
13949 
13950  Event_Packer_push(&otf_event);
13951  }
13952 
13953  /********************************/
13954  /* EMIT MALP EVENT */
13955  /********************************/
13956 
13957  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
13958 
13959  /* Submit event if MPI instrumented */
13960  Event_Packer_push(&_container);
13961  }
13962 
13963 
13964  return ret;
13965 }
13966 int MPI_Group_c2f( MPI_Group group )
13967 {
13968 
13969  /* Virtualize MPI */
13970 
13971 
13972  /* Pre instrum */
13973  int _rank = Stream_desc_get()->mpi_rank;
13974 
13975  struct MALP_Trace_Event _container;
13976 
13977  /********************************/
13978  /* FILL MPI EVENT */
13979  /********************************/
13980 
13981  _container.event.mpi_event.type =
13982  T_MPI_ENUM(MPI_GROUP_C2F)
13983  ;
13984 
13985  /* Set default source & dest before override */
13986  _container.event.mpi_event.source = _rank;
13987  _container.event.mpi_event.dest = _rank;
13988 
13989 
13990 
13991 
13992 
13993 
13994 
13995 
13996  /* Fill in size informations if needed */
13997  int _size = 0;
13998  #if 0
13999 
14000  #endif
14001  _container.event.mpi_event.size = _size;
14002 
14003  /********************************/
14004  /* EMIT OTF ENTER */
14005  /********************************/
14006 
14007  struct MALP_Trace_Event otf_event;
14008 
14009  uint64_t _begin = Timer_tsc ();
14010 
14013  {
14014 
14015  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14016  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14017  MALP_EVENT_MPI, _container.event.mpi_event.type );
14018  Event_Packer_push(&otf_event);
14019  }
14020 
14021  /********************************/
14022  /* ACTUAL FUNCTION CALL */
14023  /********************************/
14024 
14026  int ret = PMPI_Group_c2f( group );
14028 
14029  /********************************/
14030  /* EMIT OTF END */
14031  /********************************/
14032 
14033  uint64_t _end = Timer_tsc();
14034  uint64_t _duration = _end - _begin;
14035 
14037  {
14039  {
14040 
14041  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14042  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14043  MALP_EVENT_MPI, _container.event.mpi_event.type );
14044 
14045 
14046  Event_Packer_push(&otf_event);
14047  }
14048 
14049  /********************************/
14050  /* EMIT MALP EVENT */
14051  /********************************/
14052 
14053  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14054 
14055  /* Submit event if MPI instrumented */
14056  Event_Packer_push(&_container);
14057  }
14058 
14059 
14060  return ret;
14061 }
14062 int MPI_Group_compare( MPI_Group group1, MPI_Group group2, int * result )
14063 {
14064 
14065  /* Virtualize MPI */
14066 
14067 
14068  /* Pre instrum */
14069  int _rank = Stream_desc_get()->mpi_rank;
14070 
14071  struct MALP_Trace_Event _container;
14072 
14073  /********************************/
14074  /* FILL MPI EVENT */
14075  /********************************/
14076 
14077  _container.event.mpi_event.type =
14078  T_MPI_ENUM(MPI_GROUP_COMPARE)
14079  ;
14080 
14081  /* Set default source & dest before override */
14082  _container.event.mpi_event.source = _rank;
14083  _container.event.mpi_event.dest = _rank;
14084 
14085 
14086 
14087 
14088 
14089 
14090 
14091 
14092  /* Fill in size informations if needed */
14093  int _size = 0;
14094  #if 0
14095 
14096  #endif
14097  _container.event.mpi_event.size = _size;
14098 
14099  /********************************/
14100  /* EMIT OTF ENTER */
14101  /********************************/
14102 
14103  struct MALP_Trace_Event otf_event;
14104 
14105  uint64_t _begin = Timer_tsc ();
14106 
14109  {
14110 
14111  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14112  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14113  MALP_EVENT_MPI, _container.event.mpi_event.type );
14114  Event_Packer_push(&otf_event);
14115  }
14116 
14117  /********************************/
14118  /* ACTUAL FUNCTION CALL */
14119  /********************************/
14120 
14122  int ret = PMPI_Group_compare( group1, group2, result );
14124 
14125  /********************************/
14126  /* EMIT OTF END */
14127  /********************************/
14128 
14129  uint64_t _end = Timer_tsc();
14130  uint64_t _duration = _end - _begin;
14131 
14133  {
14135  {
14136 
14137  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14138  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14139  MALP_EVENT_MPI, _container.event.mpi_event.type );
14140 
14141 
14142  Event_Packer_push(&otf_event);
14143  }
14144 
14145  /********************************/
14146  /* EMIT MALP EVENT */
14147  /********************************/
14148 
14149  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14150 
14151  /* Submit event if MPI instrumented */
14152  Event_Packer_push(&_container);
14153  }
14154 
14155 
14156  return ret;
14157 }
14158 int MPI_Group_difference( MPI_Group group1, MPI_Group group2, MPI_Group * newgroup )
14159 {
14160 
14161  /* Virtualize MPI */
14162 
14163 
14164  /* Pre instrum */
14165  int _rank = Stream_desc_get()->mpi_rank;
14166 
14167  struct MALP_Trace_Event _container;
14168 
14169  /********************************/
14170  /* FILL MPI EVENT */
14171  /********************************/
14172 
14173  _container.event.mpi_event.type =
14174  T_MPI_ENUM(MPI_GROUP_DIFFERENCE)
14175  ;
14176 
14177  /* Set default source & dest before override */
14178  _container.event.mpi_event.source = _rank;
14179  _container.event.mpi_event.dest = _rank;
14180 
14181 
14182 
14183 
14184 
14185 
14186 
14187 
14188  /* Fill in size informations if needed */
14189  int _size = 0;
14190  #if 0
14191 
14192  #endif
14193  _container.event.mpi_event.size = _size;
14194 
14195  /********************************/
14196  /* EMIT OTF ENTER */
14197  /********************************/
14198 
14199  struct MALP_Trace_Event otf_event;
14200 
14201  uint64_t _begin = Timer_tsc ();
14202 
14205  {
14206 
14207  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14208  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14209  MALP_EVENT_MPI, _container.event.mpi_event.type );
14210  Event_Packer_push(&otf_event);
14211  }
14212 
14213  /********************************/
14214  /* ACTUAL FUNCTION CALL */
14215  /********************************/
14216 
14218  int ret = PMPI_Group_difference( group1, group2, newgroup );
14220 
14221  /********************************/
14222  /* EMIT OTF END */
14223  /********************************/
14224 
14225  uint64_t _end = Timer_tsc();
14226  uint64_t _duration = _end - _begin;
14227 
14229  {
14231  {
14232 
14233  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14234  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14235  MALP_EVENT_MPI, _container.event.mpi_event.type );
14236 
14237 
14238  Event_Packer_push(&otf_event);
14239  }
14240 
14241  /********************************/
14242  /* EMIT MALP EVENT */
14243  /********************************/
14244 
14245  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14246 
14247  /* Submit event if MPI instrumented */
14248  Event_Packer_push(&_container);
14249  }
14250 
14251 
14252  return ret;
14253 }
14254 int MPI_Group_excl( MPI_Group group, int n, int * ranks, MPI_Group * newgroup )
14255 {
14256 
14257  /* Virtualize MPI */
14258 
14259 
14260  /* Pre instrum */
14261  int _rank = Stream_desc_get()->mpi_rank;
14262 
14263  struct MALP_Trace_Event _container;
14264 
14265  /********************************/
14266  /* FILL MPI EVENT */
14267  /********************************/
14268 
14269  _container.event.mpi_event.type =
14270  T_MPI_ENUM(MPI_GROUP_EXCL)
14271  ;
14272 
14273  /* Set default source & dest before override */
14274  _container.event.mpi_event.source = _rank;
14275  _container.event.mpi_event.dest = _rank;
14276 
14277 
14278 
14279 
14280 
14281 
14282 
14283 
14284  /* Fill in size informations if needed */
14285  int _size = 0;
14286  #if 0
14287 
14288  #endif
14289  _container.event.mpi_event.size = _size;
14290 
14291  /********************************/
14292  /* EMIT OTF ENTER */
14293  /********************************/
14294 
14295  struct MALP_Trace_Event otf_event;
14296 
14297  uint64_t _begin = Timer_tsc ();
14298 
14301  {
14302 
14303  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14304  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14305  MALP_EVENT_MPI, _container.event.mpi_event.type );
14306  Event_Packer_push(&otf_event);
14307  }
14308 
14309  /********************************/
14310  /* ACTUAL FUNCTION CALL */
14311  /********************************/
14312 
14314  int ret = PMPI_Group_excl( group, n, ranks, newgroup );
14316 
14317  /********************************/
14318  /* EMIT OTF END */
14319  /********************************/
14320 
14321  uint64_t _end = Timer_tsc();
14322  uint64_t _duration = _end - _begin;
14323 
14325  {
14327  {
14328 
14329  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14330  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14331  MALP_EVENT_MPI, _container.event.mpi_event.type );
14332 
14333 
14334  Event_Packer_push(&otf_event);
14335  }
14336 
14337  /********************************/
14338  /* EMIT MALP EVENT */
14339  /********************************/
14340 
14341  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14342 
14343  /* Submit event if MPI instrumented */
14344  Event_Packer_push(&_container);
14345  }
14346 
14347 
14348  return ret;
14349 }
14350 int MPI_Group_free( MPI_Group * group )
14351 {
14352 
14353  /* Virtualize MPI */
14354 
14355 
14356  /* Pre instrum */
14357  int _rank = Stream_desc_get()->mpi_rank;
14358 
14359  struct MALP_Trace_Event _container;
14360 
14361  /********************************/
14362  /* FILL MPI EVENT */
14363  /********************************/
14364 
14365  _container.event.mpi_event.type =
14366  T_MPI_ENUM(MPI_GROUP_FREE)
14367  ;
14368 
14369  /* Set default source & dest before override */
14370  _container.event.mpi_event.source = _rank;
14371  _container.event.mpi_event.dest = _rank;
14372 
14373 
14374 
14375 
14376 
14377 
14378 
14379 
14380  /* Fill in size informations if needed */
14381  int _size = 0;
14382  #if 0
14383 
14384  #endif
14385  _container.event.mpi_event.size = _size;
14386 
14387  /********************************/
14388  /* EMIT OTF ENTER */
14389  /********************************/
14390 
14391  struct MALP_Trace_Event otf_event;
14392 
14393  uint64_t _begin = Timer_tsc ();
14394 
14397  {
14398 
14399  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14400  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14401  MALP_EVENT_MPI, _container.event.mpi_event.type );
14402  Event_Packer_push(&otf_event);
14403  }
14404 
14405  /********************************/
14406  /* ACTUAL FUNCTION CALL */
14407  /********************************/
14408 
14410  int ret = PMPI_Group_free( group );
14412 
14413  /********************************/
14414  /* EMIT OTF END */
14415  /********************************/
14416 
14417  uint64_t _end = Timer_tsc();
14418  uint64_t _duration = _end - _begin;
14419 
14421  {
14423  {
14424 
14425  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14426  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14427  MALP_EVENT_MPI, _container.event.mpi_event.type );
14428 
14429 
14430  Event_Packer_push(&otf_event);
14431  }
14432 
14433  /********************************/
14434  /* EMIT MALP EVENT */
14435  /********************************/
14436 
14437  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14438 
14439  /* Submit event if MPI instrumented */
14440  Event_Packer_push(&_container);
14441  }
14442 
14443 
14444  return ret;
14445 }
14446 int MPI_Group_incl( MPI_Group group, int n, int * ranks, MPI_Group * newgroup )
14447 {
14448 
14449  /* Virtualize MPI */
14450 
14451 
14452  /* Pre instrum */
14453  int _rank = Stream_desc_get()->mpi_rank;
14454 
14455  struct MALP_Trace_Event _container;
14456 
14457  /********************************/
14458  /* FILL MPI EVENT */
14459  /********************************/
14460 
14461  _container.event.mpi_event.type =
14462  T_MPI_ENUM(MPI_GROUP_INCL)
14463  ;
14464 
14465  /* Set default source & dest before override */
14466  _container.event.mpi_event.source = _rank;
14467  _container.event.mpi_event.dest = _rank;
14468 
14469 
14470 
14471 
14472 
14473 
14474 
14475 
14476  /* Fill in size informations if needed */
14477  int _size = 0;
14478  #if 0
14479 
14480  #endif
14481  _container.event.mpi_event.size = _size;
14482 
14483  /********************************/
14484  /* EMIT OTF ENTER */
14485  /********************************/
14486 
14487  struct MALP_Trace_Event otf_event;
14488 
14489  uint64_t _begin = Timer_tsc ();
14490 
14493  {
14494 
14495  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14496  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14497  MALP_EVENT_MPI, _container.event.mpi_event.type );
14498  Event_Packer_push(&otf_event);
14499  }
14500 
14501  /********************************/
14502  /* ACTUAL FUNCTION CALL */
14503  /********************************/
14504 
14506  int ret = PMPI_Group_incl( group, n, ranks, newgroup );
14508 
14509  /********************************/
14510  /* EMIT OTF END */
14511  /********************************/
14512 
14513  uint64_t _end = Timer_tsc();
14514  uint64_t _duration = _end - _begin;
14515 
14517  {
14519  {
14520 
14521  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14522  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14523  MALP_EVENT_MPI, _container.event.mpi_event.type );
14524 
14525 
14526  Event_Packer_push(&otf_event);
14527  }
14528 
14529  /********************************/
14530  /* EMIT MALP EVENT */
14531  /********************************/
14532 
14533  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14534 
14535  /* Submit event if MPI instrumented */
14536  Event_Packer_push(&_container);
14537  }
14538 
14539 
14540  return ret;
14541 }
14542 int MPI_Group_intersection( MPI_Group group1, MPI_Group group2, MPI_Group * newgroup )
14543 {
14544 
14545  /* Virtualize MPI */
14546 
14547 
14548  /* Pre instrum */
14549  int _rank = Stream_desc_get()->mpi_rank;
14550 
14551  struct MALP_Trace_Event _container;
14552 
14553  /********************************/
14554  /* FILL MPI EVENT */
14555  /********************************/
14556 
14557  _container.event.mpi_event.type =
14558  T_MPI_ENUM(MPI_GROUP_INTERSECTION)
14559  ;
14560 
14561  /* Set default source & dest before override */
14562  _container.event.mpi_event.source = _rank;
14563  _container.event.mpi_event.dest = _rank;
14564 
14565 
14566 
14567 
14568 
14569 
14570 
14571 
14572  /* Fill in size informations if needed */
14573  int _size = 0;
14574  #if 0
14575 
14576  #endif
14577  _container.event.mpi_event.size = _size;
14578 
14579  /********************************/
14580  /* EMIT OTF ENTER */
14581  /********************************/
14582 
14583  struct MALP_Trace_Event otf_event;
14584 
14585  uint64_t _begin = Timer_tsc ();
14586 
14589  {
14590 
14591  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14592  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14593  MALP_EVENT_MPI, _container.event.mpi_event.type );
14594  Event_Packer_push(&otf_event);
14595  }
14596 
14597  /********************************/
14598  /* ACTUAL FUNCTION CALL */
14599  /********************************/
14600 
14602  int ret = PMPI_Group_intersection( group1, group2, newgroup );
14604 
14605  /********************************/
14606  /* EMIT OTF END */
14607  /********************************/
14608 
14609  uint64_t _end = Timer_tsc();
14610  uint64_t _duration = _end - _begin;
14611 
14613  {
14615  {
14616 
14617  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14618  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14619  MALP_EVENT_MPI, _container.event.mpi_event.type );
14620 
14621 
14622  Event_Packer_push(&otf_event);
14623  }
14624 
14625  /********************************/
14626  /* EMIT MALP EVENT */
14627  /********************************/
14628 
14629  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14630 
14631  /* Submit event if MPI instrumented */
14632  Event_Packer_push(&_container);
14633  }
14634 
14635 
14636  return ret;
14637 }
14638 int MPI_Group_range_excl( MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup )
14639 {
14640 
14641  /* Virtualize MPI */
14642 
14643 
14644  /* Pre instrum */
14645  int _rank = Stream_desc_get()->mpi_rank;
14646 
14647  struct MALP_Trace_Event _container;
14648 
14649  /********************************/
14650  /* FILL MPI EVENT */
14651  /********************************/
14652 
14653  _container.event.mpi_event.type =
14654  T_MPI_ENUM(MPI_GROUP_RANGE_EXCL)
14655  ;
14656 
14657  /* Set default source & dest before override */
14658  _container.event.mpi_event.source = _rank;
14659  _container.event.mpi_event.dest = _rank;
14660 
14661 
14662 
14663 
14664 
14665 
14666 
14667 
14668  /* Fill in size informations if needed */
14669  int _size = 0;
14670  #if 0
14671 
14672  #endif
14673  _container.event.mpi_event.size = _size;
14674 
14675  /********************************/
14676  /* EMIT OTF ENTER */
14677  /********************************/
14678 
14679  struct MALP_Trace_Event otf_event;
14680 
14681  uint64_t _begin = Timer_tsc ();
14682 
14685  {
14686 
14687  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14688  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14689  MALP_EVENT_MPI, _container.event.mpi_event.type );
14690  Event_Packer_push(&otf_event);
14691  }
14692 
14693  /********************************/
14694  /* ACTUAL FUNCTION CALL */
14695  /********************************/
14696 
14698  int ret = PMPI_Group_range_excl( group, n, ranges, newgroup );
14700 
14701  /********************************/
14702  /* EMIT OTF END */
14703  /********************************/
14704 
14705  uint64_t _end = Timer_tsc();
14706  uint64_t _duration = _end - _begin;
14707 
14709  {
14711  {
14712 
14713  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14714  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14715  MALP_EVENT_MPI, _container.event.mpi_event.type );
14716 
14717 
14718  Event_Packer_push(&otf_event);
14719  }
14720 
14721  /********************************/
14722  /* EMIT MALP EVENT */
14723  /********************************/
14724 
14725  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14726 
14727  /* Submit event if MPI instrumented */
14728  Event_Packer_push(&_container);
14729  }
14730 
14731 
14732  return ret;
14733 }
14734 int MPI_Group_range_incl( MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup )
14735 {
14736 
14737  /* Virtualize MPI */
14738 
14739 
14740  /* Pre instrum */
14741  int _rank = Stream_desc_get()->mpi_rank;
14742 
14743  struct MALP_Trace_Event _container;
14744 
14745  /********************************/
14746  /* FILL MPI EVENT */
14747  /********************************/
14748 
14749  _container.event.mpi_event.type =
14750  T_MPI_ENUM(MPI_GROUP_RANGE_INCL)
14751  ;
14752 
14753  /* Set default source & dest before override */
14754  _container.event.mpi_event.source = _rank;
14755  _container.event.mpi_event.dest = _rank;
14756 
14757 
14758 
14759 
14760 
14761 
14762 
14763 
14764  /* Fill in size informations if needed */
14765  int _size = 0;
14766  #if 0
14767 
14768  #endif
14769  _container.event.mpi_event.size = _size;
14770 
14771  /********************************/
14772  /* EMIT OTF ENTER */
14773  /********************************/
14774 
14775  struct MALP_Trace_Event otf_event;
14776 
14777  uint64_t _begin = Timer_tsc ();
14778 
14781  {
14782 
14783  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14784  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14785  MALP_EVENT_MPI, _container.event.mpi_event.type );
14786  Event_Packer_push(&otf_event);
14787  }
14788 
14789  /********************************/
14790  /* ACTUAL FUNCTION CALL */
14791  /********************************/
14792 
14794  int ret = PMPI_Group_range_incl( group, n, ranges, newgroup );
14796 
14797  /********************************/
14798  /* EMIT OTF END */
14799  /********************************/
14800 
14801  uint64_t _end = Timer_tsc();
14802  uint64_t _duration = _end - _begin;
14803 
14805  {
14807  {
14808 
14809  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14810  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14811  MALP_EVENT_MPI, _container.event.mpi_event.type );
14812 
14813 
14814  Event_Packer_push(&otf_event);
14815  }
14816 
14817  /********************************/
14818  /* EMIT MALP EVENT */
14819  /********************************/
14820 
14821  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14822 
14823  /* Submit event if MPI instrumented */
14824  Event_Packer_push(&_container);
14825  }
14826 
14827 
14828  return ret;
14829 }
14830 int MPI_Group_rank( MPI_Group group, int * rank )
14831 {
14832 
14833  /* Virtualize MPI */
14834 
14835 
14836  /* Pre instrum */
14837  int _rank = Stream_desc_get()->mpi_rank;
14838 
14839  struct MALP_Trace_Event _container;
14840 
14841  /********************************/
14842  /* FILL MPI EVENT */
14843  /********************************/
14844 
14845  _container.event.mpi_event.type =
14846  T_MPI_ENUM(MPI_GROUP_RANK)
14847  ;
14848 
14849  /* Set default source & dest before override */
14850  _container.event.mpi_event.source = _rank;
14851  _container.event.mpi_event.dest = _rank;
14852 
14853 
14854 
14855 
14856 
14857 
14858 
14859 
14860  /* Fill in size informations if needed */
14861  int _size = 0;
14862  #if 0
14863 
14864  #endif
14865  _container.event.mpi_event.size = _size;
14866 
14867  /********************************/
14868  /* EMIT OTF ENTER */
14869  /********************************/
14870 
14871  struct MALP_Trace_Event otf_event;
14872 
14873  uint64_t _begin = Timer_tsc ();
14874 
14877  {
14878 
14879  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14880  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14881  MALP_EVENT_MPI, _container.event.mpi_event.type );
14882  Event_Packer_push(&otf_event);
14883  }
14884 
14885  /********************************/
14886  /* ACTUAL FUNCTION CALL */
14887  /********************************/
14888 
14890  int ret = PMPI_Group_rank( group, rank );
14892 
14893  /********************************/
14894  /* EMIT OTF END */
14895  /********************************/
14896 
14897  uint64_t _end = Timer_tsc();
14898  uint64_t _duration = _end - _begin;
14899 
14901  {
14903  {
14904 
14905  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
14906  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
14907  MALP_EVENT_MPI, _container.event.mpi_event.type );
14908 
14909 
14910  Event_Packer_push(&otf_event);
14911  }
14912 
14913  /********************************/
14914  /* EMIT MALP EVENT */
14915  /********************************/
14916 
14917  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
14918 
14919  /* Submit event if MPI instrumented */
14920  Event_Packer_push(&_container);
14921  }
14922 
14923 
14924  return ret;
14925 }
14926 int MPI_Group_size( MPI_Group group, int * size )
14927 {
14928 
14929  /* Virtualize MPI */
14930 
14931 
14932  /* Pre instrum */
14933  int _rank = Stream_desc_get()->mpi_rank;
14934 
14935  struct MALP_Trace_Event _container;
14936 
14937  /********************************/
14938  /* FILL MPI EVENT */
14939  /********************************/
14940 
14941  _container.event.mpi_event.type =
14942  T_MPI_ENUM(MPI_GROUP_SIZE)
14943  ;
14944 
14945  /* Set default source & dest before override */
14946  _container.event.mpi_event.source = _rank;
14947  _container.event.mpi_event.dest = _rank;
14948 
14949 
14950 
14951 
14952 
14953 
14954 
14955 
14956  /* Fill in size informations if needed */
14957  int _size = 0;
14958  #if 0
14959 
14960  #endif
14961  _container.event.mpi_event.size = _size;
14962 
14963  /********************************/
14964  /* EMIT OTF ENTER */
14965  /********************************/
14966 
14967  struct MALP_Trace_Event otf_event;
14968 
14969  uint64_t _begin = Timer_tsc ();
14970 
14973  {
14974 
14975  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
14976  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
14977  MALP_EVENT_MPI, _container.event.mpi_event.type );
14978  Event_Packer_push(&otf_event);
14979  }
14980 
14981  /********************************/
14982  /* ACTUAL FUNCTION CALL */
14983  /********************************/
14984 
14986  int ret = PMPI_Group_size( group, size );
14988 
14989  /********************************/
14990  /* EMIT OTF END */
14991  /********************************/
14992 
14993  uint64_t _end = Timer_tsc();
14994  uint64_t _duration = _end - _begin;
14995 
14997  {
14999  {
15000 
15001  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15002  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15003  MALP_EVENT_MPI, _container.event.mpi_event.type );
15004 
15005 
15006  Event_Packer_push(&otf_event);
15007  }
15008 
15009  /********************************/
15010  /* EMIT MALP EVENT */
15011  /********************************/
15012 
15013  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15014 
15015  /* Submit event if MPI instrumented */
15016  Event_Packer_push(&_container);
15017  }
15018 
15019 
15020  return ret;
15021 }
15022 int MPI_Group_translate_ranks( MPI_Group group1, int n, int * ranks1, MPI_Group group2, int * ranks2 )
15023 {
15024 
15025  /* Virtualize MPI */
15026 
15027 
15028  /* Pre instrum */
15029  int _rank = Stream_desc_get()->mpi_rank;
15030 
15031  struct MALP_Trace_Event _container;
15032 
15033  /********************************/
15034  /* FILL MPI EVENT */
15035  /********************************/
15036 
15037  _container.event.mpi_event.type =
15038  T_MPI_ENUM(MPI_GROUP_TRANSLATE_RANKS)
15039  ;
15040 
15041  /* Set default source & dest before override */
15042  _container.event.mpi_event.source = _rank;
15043  _container.event.mpi_event.dest = _rank;
15044 
15045 
15046 
15047 
15048 
15049 
15050 
15051 
15052  /* Fill in size informations if needed */
15053  int _size = 0;
15054  #if 0
15055 
15056  #endif
15057  _container.event.mpi_event.size = _size;
15058 
15059  /********************************/
15060  /* EMIT OTF ENTER */
15061  /********************************/
15062 
15063  struct MALP_Trace_Event otf_event;
15064 
15065  uint64_t _begin = Timer_tsc ();
15066 
15069  {
15070 
15071  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15072  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15073  MALP_EVENT_MPI, _container.event.mpi_event.type );
15074  Event_Packer_push(&otf_event);
15075  }
15076 
15077  /********************************/
15078  /* ACTUAL FUNCTION CALL */
15079  /********************************/
15080 
15082  int ret = PMPI_Group_translate_ranks( group1, n, ranks1, group2, ranks2 );
15084 
15085  /********************************/
15086  /* EMIT OTF END */
15087  /********************************/
15088 
15089  uint64_t _end = Timer_tsc();
15090  uint64_t _duration = _end - _begin;
15091 
15093  {
15095  {
15096 
15097  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15098  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15099  MALP_EVENT_MPI, _container.event.mpi_event.type );
15100 
15101 
15102  Event_Packer_push(&otf_event);
15103  }
15104 
15105  /********************************/
15106  /* EMIT MALP EVENT */
15107  /********************************/
15108 
15109  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15110 
15111  /* Submit event if MPI instrumented */
15112  Event_Packer_push(&_container);
15113  }
15114 
15115 
15116  return ret;
15117 }
15118 int MPI_Group_union( MPI_Group group1, MPI_Group group2, MPI_Group * newgroup )
15119 {
15120 
15121  /* Virtualize MPI */
15122 
15123 
15124  /* Pre instrum */
15125  int _rank = Stream_desc_get()->mpi_rank;
15126 
15127  struct MALP_Trace_Event _container;
15128 
15129  /********************************/
15130  /* FILL MPI EVENT */
15131  /********************************/
15132 
15133  _container.event.mpi_event.type =
15134  T_MPI_ENUM(MPI_GROUP_UNION)
15135  ;
15136 
15137  /* Set default source & dest before override */
15138  _container.event.mpi_event.source = _rank;
15139  _container.event.mpi_event.dest = _rank;
15140 
15141 
15142 
15143 
15144 
15145 
15146 
15147 
15148  /* Fill in size informations if needed */
15149  int _size = 0;
15150  #if 0
15151 
15152  #endif
15153  _container.event.mpi_event.size = _size;
15154 
15155  /********************************/
15156  /* EMIT OTF ENTER */
15157  /********************************/
15158 
15159  struct MALP_Trace_Event otf_event;
15160 
15161  uint64_t _begin = Timer_tsc ();
15162 
15165  {
15166 
15167  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15168  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15169  MALP_EVENT_MPI, _container.event.mpi_event.type );
15170  Event_Packer_push(&otf_event);
15171  }
15172 
15173  /********************************/
15174  /* ACTUAL FUNCTION CALL */
15175  /********************************/
15176 
15178  int ret = PMPI_Group_union( group1, group2, newgroup );
15180 
15181  /********************************/
15182  /* EMIT OTF END */
15183  /********************************/
15184 
15185  uint64_t _end = Timer_tsc();
15186  uint64_t _duration = _end - _begin;
15187 
15189  {
15191  {
15192 
15193  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15194  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15195  MALP_EVENT_MPI, _container.event.mpi_event.type );
15196 
15197 
15198  Event_Packer_push(&otf_event);
15199  }
15200 
15201  /********************************/
15202  /* EMIT MALP EVENT */
15203  /********************************/
15204 
15205  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15206 
15207  /* Submit event if MPI instrumented */
15208  Event_Packer_push(&_container);
15209  }
15210 
15211 
15212  return ret;
15213 }
15214 int MPI_Ibsend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
15215 {
15216 
15217  /* Virtualize MPI */
15218  MACRO_MPI_Comm (comm)
15219 
15220  /* Pre instrum */
15221  int _rank = Stream_desc_get()->mpi_rank;
15222 
15223  struct MALP_Trace_Event _container;
15224 
15225  /********************************/
15226  /* FILL MPI EVENT */
15227  /********************************/
15228 
15229  _container.event.mpi_event.type =
15230  T_MPI_ENUM(MPI_IBSEND)
15231  ;
15232 
15233  /* Set default source & dest before override */
15234  _container.event.mpi_event.source = _rank;
15235  _container.event.mpi_event.dest = _rank;
15236 
15237 
15238  SET_DEST (dest)
15239  SET_TAG (tag)
15240  SET_COUNT (count)
15241  SET_DATATYPE (datatype)
15242  SET_COMM (comm)
15243 
15244  /* Fill in size informations if needed */
15245  int _size = 0;
15246  #if 1
15247  COMP_SIZE (count)
15248  #endif
15249  _container.event.mpi_event.size = _size;
15250 
15251  /********************************/
15252  /* EMIT OTF ENTER */
15253  /********************************/
15254 
15255  struct MALP_Trace_Event otf_event;
15256 
15257  uint64_t _begin = Timer_tsc ();
15258 
15261  {
15262 
15263  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15264  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15265  MALP_EVENT_MPI, _container.event.mpi_event.type );
15266  Event_Packer_push(&otf_event);
15267  }
15268 
15269  /********************************/
15270  /* ACTUAL FUNCTION CALL */
15271  /********************************/
15272 
15274  int ret = PMPI_Ibsend( buf, count, datatype, dest, tag, comm, request );
15276 
15277  /********************************/
15278  /* EMIT OTF END */
15279  /********************************/
15280 
15281  uint64_t _end = Timer_tsc();
15282  uint64_t _duration = _end - _begin;
15283 
15285  {
15287  {
15288 
15289  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15290  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15291  MALP_EVENT_MPI, _container.event.mpi_event.type );
15292 
15293 
15294  Event_Packer_push(&otf_event);
15295  }
15296 
15297  /********************************/
15298  /* EMIT MALP EVENT */
15299  /********************************/
15300 
15301  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15302 
15303  /* Submit event if MPI instrumented */
15304  Event_Packer_push(&_container);
15305  }
15306 
15307 
15308  return ret;
15309 }
15310 int MPI_Info_c2f( MPI_Info info )
15311 {
15312 
15313  /* Virtualize MPI */
15314 
15315 
15316  /* Pre instrum */
15317  int _rank = Stream_desc_get()->mpi_rank;
15318 
15319  struct MALP_Trace_Event _container;
15320 
15321  /********************************/
15322  /* FILL MPI EVENT */
15323  /********************************/
15324 
15325  _container.event.mpi_event.type =
15326  T_MPI_ENUM(MPI_INFO_C2F)
15327  ;
15328 
15329  /* Set default source & dest before override */
15330  _container.event.mpi_event.source = _rank;
15331  _container.event.mpi_event.dest = _rank;
15332 
15333 
15334 
15335 
15336 
15337 
15338 
15339 
15340  /* Fill in size informations if needed */
15341  int _size = 0;
15342  #if 0
15343 
15344  #endif
15345  _container.event.mpi_event.size = _size;
15346 
15347  /********************************/
15348  /* EMIT OTF ENTER */
15349  /********************************/
15350 
15351  struct MALP_Trace_Event otf_event;
15352 
15353  uint64_t _begin = Timer_tsc ();
15354 
15357  {
15358 
15359  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15360  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15361  MALP_EVENT_MPI, _container.event.mpi_event.type );
15362  Event_Packer_push(&otf_event);
15363  }
15364 
15365  /********************************/
15366  /* ACTUAL FUNCTION CALL */
15367  /********************************/
15368 
15370  int ret = PMPI_Info_c2f( info );
15372 
15373  /********************************/
15374  /* EMIT OTF END */
15375  /********************************/
15376 
15377  uint64_t _end = Timer_tsc();
15378  uint64_t _duration = _end - _begin;
15379 
15381  {
15383  {
15384 
15385  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15386  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15387  MALP_EVENT_MPI, _container.event.mpi_event.type );
15388 
15389 
15390  Event_Packer_push(&otf_event);
15391  }
15392 
15393  /********************************/
15394  /* EMIT MALP EVENT */
15395  /********************************/
15396 
15397  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15398 
15399  /* Submit event if MPI instrumented */
15400  Event_Packer_push(&_container);
15401  }
15402 
15403 
15404  return ret;
15405 }
15406 int MPI_Info_create( MPI_Info * info )
15407 {
15408 
15409  /* Virtualize MPI */
15410 
15411 
15412  /* Pre instrum */
15413  int _rank = Stream_desc_get()->mpi_rank;
15414 
15415  struct MALP_Trace_Event _container;
15416 
15417  /********************************/
15418  /* FILL MPI EVENT */
15419  /********************************/
15420 
15421  _container.event.mpi_event.type =
15422  T_MPI_ENUM(MPI_INFO_CREATE)
15423  ;
15424 
15425  /* Set default source & dest before override */
15426  _container.event.mpi_event.source = _rank;
15427  _container.event.mpi_event.dest = _rank;
15428 
15429 
15430 
15431 
15432 
15433 
15434 
15435 
15436  /* Fill in size informations if needed */
15437  int _size = 0;
15438  #if 0
15439 
15440  #endif
15441  _container.event.mpi_event.size = _size;
15442 
15443  /********************************/
15444  /* EMIT OTF ENTER */
15445  /********************************/
15446 
15447  struct MALP_Trace_Event otf_event;
15448 
15449  uint64_t _begin = Timer_tsc ();
15450 
15453  {
15454 
15455  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15456  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15457  MALP_EVENT_MPI, _container.event.mpi_event.type );
15458  Event_Packer_push(&otf_event);
15459  }
15460 
15461  /********************************/
15462  /* ACTUAL FUNCTION CALL */
15463  /********************************/
15464 
15466  int ret = PMPI_Info_create( info );
15468 
15469  /********************************/
15470  /* EMIT OTF END */
15471  /********************************/
15472 
15473  uint64_t _end = Timer_tsc();
15474  uint64_t _duration = _end - _begin;
15475 
15477  {
15479  {
15480 
15481  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15482  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15483  MALP_EVENT_MPI, _container.event.mpi_event.type );
15484 
15485 
15486  Event_Packer_push(&otf_event);
15487  }
15488 
15489  /********************************/
15490  /* EMIT MALP EVENT */
15491  /********************************/
15492 
15493  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15494 
15495  /* Submit event if MPI instrumented */
15496  Event_Packer_push(&_container);
15497  }
15498 
15499 
15500  return ret;
15501 }
15502 int MPI_Info_delete( MPI_Info info, char * key )
15503 {
15504 
15505  /* Virtualize MPI */
15506 
15507 
15508  /* Pre instrum */
15509  int _rank = Stream_desc_get()->mpi_rank;
15510 
15511  struct MALP_Trace_Event _container;
15512 
15513  /********************************/
15514  /* FILL MPI EVENT */
15515  /********************************/
15516 
15517  _container.event.mpi_event.type =
15518  T_MPI_ENUM(MPI_INFO_DELETE)
15519  ;
15520 
15521  /* Set default source & dest before override */
15522  _container.event.mpi_event.source = _rank;
15523  _container.event.mpi_event.dest = _rank;
15524 
15525 
15526 
15527 
15528 
15529 
15530 
15531 
15532  /* Fill in size informations if needed */
15533  int _size = 0;
15534  #if 0
15535 
15536  #endif
15537  _container.event.mpi_event.size = _size;
15538 
15539  /********************************/
15540  /* EMIT OTF ENTER */
15541  /********************************/
15542 
15543  struct MALP_Trace_Event otf_event;
15544 
15545  uint64_t _begin = Timer_tsc ();
15546 
15549  {
15550 
15551  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15552  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15553  MALP_EVENT_MPI, _container.event.mpi_event.type );
15554  Event_Packer_push(&otf_event);
15555  }
15556 
15557  /********************************/
15558  /* ACTUAL FUNCTION CALL */
15559  /********************************/
15560 
15562  int ret = PMPI_Info_delete( info, key );
15564 
15565  /********************************/
15566  /* EMIT OTF END */
15567  /********************************/
15568 
15569  uint64_t _end = Timer_tsc();
15570  uint64_t _duration = _end - _begin;
15571 
15573  {
15575  {
15576 
15577  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15578  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15579  MALP_EVENT_MPI, _container.event.mpi_event.type );
15580 
15581 
15582  Event_Packer_push(&otf_event);
15583  }
15584 
15585  /********************************/
15586  /* EMIT MALP EVENT */
15587  /********************************/
15588 
15589  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15590 
15591  /* Submit event if MPI instrumented */
15592  Event_Packer_push(&_container);
15593  }
15594 
15595 
15596  return ret;
15597 }
15598 int MPI_Info_dup( MPI_Info info, MPI_Info * newinfo )
15599 {
15600 
15601  /* Virtualize MPI */
15602 
15603 
15604  /* Pre instrum */
15605  int _rank = Stream_desc_get()->mpi_rank;
15606 
15607  struct MALP_Trace_Event _container;
15608 
15609  /********************************/
15610  /* FILL MPI EVENT */
15611  /********************************/
15612 
15613  _container.event.mpi_event.type =
15614  T_MPI_ENUM(MPI_INFO_DUP)
15615  ;
15616 
15617  /* Set default source & dest before override */
15618  _container.event.mpi_event.source = _rank;
15619  _container.event.mpi_event.dest = _rank;
15620 
15621 
15622 
15623 
15624 
15625 
15626 
15627 
15628  /* Fill in size informations if needed */
15629  int _size = 0;
15630  #if 0
15631 
15632  #endif
15633  _container.event.mpi_event.size = _size;
15634 
15635  /********************************/
15636  /* EMIT OTF ENTER */
15637  /********************************/
15638 
15639  struct MALP_Trace_Event otf_event;
15640 
15641  uint64_t _begin = Timer_tsc ();
15642 
15645  {
15646 
15647  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15648  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15649  MALP_EVENT_MPI, _container.event.mpi_event.type );
15650  Event_Packer_push(&otf_event);
15651  }
15652 
15653  /********************************/
15654  /* ACTUAL FUNCTION CALL */
15655  /********************************/
15656 
15658  int ret = PMPI_Info_dup( info, newinfo );
15660 
15661  /********************************/
15662  /* EMIT OTF END */
15663  /********************************/
15664 
15665  uint64_t _end = Timer_tsc();
15666  uint64_t _duration = _end - _begin;
15667 
15669  {
15671  {
15672 
15673  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15674  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15675  MALP_EVENT_MPI, _container.event.mpi_event.type );
15676 
15677 
15678  Event_Packer_push(&otf_event);
15679  }
15680 
15681  /********************************/
15682  /* EMIT MALP EVENT */
15683  /********************************/
15684 
15685  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15686 
15687  /* Submit event if MPI instrumented */
15688  Event_Packer_push(&_container);
15689  }
15690 
15691 
15692  return ret;
15693 }
15694 int MPI_Info_free( MPI_Info * info )
15695 {
15696 
15697  /* Virtualize MPI */
15698 
15699 
15700  /* Pre instrum */
15701  int _rank = Stream_desc_get()->mpi_rank;
15702 
15703  struct MALP_Trace_Event _container;
15704 
15705  /********************************/
15706  /* FILL MPI EVENT */
15707  /********************************/
15708 
15709  _container.event.mpi_event.type =
15710  T_MPI_ENUM(MPI_INFO_FREE)
15711  ;
15712 
15713  /* Set default source & dest before override */
15714  _container.event.mpi_event.source = _rank;
15715  _container.event.mpi_event.dest = _rank;
15716 
15717 
15718 
15719 
15720 
15721 
15722 
15723 
15724  /* Fill in size informations if needed */
15725  int _size = 0;
15726  #if 0
15727 
15728  #endif
15729  _container.event.mpi_event.size = _size;
15730 
15731  /********************************/
15732  /* EMIT OTF ENTER */
15733  /********************************/
15734 
15735  struct MALP_Trace_Event otf_event;
15736 
15737  uint64_t _begin = Timer_tsc ();
15738 
15741  {
15742 
15743  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15744  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15745  MALP_EVENT_MPI, _container.event.mpi_event.type );
15746  Event_Packer_push(&otf_event);
15747  }
15748 
15749  /********************************/
15750  /* ACTUAL FUNCTION CALL */
15751  /********************************/
15752 
15754  int ret = PMPI_Info_free( info );
15756 
15757  /********************************/
15758  /* EMIT OTF END */
15759  /********************************/
15760 
15761  uint64_t _end = Timer_tsc();
15762  uint64_t _duration = _end - _begin;
15763 
15765  {
15767  {
15768 
15769  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15770  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15771  MALP_EVENT_MPI, _container.event.mpi_event.type );
15772 
15773 
15774  Event_Packer_push(&otf_event);
15775  }
15776 
15777  /********************************/
15778  /* EMIT MALP EVENT */
15779  /********************************/
15780 
15781  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15782 
15783  /* Submit event if MPI instrumented */
15784  Event_Packer_push(&_container);
15785  }
15786 
15787 
15788  return ret;
15789 }
15790 int MPI_Info_get( MPI_Info info, char * key, int valuelen, char * value, int * flag )
15791 {
15792 
15793  /* Virtualize MPI */
15794 
15795 
15796  /* Pre instrum */
15797  int _rank = Stream_desc_get()->mpi_rank;
15798 
15799  struct MALP_Trace_Event _container;
15800 
15801  /********************************/
15802  /* FILL MPI EVENT */
15803  /********************************/
15804 
15805  _container.event.mpi_event.type =
15806  T_MPI_ENUM(MPI_INFO_GET)
15807  ;
15808 
15809  /* Set default source & dest before override */
15810  _container.event.mpi_event.source = _rank;
15811  _container.event.mpi_event.dest = _rank;
15812 
15813 
15814 
15815 
15816 
15817 
15818 
15819 
15820  /* Fill in size informations if needed */
15821  int _size = 0;
15822  #if 0
15823 
15824  #endif
15825  _container.event.mpi_event.size = _size;
15826 
15827  /********************************/
15828  /* EMIT OTF ENTER */
15829  /********************************/
15830 
15831  struct MALP_Trace_Event otf_event;
15832 
15833  uint64_t _begin = Timer_tsc ();
15834 
15837  {
15838 
15839  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15840  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15841  MALP_EVENT_MPI, _container.event.mpi_event.type );
15842  Event_Packer_push(&otf_event);
15843  }
15844 
15845  /********************************/
15846  /* ACTUAL FUNCTION CALL */
15847  /********************************/
15848 
15850  int ret = PMPI_Info_get( info, key, valuelen, value, flag );
15852 
15853  /********************************/
15854  /* EMIT OTF END */
15855  /********************************/
15856 
15857  uint64_t _end = Timer_tsc();
15858  uint64_t _duration = _end - _begin;
15859 
15861  {
15863  {
15864 
15865  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15866  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15867  MALP_EVENT_MPI, _container.event.mpi_event.type );
15868 
15869 
15870  Event_Packer_push(&otf_event);
15871  }
15872 
15873  /********************************/
15874  /* EMIT MALP EVENT */
15875  /********************************/
15876 
15877  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15878 
15879  /* Submit event if MPI instrumented */
15880  Event_Packer_push(&_container);
15881  }
15882 
15883 
15884  return ret;
15885 }
15886 int MPI_Info_get_nkeys( MPI_Info info, int * nkeys )
15887 {
15888 
15889  /* Virtualize MPI */
15890 
15891 
15892  /* Pre instrum */
15893  int _rank = Stream_desc_get()->mpi_rank;
15894 
15895  struct MALP_Trace_Event _container;
15896 
15897  /********************************/
15898  /* FILL MPI EVENT */
15899  /********************************/
15900 
15901  _container.event.mpi_event.type =
15902  T_MPI_ENUM(MPI_INFO_GET_NKEYS)
15903  ;
15904 
15905  /* Set default source & dest before override */
15906  _container.event.mpi_event.source = _rank;
15907  _container.event.mpi_event.dest = _rank;
15908 
15909 
15910 
15911 
15912 
15913 
15914 
15915 
15916  /* Fill in size informations if needed */
15917  int _size = 0;
15918  #if 0
15919 
15920  #endif
15921  _container.event.mpi_event.size = _size;
15922 
15923  /********************************/
15924  /* EMIT OTF ENTER */
15925  /********************************/
15926 
15927  struct MALP_Trace_Event otf_event;
15928 
15929  uint64_t _begin = Timer_tsc ();
15930 
15933  {
15934 
15935  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
15936  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
15937  MALP_EVENT_MPI, _container.event.mpi_event.type );
15938  Event_Packer_push(&otf_event);
15939  }
15940 
15941  /********************************/
15942  /* ACTUAL FUNCTION CALL */
15943  /********************************/
15944 
15946  int ret = PMPI_Info_get_nkeys( info, nkeys );
15948 
15949  /********************************/
15950  /* EMIT OTF END */
15951  /********************************/
15952 
15953  uint64_t _end = Timer_tsc();
15954  uint64_t _duration = _end - _begin;
15955 
15957  {
15959  {
15960 
15961  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
15962  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
15963  MALP_EVENT_MPI, _container.event.mpi_event.type );
15964 
15965 
15966  Event_Packer_push(&otf_event);
15967  }
15968 
15969  /********************************/
15970  /* EMIT MALP EVENT */
15971  /********************************/
15972 
15973  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
15974 
15975  /* Submit event if MPI instrumented */
15976  Event_Packer_push(&_container);
15977  }
15978 
15979 
15980  return ret;
15981 }
15982 int MPI_Info_get_nthkey( MPI_Info info, int n, char * key )
15983 {
15984 
15985  /* Virtualize MPI */
15986 
15987 
15988  /* Pre instrum */
15989  int _rank = Stream_desc_get()->mpi_rank;
15990 
15991  struct MALP_Trace_Event _container;
15992 
15993  /********************************/
15994  /* FILL MPI EVENT */
15995  /********************************/
15996 
15997  _container.event.mpi_event.type =
15998  T_MPI_ENUM(MPI_INFO_GET_NTHKEY)
15999  ;
16000 
16001  /* Set default source & dest before override */
16002  _container.event.mpi_event.source = _rank;
16003  _container.event.mpi_event.dest = _rank;
16004 
16005 
16006 
16007 
16008 
16009 
16010 
16011 
16012  /* Fill in size informations if needed */
16013  int _size = 0;
16014  #if 0
16015 
16016  #endif
16017  _container.event.mpi_event.size = _size;
16018 
16019  /********************************/
16020  /* EMIT OTF ENTER */
16021  /********************************/
16022 
16023  struct MALP_Trace_Event otf_event;
16024 
16025  uint64_t _begin = Timer_tsc ();
16026 
16029  {
16030 
16031  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16032  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16033  MALP_EVENT_MPI, _container.event.mpi_event.type );
16034  Event_Packer_push(&otf_event);
16035  }
16036 
16037  /********************************/
16038  /* ACTUAL FUNCTION CALL */
16039  /********************************/
16040 
16042  int ret = PMPI_Info_get_nthkey( info, n, key );
16044 
16045  /********************************/
16046  /* EMIT OTF END */
16047  /********************************/
16048 
16049  uint64_t _end = Timer_tsc();
16050  uint64_t _duration = _end - _begin;
16051 
16053  {
16055  {
16056 
16057  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16058  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16059  MALP_EVENT_MPI, _container.event.mpi_event.type );
16060 
16061 
16062  Event_Packer_push(&otf_event);
16063  }
16064 
16065  /********************************/
16066  /* EMIT MALP EVENT */
16067  /********************************/
16068 
16069  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16070 
16071  /* Submit event if MPI instrumented */
16072  Event_Packer_push(&_container);
16073  }
16074 
16075 
16076  return ret;
16077 }
16078 int MPI_Info_get_valuelen( MPI_Info info, char * key, int * valuelen, int * flag )
16079 {
16080 
16081  /* Virtualize MPI */
16082 
16083 
16084  /* Pre instrum */
16085  int _rank = Stream_desc_get()->mpi_rank;
16086 
16087  struct MALP_Trace_Event _container;
16088 
16089  /********************************/
16090  /* FILL MPI EVENT */
16091  /********************************/
16092 
16093  _container.event.mpi_event.type =
16094  T_MPI_ENUM(MPI_INFO_GET_VALUELEN)
16095  ;
16096 
16097  /* Set default source & dest before override */
16098  _container.event.mpi_event.source = _rank;
16099  _container.event.mpi_event.dest = _rank;
16100 
16101 
16102 
16103 
16104 
16105 
16106 
16107 
16108  /* Fill in size informations if needed */
16109  int _size = 0;
16110  #if 0
16111 
16112  #endif
16113  _container.event.mpi_event.size = _size;
16114 
16115  /********************************/
16116  /* EMIT OTF ENTER */
16117  /********************************/
16118 
16119  struct MALP_Trace_Event otf_event;
16120 
16121  uint64_t _begin = Timer_tsc ();
16122 
16125  {
16126 
16127  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16128  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16129  MALP_EVENT_MPI, _container.event.mpi_event.type );
16130  Event_Packer_push(&otf_event);
16131  }
16132 
16133  /********************************/
16134  /* ACTUAL FUNCTION CALL */
16135  /********************************/
16136 
16138  int ret = PMPI_Info_get_valuelen( info, key, valuelen, flag );
16140 
16141  /********************************/
16142  /* EMIT OTF END */
16143  /********************************/
16144 
16145  uint64_t _end = Timer_tsc();
16146  uint64_t _duration = _end - _begin;
16147 
16149  {
16151  {
16152 
16153  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16154  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16155  MALP_EVENT_MPI, _container.event.mpi_event.type );
16156 
16157 
16158  Event_Packer_push(&otf_event);
16159  }
16160 
16161  /********************************/
16162  /* EMIT MALP EVENT */
16163  /********************************/
16164 
16165  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16166 
16167  /* Submit event if MPI instrumented */
16168  Event_Packer_push(&_container);
16169  }
16170 
16171 
16172  return ret;
16173 }
16174 int MPI_Info_set( MPI_Info info, char * key, char * value )
16175 {
16176 
16177  /* Virtualize MPI */
16178 
16179 
16180  /* Pre instrum */
16181  int _rank = Stream_desc_get()->mpi_rank;
16182 
16183  struct MALP_Trace_Event _container;
16184 
16185  /********************************/
16186  /* FILL MPI EVENT */
16187  /********************************/
16188 
16189  _container.event.mpi_event.type =
16190  T_MPI_ENUM(MPI_INFO_SET)
16191  ;
16192 
16193  /* Set default source & dest before override */
16194  _container.event.mpi_event.source = _rank;
16195  _container.event.mpi_event.dest = _rank;
16196 
16197 
16198 
16199 
16200 
16201 
16202 
16203 
16204  /* Fill in size informations if needed */
16205  int _size = 0;
16206  #if 0
16207 
16208  #endif
16209  _container.event.mpi_event.size = _size;
16210 
16211  /********************************/
16212  /* EMIT OTF ENTER */
16213  /********************************/
16214 
16215  struct MALP_Trace_Event otf_event;
16216 
16217  uint64_t _begin = Timer_tsc ();
16218 
16221  {
16222 
16223  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16224  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16225  MALP_EVENT_MPI, _container.event.mpi_event.type );
16226  Event_Packer_push(&otf_event);
16227  }
16228 
16229  /********************************/
16230  /* ACTUAL FUNCTION CALL */
16231  /********************************/
16232 
16234  int ret = PMPI_Info_set( info, key, value );
16236 
16237  /********************************/
16238  /* EMIT OTF END */
16239  /********************************/
16240 
16241  uint64_t _end = Timer_tsc();
16242  uint64_t _duration = _end - _begin;
16243 
16245  {
16247  {
16248 
16249  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16250  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16251  MALP_EVENT_MPI, _container.event.mpi_event.type );
16252 
16253 
16254  Event_Packer_push(&otf_event);
16255  }
16256 
16257  /********************************/
16258  /* EMIT MALP EVENT */
16259  /********************************/
16260 
16261  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16262 
16263  /* Submit event if MPI instrumented */
16264  Event_Packer_push(&_container);
16265  }
16266 
16267 
16268  return ret;
16269 }
16270 int MPI_Intercomm_create( MPI_Comm local_comm, int local_leader, MPI_Comm bridge_comm, int remote_leader, int tag, MPI_Comm * newintercomm )
16271 {
16272 
16273  /* Virtualize MPI */
16274  MACRO_MPI_Comm (local_comm) MACRO_MPI_Comm (bridge_comm)
16275 
16276  /* Pre instrum */
16277  int _rank = Stream_desc_get()->mpi_rank;
16278 
16279  struct MALP_Trace_Event _container;
16280 
16281  /********************************/
16282  /* FILL MPI EVENT */
16283  /********************************/
16284 
16285  _container.event.mpi_event.type =
16286  T_MPI_ENUM(MPI_INTERCOMM_CREATE)
16287  ;
16288 
16289  /* Set default source & dest before override */
16290  _container.event.mpi_event.source = _rank;
16291  _container.event.mpi_event.dest = _rank;
16292 
16293 
16294 
16295  SET_TAG (tag)
16296 
16297 
16298 
16299 
16300  /* Fill in size informations if needed */
16301  int _size = 0;
16302  #if 0
16303 
16304  #endif
16305  _container.event.mpi_event.size = _size;
16306 
16307  /********************************/
16308  /* EMIT OTF ENTER */
16309  /********************************/
16310 
16311  struct MALP_Trace_Event otf_event;
16312 
16313  uint64_t _begin = Timer_tsc ();
16314 
16317  {
16318 
16319  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16320  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16321  MALP_EVENT_MPI, _container.event.mpi_event.type );
16322  Event_Packer_push(&otf_event);
16323  }
16324 
16325  /********************************/
16326  /* ACTUAL FUNCTION CALL */
16327  /********************************/
16328 
16330  int ret = PMPI_Intercomm_create( local_comm, local_leader, bridge_comm, remote_leader, tag, newintercomm );
16332 
16333  /********************************/
16334  /* EMIT OTF END */
16335  /********************************/
16336 
16337  uint64_t _end = Timer_tsc();
16338  uint64_t _duration = _end - _begin;
16339 
16341  {
16343  {
16344 
16345  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16346  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16347  MALP_EVENT_MPI, _container.event.mpi_event.type );
16348 
16349 
16350  Event_Packer_push(&otf_event);
16351  }
16352 
16353  /********************************/
16354  /* EMIT MALP EVENT */
16355  /********************************/
16356 
16357  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16358 
16359  /* Submit event if MPI instrumented */
16360  Event_Packer_push(&_container);
16361  }
16362 
16363 
16364  return ret;
16365 }
16366 int MPI_Intercomm_merge( MPI_Comm intercomm, int high, MPI_Comm * newintercomm )
16367 {
16368 
16369  /* Virtualize MPI */
16370  MACRO_MPI_Comm (intercomm)
16371 
16372  /* Pre instrum */
16373  int _rank = Stream_desc_get()->mpi_rank;
16374 
16375  struct MALP_Trace_Event _container;
16376 
16377  /********************************/
16378  /* FILL MPI EVENT */
16379  /********************************/
16380 
16381  _container.event.mpi_event.type =
16382  T_MPI_ENUM(MPI_INTERCOMM_MERGE)
16383  ;
16384 
16385  /* Set default source & dest before override */
16386  _container.event.mpi_event.source = _rank;
16387  _container.event.mpi_event.dest = _rank;
16388 
16389 
16390 
16391 
16392 
16393 
16394 
16395 
16396  /* Fill in size informations if needed */
16397  int _size = 0;
16398  #if 0
16399 
16400  #endif
16401  _container.event.mpi_event.size = _size;
16402 
16403  /********************************/
16404  /* EMIT OTF ENTER */
16405  /********************************/
16406 
16407  struct MALP_Trace_Event otf_event;
16408 
16409  uint64_t _begin = Timer_tsc ();
16410 
16413  {
16414 
16415  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16416  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16417  MALP_EVENT_MPI, _container.event.mpi_event.type );
16418  Event_Packer_push(&otf_event);
16419  }
16420 
16421  /********************************/
16422  /* ACTUAL FUNCTION CALL */
16423  /********************************/
16424 
16426  int ret = PMPI_Intercomm_merge( intercomm, high, newintercomm );
16428 
16429  /********************************/
16430  /* EMIT OTF END */
16431  /********************************/
16432 
16433  uint64_t _end = Timer_tsc();
16434  uint64_t _duration = _end - _begin;
16435 
16437  {
16439  {
16440 
16441  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16442  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16443  MALP_EVENT_MPI, _container.event.mpi_event.type );
16444 
16445 
16446  Event_Packer_push(&otf_event);
16447  }
16448 
16449  /********************************/
16450  /* EMIT MALP EVENT */
16451  /********************************/
16452 
16453  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16454 
16455  /* Submit event if MPI instrumented */
16456  Event_Packer_push(&_container);
16457  }
16458 
16459 
16460  return ret;
16461 }
16462 int MPI_Iprobe( int source, int tag, MPI_Comm comm, int * flag, MPI_Status * status )
16463 {
16464 
16465  /* Virtualize MPI */
16466  MACRO_MPI_Comm (comm)
16467 
16468  /* Pre instrum */
16469  int _rank = Stream_desc_get()->mpi_rank;
16470 
16471  struct MALP_Trace_Event _container;
16472 
16473  /********************************/
16474  /* FILL MPI EVENT */
16475  /********************************/
16476 
16477  _container.event.mpi_event.type =
16478  T_MPI_ENUM(MPI_IPROBE)
16479  ;
16480 
16481  /* Set default source & dest before override */
16482  _container.event.mpi_event.source = _rank;
16483  _container.event.mpi_event.dest = _rank;
16484 
16485  SET_SOURCE (source)
16486 
16487  SET_TAG (tag)
16488 
16489 
16490  SET_COMM (comm)
16491 
16492  /* Fill in size informations if needed */
16493  int _size = 0;
16494  #if 0
16495 
16496  #endif
16497  _container.event.mpi_event.size = _size;
16498 
16499  /********************************/
16500  /* EMIT OTF ENTER */
16501  /********************************/
16502 
16503  struct MALP_Trace_Event otf_event;
16504 
16505  uint64_t _begin = Timer_tsc ();
16506 
16509  {
16510 
16511  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16512  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16513  MALP_EVENT_MPI, _container.event.mpi_event.type );
16514  Event_Packer_push(&otf_event);
16515  }
16516 
16517  /********************************/
16518  /* ACTUAL FUNCTION CALL */
16519  /********************************/
16520 
16522  int ret = PMPI_Iprobe( source, tag, comm, flag, status );
16524 
16525  /********************************/
16526  /* EMIT OTF END */
16527  /********************************/
16528 
16529  uint64_t _end = Timer_tsc();
16530  uint64_t _duration = _end - _begin;
16531 
16533  {
16535  {
16536 
16537  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16538  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16539  MALP_EVENT_MPI, _container.event.mpi_event.type );
16540 
16541 
16542  Event_Packer_push(&otf_event);
16543  }
16544 
16545  /********************************/
16546  /* EMIT MALP EVENT */
16547  /********************************/
16548 
16549  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16550 
16551  /* Submit event if MPI instrumented */
16552  Event_Packer_push(&_container);
16553  }
16554 
16555 
16556  return ret;
16557 }
16558 int MPI_Irecv( void * buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request * request )
16559 {
16560 
16561  /* Virtualize MPI */
16562  MACRO_MPI_Comm (comm)
16563 
16564  /* Pre instrum */
16565  int _rank = Stream_desc_get()->mpi_rank;
16566 
16567  struct MALP_Trace_Event _container;
16568 
16569  /********************************/
16570  /* FILL MPI EVENT */
16571  /********************************/
16572 
16573  _container.event.mpi_event.type =
16574  T_MPI_ENUM(MPI_IRECV)
16575  ;
16576 
16577  /* Set default source & dest before override */
16578  _container.event.mpi_event.source = _rank;
16579  _container.event.mpi_event.dest = _rank;
16580 
16581  SET_SOURCE (source)
16582 
16583  SET_TAG (tag)
16584  SET_COUNT (count)
16585  SET_DATATYPE (datatype)
16586  SET_COMM (comm)
16587 
16588  /* Fill in size informations if needed */
16589  int _size = 0;
16590  #if 1
16591  COMP_SIZE (count)
16592  #endif
16593  _container.event.mpi_event.size = _size;
16594 
16595  /********************************/
16596  /* EMIT OTF ENTER */
16597  /********************************/
16598 
16599  struct MALP_Trace_Event otf_event;
16600 
16601  uint64_t _begin = Timer_tsc ();
16602 
16605  {
16606 
16607  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16608  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16609  MALP_EVENT_MPI, _container.event.mpi_event.type );
16610  Event_Packer_push(&otf_event);
16611  }
16612 
16613  /********************************/
16614  /* ACTUAL FUNCTION CALL */
16615  /********************************/
16616 
16618  int ret = PMPI_Irecv( buf, count, datatype, source, tag, comm, request );
16620 
16621  /********************************/
16622  /* EMIT OTF END */
16623  /********************************/
16624 
16625  uint64_t _end = Timer_tsc();
16626  uint64_t _duration = _end - _begin;
16627 
16629  {
16631  {
16632 
16633  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16634  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16635  MALP_EVENT_MPI, _container.event.mpi_event.type );
16636 
16637 
16638  Event_Packer_push(&otf_event);
16639  }
16640 
16641  /********************************/
16642  /* EMIT MALP EVENT */
16643  /********************************/
16644 
16645  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16646 
16647  /* Submit event if MPI instrumented */
16648  Event_Packer_push(&_container);
16649  }
16650 
16651 
16652  return ret;
16653 }
16654 int MPI_Irsend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
16655 {
16656 
16657  /* Virtualize MPI */
16658  MACRO_MPI_Comm (comm)
16659 
16660  /* Pre instrum */
16661  int _rank = Stream_desc_get()->mpi_rank;
16662 
16663  struct MALP_Trace_Event _container;
16664 
16665  /********************************/
16666  /* FILL MPI EVENT */
16667  /********************************/
16668 
16669  _container.event.mpi_event.type =
16670  T_MPI_ENUM(MPI_IRSEND)
16671  ;
16672 
16673  /* Set default source & dest before override */
16674  _container.event.mpi_event.source = _rank;
16675  _container.event.mpi_event.dest = _rank;
16676 
16677 
16678  SET_DEST (dest)
16679  SET_TAG (tag)
16680  SET_COUNT (count)
16681  SET_DATATYPE (datatype)
16682  SET_COMM (comm)
16683 
16684  /* Fill in size informations if needed */
16685  int _size = 0;
16686  #if 1
16687  COMP_SIZE (count)
16688  #endif
16689  _container.event.mpi_event.size = _size;
16690 
16691  /********************************/
16692  /* EMIT OTF ENTER */
16693  /********************************/
16694 
16695  struct MALP_Trace_Event otf_event;
16696 
16697  uint64_t _begin = Timer_tsc ();
16698 
16701  {
16702 
16703  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16704  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16705  MALP_EVENT_MPI, _container.event.mpi_event.type );
16706  Event_Packer_push(&otf_event);
16707  }
16708 
16709  /********************************/
16710  /* ACTUAL FUNCTION CALL */
16711  /********************************/
16712 
16714  int ret = PMPI_Irsend( buf, count, datatype, dest, tag, comm, request );
16716 
16717  /********************************/
16718  /* EMIT OTF END */
16719  /********************************/
16720 
16721  uint64_t _end = Timer_tsc();
16722  uint64_t _duration = _end - _begin;
16723 
16725  {
16727  {
16728 
16729  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16730  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16731  MALP_EVENT_MPI, _container.event.mpi_event.type );
16732 
16733 
16734  Event_Packer_push(&otf_event);
16735  }
16736 
16737  /********************************/
16738  /* EMIT MALP EVENT */
16739  /********************************/
16740 
16741  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16742 
16743  /* Submit event if MPI instrumented */
16744  Event_Packer_push(&_container);
16745  }
16746 
16747 
16748  return ret;
16749 }
16750 int MPI_Isend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
16751 {
16752 
16753  /* Virtualize MPI */
16754  MACRO_MPI_Comm (comm)
16755 
16756  /* Pre instrum */
16757  int _rank = Stream_desc_get()->mpi_rank;
16758 
16759  struct MALP_Trace_Event _container;
16760 
16761  /********************************/
16762  /* FILL MPI EVENT */
16763  /********************************/
16764 
16765  _container.event.mpi_event.type =
16766  T_MPI_ENUM(MPI_ISEND)
16767  ;
16768 
16769  /* Set default source & dest before override */
16770  _container.event.mpi_event.source = _rank;
16771  _container.event.mpi_event.dest = _rank;
16772 
16773 
16774  SET_DEST (dest)
16775  SET_TAG (tag)
16776  SET_COUNT (count)
16777  SET_DATATYPE (datatype)
16778  SET_COMM (comm)
16779 
16780  /* Fill in size informations if needed */
16781  int _size = 0;
16782  #if 1
16783  COMP_SIZE (count)
16784  #endif
16785  _container.event.mpi_event.size = _size;
16786 
16787  /********************************/
16788  /* EMIT OTF ENTER */
16789  /********************************/
16790 
16791  struct MALP_Trace_Event otf_event;
16792 
16793  uint64_t _begin = Timer_tsc ();
16794 
16797  {
16798 
16799  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16800  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16801  MALP_EVENT_MPI, _container.event.mpi_event.type );
16802  Event_Packer_push(&otf_event);
16803  }
16804 
16805  /********************************/
16806  /* ACTUAL FUNCTION CALL */
16807  /********************************/
16808 
16810  int ret = PMPI_Isend( buf, count, datatype, dest, tag, comm, request );
16812 
16813  /********************************/
16814  /* EMIT OTF END */
16815  /********************************/
16816 
16817  uint64_t _end = Timer_tsc();
16818  uint64_t _duration = _end - _begin;
16819 
16821  {
16823  {
16824 
16825  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16826  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16827  MALP_EVENT_MPI, _container.event.mpi_event.type );
16828 
16829 
16830  Event_Packer_push(&otf_event);
16831  }
16832 
16833  /********************************/
16834  /* EMIT MALP EVENT */
16835  /********************************/
16836 
16837  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16838 
16839  /* Submit event if MPI instrumented */
16840  Event_Packer_push(&_container);
16841  }
16842 
16843 
16844  return ret;
16845 }
16846 int MPI_Issend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
16847 {
16848 
16849  /* Virtualize MPI */
16850  MACRO_MPI_Comm (comm)
16851 
16852  /* Pre instrum */
16853  int _rank = Stream_desc_get()->mpi_rank;
16854 
16855  struct MALP_Trace_Event _container;
16856 
16857  /********************************/
16858  /* FILL MPI EVENT */
16859  /********************************/
16860 
16861  _container.event.mpi_event.type =
16862  T_MPI_ENUM(MPI_ISSEND)
16863  ;
16864 
16865  /* Set default source & dest before override */
16866  _container.event.mpi_event.source = _rank;
16867  _container.event.mpi_event.dest = _rank;
16868 
16869 
16870  SET_DEST (dest)
16871  SET_TAG (tag)
16872  SET_COUNT (count)
16873  SET_DATATYPE (datatype)
16874  SET_COMM (comm)
16875 
16876  /* Fill in size informations if needed */
16877  int _size = 0;
16878  #if 1
16879  COMP_SIZE (count)
16880  #endif
16881  _container.event.mpi_event.size = _size;
16882 
16883  /********************************/
16884  /* EMIT OTF ENTER */
16885  /********************************/
16886 
16887  struct MALP_Trace_Event otf_event;
16888 
16889  uint64_t _begin = Timer_tsc ();
16890 
16893  {
16894 
16895  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16896  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16897  MALP_EVENT_MPI, _container.event.mpi_event.type );
16898  Event_Packer_push(&otf_event);
16899  }
16900 
16901  /********************************/
16902  /* ACTUAL FUNCTION CALL */
16903  /********************************/
16904 
16906  int ret = PMPI_Issend( buf, count, datatype, dest, tag, comm, request );
16908 
16909  /********************************/
16910  /* EMIT OTF END */
16911  /********************************/
16912 
16913  uint64_t _end = Timer_tsc();
16914  uint64_t _duration = _end - _begin;
16915 
16917  {
16919  {
16920 
16921  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
16922  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
16923  MALP_EVENT_MPI, _container.event.mpi_event.type );
16924 
16925 
16926  Event_Packer_push(&otf_event);
16927  }
16928 
16929  /********************************/
16930  /* EMIT MALP EVENT */
16931  /********************************/
16932 
16933  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
16934 
16935  /* Submit event if MPI instrumented */
16936  Event_Packer_push(&_container);
16937  }
16938 
16939 
16940  return ret;
16941 }
16942 int MPI_Is_thread_main( int * flag )
16943 {
16944 
16945  /* Virtualize MPI */
16946 
16947 
16948  /* Pre instrum */
16949  int _rank = Stream_desc_get()->mpi_rank;
16950 
16951  struct MALP_Trace_Event _container;
16952 
16953  /********************************/
16954  /* FILL MPI EVENT */
16955  /********************************/
16956 
16957  _container.event.mpi_event.type =
16958  T_MPI_ENUM(MPI_IS_THREAD_MAIN)
16959  ;
16960 
16961  /* Set default source & dest before override */
16962  _container.event.mpi_event.source = _rank;
16963  _container.event.mpi_event.dest = _rank;
16964 
16965 
16966 
16967 
16968 
16969 
16970 
16971 
16972  /* Fill in size informations if needed */
16973  int _size = 0;
16974  #if 0
16975 
16976  #endif
16977  _container.event.mpi_event.size = _size;
16978 
16979  /********************************/
16980  /* EMIT OTF ENTER */
16981  /********************************/
16982 
16983  struct MALP_Trace_Event otf_event;
16984 
16985  uint64_t _begin = Timer_tsc ();
16986 
16989  {
16990 
16991  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
16992  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
16993  MALP_EVENT_MPI, _container.event.mpi_event.type );
16994  Event_Packer_push(&otf_event);
16995  }
16996 
16997  /********************************/
16998  /* ACTUAL FUNCTION CALL */
16999  /********************************/
17000 
17002  int ret = PMPI_Is_thread_main( flag );
17004 
17005  /********************************/
17006  /* EMIT OTF END */
17007  /********************************/
17008 
17009  uint64_t _end = Timer_tsc();
17010  uint64_t _duration = _end - _begin;
17011 
17013  {
17015  {
17016 
17017  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17018  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17019  MALP_EVENT_MPI, _container.event.mpi_event.type );
17020 
17021 
17022  Event_Packer_push(&otf_event);
17023  }
17024 
17025  /********************************/
17026  /* EMIT MALP EVENT */
17027  /********************************/
17028 
17029  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17030 
17031  /* Submit event if MPI instrumented */
17032  Event_Packer_push(&_container);
17033  }
17034 
17035 
17036  return ret;
17037 }
17038 int MPI_Keyval_create( MPI_Copy_function * copy_fn, MPI_Delete_function * delete_fn, int * keyval, void * extra_state )
17039 {
17040 
17041  /* Virtualize MPI */
17042 
17043 
17044  /* Pre instrum */
17045  int _rank = Stream_desc_get()->mpi_rank;
17046 
17047  struct MALP_Trace_Event _container;
17048 
17049  /********************************/
17050  /* FILL MPI EVENT */
17051  /********************************/
17052 
17053  _container.event.mpi_event.type =
17054  T_MPI_ENUM(MPI_KEYVAL_CREATE)
17055  ;
17056 
17057  /* Set default source & dest before override */
17058  _container.event.mpi_event.source = _rank;
17059  _container.event.mpi_event.dest = _rank;
17060 
17061 
17062 
17063 
17064 
17065 
17066 
17067 
17068  /* Fill in size informations if needed */
17069  int _size = 0;
17070  #if 0
17071 
17072  #endif
17073  _container.event.mpi_event.size = _size;
17074 
17075  /********************************/
17076  /* EMIT OTF ENTER */
17077  /********************************/
17078 
17079  struct MALP_Trace_Event otf_event;
17080 
17081  uint64_t _begin = Timer_tsc ();
17082 
17085  {
17086 
17087  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17088  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17089  MALP_EVENT_MPI, _container.event.mpi_event.type );
17090  Event_Packer_push(&otf_event);
17091  }
17092 
17093  /********************************/
17094  /* ACTUAL FUNCTION CALL */
17095  /********************************/
17096 
17098  int ret = PMPI_Keyval_create( copy_fn, delete_fn, keyval, extra_state );
17100 
17101  /********************************/
17102  /* EMIT OTF END */
17103  /********************************/
17104 
17105  uint64_t _end = Timer_tsc();
17106  uint64_t _duration = _end - _begin;
17107 
17109  {
17111  {
17112 
17113  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17114  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17115  MALP_EVENT_MPI, _container.event.mpi_event.type );
17116 
17117 
17118  Event_Packer_push(&otf_event);
17119  }
17120 
17121  /********************************/
17122  /* EMIT MALP EVENT */
17123  /********************************/
17124 
17125  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17126 
17127  /* Submit event if MPI instrumented */
17128  Event_Packer_push(&_container);
17129  }
17130 
17131 
17132  return ret;
17133 }
17134 int MPI_Keyval_free( int * keyval )
17135 {
17136 
17137  /* Virtualize MPI */
17138 
17139 
17140  /* Pre instrum */
17141  int _rank = Stream_desc_get()->mpi_rank;
17142 
17143  struct MALP_Trace_Event _container;
17144 
17145  /********************************/
17146  /* FILL MPI EVENT */
17147  /********************************/
17148 
17149  _container.event.mpi_event.type =
17150  T_MPI_ENUM(MPI_KEYVAL_FREE)
17151  ;
17152 
17153  /* Set default source & dest before override */
17154  _container.event.mpi_event.source = _rank;
17155  _container.event.mpi_event.dest = _rank;
17156 
17157 
17158 
17159 
17160 
17161 
17162 
17163 
17164  /* Fill in size informations if needed */
17165  int _size = 0;
17166  #if 0
17167 
17168  #endif
17169  _container.event.mpi_event.size = _size;
17170 
17171  /********************************/
17172  /* EMIT OTF ENTER */
17173  /********************************/
17174 
17175  struct MALP_Trace_Event otf_event;
17176 
17177  uint64_t _begin = Timer_tsc ();
17178 
17181  {
17182 
17183  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17184  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17185  MALP_EVENT_MPI, _container.event.mpi_event.type );
17186  Event_Packer_push(&otf_event);
17187  }
17188 
17189  /********************************/
17190  /* ACTUAL FUNCTION CALL */
17191  /********************************/
17192 
17194  int ret = PMPI_Keyval_free( keyval );
17196 
17197  /********************************/
17198  /* EMIT OTF END */
17199  /********************************/
17200 
17201  uint64_t _end = Timer_tsc();
17202  uint64_t _duration = _end - _begin;
17203 
17205  {
17207  {
17208 
17209  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17210  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17211  MALP_EVENT_MPI, _container.event.mpi_event.type );
17212 
17213 
17214  Event_Packer_push(&otf_event);
17215  }
17216 
17217  /********************************/
17218  /* EMIT MALP EVENT */
17219  /********************************/
17220 
17221  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17222 
17223  /* Submit event if MPI instrumented */
17224  Event_Packer_push(&_container);
17225  }
17226 
17227 
17228  return ret;
17229 }
17230 int MPI_Lookup_name( char * service_name, MPI_Info info, char * port_name )
17231 {
17232 
17233  /* Virtualize MPI */
17234 
17235 
17236  /* Pre instrum */
17237  int _rank = Stream_desc_get()->mpi_rank;
17238 
17239  struct MALP_Trace_Event _container;
17240 
17241  /********************************/
17242  /* FILL MPI EVENT */
17243  /********************************/
17244 
17245  _container.event.mpi_event.type =
17246  T_MPI_ENUM(MPI_LOOKUP_NAME)
17247  ;
17248 
17249  /* Set default source & dest before override */
17250  _container.event.mpi_event.source = _rank;
17251  _container.event.mpi_event.dest = _rank;
17252 
17253 
17254 
17255 
17256 
17257 
17258 
17259 
17260  /* Fill in size informations if needed */
17261  int _size = 0;
17262  #if 0
17263 
17264  #endif
17265  _container.event.mpi_event.size = _size;
17266 
17267  /********************************/
17268  /* EMIT OTF ENTER */
17269  /********************************/
17270 
17271  struct MALP_Trace_Event otf_event;
17272 
17273  uint64_t _begin = Timer_tsc ();
17274 
17277  {
17278 
17279  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17280  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17281  MALP_EVENT_MPI, _container.event.mpi_event.type );
17282  Event_Packer_push(&otf_event);
17283  }
17284 
17285  /********************************/
17286  /* ACTUAL FUNCTION CALL */
17287  /********************************/
17288 
17290  int ret = PMPI_Lookup_name( service_name, info, port_name );
17292 
17293  /********************************/
17294  /* EMIT OTF END */
17295  /********************************/
17296 
17297  uint64_t _end = Timer_tsc();
17298  uint64_t _duration = _end - _begin;
17299 
17301  {
17303  {
17304 
17305  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17306  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17307  MALP_EVENT_MPI, _container.event.mpi_event.type );
17308 
17309 
17310  Event_Packer_push(&otf_event);
17311  }
17312 
17313  /********************************/
17314  /* EMIT MALP EVENT */
17315  /********************************/
17316 
17317  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17318 
17319  /* Submit event if MPI instrumented */
17320  Event_Packer_push(&_container);
17321  }
17322 
17323 
17324  return ret;
17325 }
17326 int MPI_Op_c2f( MPI_Op op )
17327 {
17328 
17329  /* Virtualize MPI */
17330 
17331 
17332  /* Pre instrum */
17333  int _rank = Stream_desc_get()->mpi_rank;
17334 
17335  struct MALP_Trace_Event _container;
17336 
17337  /********************************/
17338  /* FILL MPI EVENT */
17339  /********************************/
17340 
17341  _container.event.mpi_event.type =
17342  T_MPI_ENUM(MPI_OP_C2F)
17343  ;
17344 
17345  /* Set default source & dest before override */
17346  _container.event.mpi_event.source = _rank;
17347  _container.event.mpi_event.dest = _rank;
17348 
17349 
17350 
17351 
17352 
17353 
17354 
17355 
17356  /* Fill in size informations if needed */
17357  int _size = 0;
17358  #if 0
17359 
17360  #endif
17361  _container.event.mpi_event.size = _size;
17362 
17363  /********************************/
17364  /* EMIT OTF ENTER */
17365  /********************************/
17366 
17367  struct MALP_Trace_Event otf_event;
17368 
17369  uint64_t _begin = Timer_tsc ();
17370 
17373  {
17374 
17375  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17376  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17377  MALP_EVENT_MPI, _container.event.mpi_event.type );
17378  Event_Packer_push(&otf_event);
17379  }
17380 
17381  /********************************/
17382  /* ACTUAL FUNCTION CALL */
17383  /********************************/
17384 
17386  int ret = PMPI_Op_c2f( op );
17388 
17389  /********************************/
17390  /* EMIT OTF END */
17391  /********************************/
17392 
17393  uint64_t _end = Timer_tsc();
17394  uint64_t _duration = _end - _begin;
17395 
17397  {
17399  {
17400 
17401  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17402  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17403  MALP_EVENT_MPI, _container.event.mpi_event.type );
17404 
17405 
17406  Event_Packer_push(&otf_event);
17407  }
17408 
17409  /********************************/
17410  /* EMIT MALP EVENT */
17411  /********************************/
17412 
17413  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17414 
17415  /* Submit event if MPI instrumented */
17416  Event_Packer_push(&_container);
17417  }
17418 
17419 
17420  return ret;
17421 }
17422 int MPI_Op_commutative( MPI_Op op, int * commute )
17423 {
17424 
17425  /* Virtualize MPI */
17426 
17427 
17428  /* Pre instrum */
17429  int _rank = Stream_desc_get()->mpi_rank;
17430 
17431  struct MALP_Trace_Event _container;
17432 
17433  /********************************/
17434  /* FILL MPI EVENT */
17435  /********************************/
17436 
17437  _container.event.mpi_event.type =
17438  T_MPI_ENUM(MPI_OP_COMMUTATIVE)
17439  ;
17440 
17441  /* Set default source & dest before override */
17442  _container.event.mpi_event.source = _rank;
17443  _container.event.mpi_event.dest = _rank;
17444 
17445 
17446 
17447 
17448 
17449 
17450 
17451 
17452  /* Fill in size informations if needed */
17453  int _size = 0;
17454  #if 0
17455 
17456  #endif
17457  _container.event.mpi_event.size = _size;
17458 
17459  /********************************/
17460  /* EMIT OTF ENTER */
17461  /********************************/
17462 
17463  struct MALP_Trace_Event otf_event;
17464 
17465  uint64_t _begin = Timer_tsc ();
17466 
17469  {
17470 
17471  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17472  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17473  MALP_EVENT_MPI, _container.event.mpi_event.type );
17474  Event_Packer_push(&otf_event);
17475  }
17476 
17477  /********************************/
17478  /* ACTUAL FUNCTION CALL */
17479  /********************************/
17480 
17482  int ret = PMPI_Op_commutative( op, commute );
17484 
17485  /********************************/
17486  /* EMIT OTF END */
17487  /********************************/
17488 
17489  uint64_t _end = Timer_tsc();
17490  uint64_t _duration = _end - _begin;
17491 
17493  {
17495  {
17496 
17497  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17498  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17499  MALP_EVENT_MPI, _container.event.mpi_event.type );
17500 
17501 
17502  Event_Packer_push(&otf_event);
17503  }
17504 
17505  /********************************/
17506  /* EMIT MALP EVENT */
17507  /********************************/
17508 
17509  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17510 
17511  /* Submit event if MPI instrumented */
17512  Event_Packer_push(&_container);
17513  }
17514 
17515 
17516  return ret;
17517 }
17518 int MPI_Op_create( MPI_User_function * function, int commute, MPI_Op * op )
17519 {
17520 
17521  /* Virtualize MPI */
17522 
17523 
17524  /* Pre instrum */
17525  int _rank = Stream_desc_get()->mpi_rank;
17526 
17527  struct MALP_Trace_Event _container;
17528 
17529  /********************************/
17530  /* FILL MPI EVENT */
17531  /********************************/
17532 
17533  _container.event.mpi_event.type =
17534  T_MPI_ENUM(MPI_OP_CREATE)
17535  ;
17536 
17537  /* Set default source & dest before override */
17538  _container.event.mpi_event.source = _rank;
17539  _container.event.mpi_event.dest = _rank;
17540 
17541 
17542 
17543 
17544 
17545 
17546 
17547 
17548  /* Fill in size informations if needed */
17549  int _size = 0;
17550  #if 0
17551 
17552  #endif
17553  _container.event.mpi_event.size = _size;
17554 
17555  /********************************/
17556  /* EMIT OTF ENTER */
17557  /********************************/
17558 
17559  struct MALP_Trace_Event otf_event;
17560 
17561  uint64_t _begin = Timer_tsc ();
17562 
17565  {
17566 
17567  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17568  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17569  MALP_EVENT_MPI, _container.event.mpi_event.type );
17570  Event_Packer_push(&otf_event);
17571  }
17572 
17573  /********************************/
17574  /* ACTUAL FUNCTION CALL */
17575  /********************************/
17576 
17578  int ret = PMPI_Op_create( function, commute, op );
17580 
17581  /********************************/
17582  /* EMIT OTF END */
17583  /********************************/
17584 
17585  uint64_t _end = Timer_tsc();
17586  uint64_t _duration = _end - _begin;
17587 
17589  {
17591  {
17592 
17593  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17594  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17595  MALP_EVENT_MPI, _container.event.mpi_event.type );
17596 
17597 
17598  Event_Packer_push(&otf_event);
17599  }
17600 
17601  /********************************/
17602  /* EMIT MALP EVENT */
17603  /********************************/
17604 
17605  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17606 
17607  /* Submit event if MPI instrumented */
17608  Event_Packer_push(&_container);
17609  }
17610 
17611 
17612  return ret;
17613 }
17614 int MPI_Open_port( MPI_Info info, char * port_name )
17615 {
17616 
17617  /* Virtualize MPI */
17618 
17619 
17620  /* Pre instrum */
17621  int _rank = Stream_desc_get()->mpi_rank;
17622 
17623  struct MALP_Trace_Event _container;
17624 
17625  /********************************/
17626  /* FILL MPI EVENT */
17627  /********************************/
17628 
17629  _container.event.mpi_event.type =
17630  T_MPI_ENUM(MPI_OPEN_PORT)
17631  ;
17632 
17633  /* Set default source & dest before override */
17634  _container.event.mpi_event.source = _rank;
17635  _container.event.mpi_event.dest = _rank;
17636 
17637 
17638 
17639 
17640 
17641 
17642 
17643 
17644  /* Fill in size informations if needed */
17645  int _size = 0;
17646  #if 0
17647 
17648  #endif
17649  _container.event.mpi_event.size = _size;
17650 
17651  /********************************/
17652  /* EMIT OTF ENTER */
17653  /********************************/
17654 
17655  struct MALP_Trace_Event otf_event;
17656 
17657  uint64_t _begin = Timer_tsc ();
17658 
17661  {
17662 
17663  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17664  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17665  MALP_EVENT_MPI, _container.event.mpi_event.type );
17666  Event_Packer_push(&otf_event);
17667  }
17668 
17669  /********************************/
17670  /* ACTUAL FUNCTION CALL */
17671  /********************************/
17672 
17674  int ret = PMPI_Open_port( info, port_name );
17676 
17677  /********************************/
17678  /* EMIT OTF END */
17679  /********************************/
17680 
17681  uint64_t _end = Timer_tsc();
17682  uint64_t _duration = _end - _begin;
17683 
17685  {
17687  {
17688 
17689  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17690  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17691  MALP_EVENT_MPI, _container.event.mpi_event.type );
17692 
17693 
17694  Event_Packer_push(&otf_event);
17695  }
17696 
17697  /********************************/
17698  /* EMIT MALP EVENT */
17699  /********************************/
17700 
17701  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17702 
17703  /* Submit event if MPI instrumented */
17704  Event_Packer_push(&_container);
17705  }
17706 
17707 
17708  return ret;
17709 }
17710 int MPI_Op_free( MPI_Op * op )
17711 {
17712 
17713  /* Virtualize MPI */
17714 
17715 
17716  /* Pre instrum */
17717  int _rank = Stream_desc_get()->mpi_rank;
17718 
17719  struct MALP_Trace_Event _container;
17720 
17721  /********************************/
17722  /* FILL MPI EVENT */
17723  /********************************/
17724 
17725  _container.event.mpi_event.type =
17726  T_MPI_ENUM(MPI_OP_FREE)
17727  ;
17728 
17729  /* Set default source & dest before override */
17730  _container.event.mpi_event.source = _rank;
17731  _container.event.mpi_event.dest = _rank;
17732 
17733 
17734 
17735 
17736 
17737 
17738 
17739 
17740  /* Fill in size informations if needed */
17741  int _size = 0;
17742  #if 0
17743 
17744  #endif
17745  _container.event.mpi_event.size = _size;
17746 
17747  /********************************/
17748  /* EMIT OTF ENTER */
17749  /********************************/
17750 
17751  struct MALP_Trace_Event otf_event;
17752 
17753  uint64_t _begin = Timer_tsc ();
17754 
17757  {
17758 
17759  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17760  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17761  MALP_EVENT_MPI, _container.event.mpi_event.type );
17762  Event_Packer_push(&otf_event);
17763  }
17764 
17765  /********************************/
17766  /* ACTUAL FUNCTION CALL */
17767  /********************************/
17768 
17770  int ret = PMPI_Op_free( op );
17772 
17773  /********************************/
17774  /* EMIT OTF END */
17775  /********************************/
17776 
17777  uint64_t _end = Timer_tsc();
17778  uint64_t _duration = _end - _begin;
17779 
17781  {
17783  {
17784 
17785  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17786  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17787  MALP_EVENT_MPI, _container.event.mpi_event.type );
17788 
17789 
17790  Event_Packer_push(&otf_event);
17791  }
17792 
17793  /********************************/
17794  /* EMIT MALP EVENT */
17795  /********************************/
17796 
17797  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17798 
17799  /* Submit event if MPI instrumented */
17800  Event_Packer_push(&_container);
17801  }
17802 
17803 
17804  return ret;
17805 }
17806 int MPI_Pack_external( char * datarep, void * inbuf, int incount, MPI_Datatype datatype, void * outbuf, MPI_Aint outsize, MPI_Aint * position )
17807 {
17808 
17809  /* Virtualize MPI */
17810 
17811 
17812  /* Pre instrum */
17813  int _rank = Stream_desc_get()->mpi_rank;
17814 
17815  struct MALP_Trace_Event _container;
17816 
17817  /********************************/
17818  /* FILL MPI EVENT */
17819  /********************************/
17820 
17821  _container.event.mpi_event.type =
17822  T_MPI_ENUM(MPI_PACK_EXTERNAL)
17823  ;
17824 
17825  /* Set default source & dest before override */
17826  _container.event.mpi_event.source = _rank;
17827  _container.event.mpi_event.dest = _rank;
17828 
17829 
17830 
17831 
17832 
17833  SET_DATATYPE (datatype)
17834 
17835 
17836  /* Fill in size informations if needed */
17837  int _size = 0;
17838  #if 1
17839 
17840  #endif
17841  _container.event.mpi_event.size = _size;
17842 
17843  /********************************/
17844  /* EMIT OTF ENTER */
17845  /********************************/
17846 
17847  struct MALP_Trace_Event otf_event;
17848 
17849  uint64_t _begin = Timer_tsc ();
17850 
17853  {
17854 
17855  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17856  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17857  MALP_EVENT_MPI, _container.event.mpi_event.type );
17858  Event_Packer_push(&otf_event);
17859  }
17860 
17861  /********************************/
17862  /* ACTUAL FUNCTION CALL */
17863  /********************************/
17864 
17866  int ret = PMPI_Pack_external( datarep, inbuf, incount, datatype, outbuf, outsize, position );
17868 
17869  /********************************/
17870  /* EMIT OTF END */
17871  /********************************/
17872 
17873  uint64_t _end = Timer_tsc();
17874  uint64_t _duration = _end - _begin;
17875 
17877  {
17879  {
17880 
17881  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17882  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17883  MALP_EVENT_MPI, _container.event.mpi_event.type );
17884 
17885 
17886  Event_Packer_push(&otf_event);
17887  }
17888 
17889  /********************************/
17890  /* EMIT MALP EVENT */
17891  /********************************/
17892 
17893  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17894 
17895  /* Submit event if MPI instrumented */
17896  Event_Packer_push(&_container);
17897  }
17898 
17899 
17900  return ret;
17901 }
17902 int MPI_Pack_external_size( char * datarep, int incount, MPI_Datatype datatype, MPI_Aint * size )
17903 {
17904 
17905  /* Virtualize MPI */
17906 
17907 
17908  /* Pre instrum */
17909  int _rank = Stream_desc_get()->mpi_rank;
17910 
17911  struct MALP_Trace_Event _container;
17912 
17913  /********************************/
17914  /* FILL MPI EVENT */
17915  /********************************/
17916 
17917  _container.event.mpi_event.type =
17918  T_MPI_ENUM(MPI_PACK_EXTERNAL_SIZE)
17919  ;
17920 
17921  /* Set default source & dest before override */
17922  _container.event.mpi_event.source = _rank;
17923  _container.event.mpi_event.dest = _rank;
17924 
17925 
17926 
17927 
17928 
17929  SET_DATATYPE (datatype)
17930 
17931 
17932  /* Fill in size informations if needed */
17933  int _size = 0;
17934  #if 1
17935 
17936  #endif
17937  _container.event.mpi_event.size = _size;
17938 
17939  /********************************/
17940  /* EMIT OTF ENTER */
17941  /********************************/
17942 
17943  struct MALP_Trace_Event otf_event;
17944 
17945  uint64_t _begin = Timer_tsc ();
17946 
17949  {
17950 
17951  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
17952  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
17953  MALP_EVENT_MPI, _container.event.mpi_event.type );
17954  Event_Packer_push(&otf_event);
17955  }
17956 
17957  /********************************/
17958  /* ACTUAL FUNCTION CALL */
17959  /********************************/
17960 
17962  int ret = PMPI_Pack_external_size( datarep, incount, datatype, size );
17964 
17965  /********************************/
17966  /* EMIT OTF END */
17967  /********************************/
17968 
17969  uint64_t _end = Timer_tsc();
17970  uint64_t _duration = _end - _begin;
17971 
17973  {
17975  {
17976 
17977  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
17978  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
17979  MALP_EVENT_MPI, _container.event.mpi_event.type );
17980 
17981 
17982  Event_Packer_push(&otf_event);
17983  }
17984 
17985  /********************************/
17986  /* EMIT MALP EVENT */
17987  /********************************/
17988 
17989  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
17990 
17991  /* Submit event if MPI instrumented */
17992  Event_Packer_push(&_container);
17993  }
17994 
17995 
17996  return ret;
17997 }
17998 int MPI_Pack( void * inbuf, int incount, MPI_Datatype datatype, void * outbuf, int outsize, int * position, MPI_Comm comm )
17999 {
18000 
18001  /* Virtualize MPI */
18002  MACRO_MPI_Comm (comm)
18003 
18004  /* Pre instrum */
18005  int _rank = Stream_desc_get()->mpi_rank;
18006 
18007  struct MALP_Trace_Event _container;
18008 
18009  /********************************/
18010  /* FILL MPI EVENT */
18011  /********************************/
18012 
18013  _container.event.mpi_event.type =
18014  T_MPI_ENUM(MPI_PACK)
18015  ;
18016 
18017  /* Set default source & dest before override */
18018  _container.event.mpi_event.source = _rank;
18019  _container.event.mpi_event.dest = _rank;
18020 
18021 
18022 
18023 
18024 
18025  SET_DATATYPE (datatype)
18026  SET_COMM (comm)
18027 
18028  /* Fill in size informations if needed */
18029  int _size = 0;
18030  #if 1
18031 
18032  #endif
18033  _container.event.mpi_event.size = _size;
18034 
18035  /********************************/
18036  /* EMIT OTF ENTER */
18037  /********************************/
18038 
18039  struct MALP_Trace_Event otf_event;
18040 
18041  uint64_t _begin = Timer_tsc ();
18042 
18045  {
18046 
18047  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18048  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18049  MALP_EVENT_MPI, _container.event.mpi_event.type );
18050  Event_Packer_push(&otf_event);
18051  }
18052 
18053  /********************************/
18054  /* ACTUAL FUNCTION CALL */
18055  /********************************/
18056 
18058  int ret = PMPI_Pack( inbuf, incount, datatype, outbuf, outsize, position, comm );
18060 
18061  /********************************/
18062  /* EMIT OTF END */
18063  /********************************/
18064 
18065  uint64_t _end = Timer_tsc();
18066  uint64_t _duration = _end - _begin;
18067 
18069  {
18071  {
18072 
18073  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18074  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18075  MALP_EVENT_MPI, _container.event.mpi_event.type );
18076 
18077 
18078  Event_Packer_push(&otf_event);
18079  }
18080 
18081  /********************************/
18082  /* EMIT MALP EVENT */
18083  /********************************/
18084 
18085  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18086 
18087  /* Submit event if MPI instrumented */
18088  Event_Packer_push(&_container);
18089  }
18090 
18091 
18092  return ret;
18093 }
18094 int MPI_Pack_size( int incount, MPI_Datatype datatype, MPI_Comm comm, int * size )
18095 {
18096 
18097  /* Virtualize MPI */
18098  MACRO_MPI_Comm (comm)
18099 
18100  /* Pre instrum */
18101  int _rank = Stream_desc_get()->mpi_rank;
18102 
18103  struct MALP_Trace_Event _container;
18104 
18105  /********************************/
18106  /* FILL MPI EVENT */
18107  /********************************/
18108 
18109  _container.event.mpi_event.type =
18110  T_MPI_ENUM(MPI_PACK_SIZE)
18111  ;
18112 
18113  /* Set default source & dest before override */
18114  _container.event.mpi_event.source = _rank;
18115  _container.event.mpi_event.dest = _rank;
18116 
18117 
18118 
18119 
18120 
18121  SET_DATATYPE (datatype)
18122  SET_COMM (comm)
18123 
18124  /* Fill in size informations if needed */
18125  int _size = 0;
18126  #if 1
18127 
18128  #endif
18129  _container.event.mpi_event.size = _size;
18130 
18131  /********************************/
18132  /* EMIT OTF ENTER */
18133  /********************************/
18134 
18135  struct MALP_Trace_Event otf_event;
18136 
18137  uint64_t _begin = Timer_tsc ();
18138 
18141  {
18142 
18143  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18144  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18145  MALP_EVENT_MPI, _container.event.mpi_event.type );
18146  Event_Packer_push(&otf_event);
18147  }
18148 
18149  /********************************/
18150  /* ACTUAL FUNCTION CALL */
18151  /********************************/
18152 
18154  int ret = PMPI_Pack_size( incount, datatype, comm, size );
18156 
18157  /********************************/
18158  /* EMIT OTF END */
18159  /********************************/
18160 
18161  uint64_t _end = Timer_tsc();
18162  uint64_t _duration = _end - _begin;
18163 
18165  {
18167  {
18168 
18169  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18170  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18171  MALP_EVENT_MPI, _container.event.mpi_event.type );
18172 
18173 
18174  Event_Packer_push(&otf_event);
18175  }
18176 
18177  /********************************/
18178  /* EMIT MALP EVENT */
18179  /********************************/
18180 
18181  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18182 
18183  /* Submit event if MPI instrumented */
18184  Event_Packer_push(&_container);
18185  }
18186 
18187 
18188  return ret;
18189 }
18190 int MPI_Probe( int source, int tag, MPI_Comm comm, MPI_Status * status )
18191 {
18192 
18193  /* Virtualize MPI */
18194  MACRO_MPI_Comm (comm)
18195 
18196  /* Pre instrum */
18197  int _rank = Stream_desc_get()->mpi_rank;
18198 
18199  struct MALP_Trace_Event _container;
18200 
18201  /********************************/
18202  /* FILL MPI EVENT */
18203  /********************************/
18204 
18205  _container.event.mpi_event.type =
18206  T_MPI_ENUM(MPI_PROBE)
18207  ;
18208 
18209  /* Set default source & dest before override */
18210  _container.event.mpi_event.source = _rank;
18211  _container.event.mpi_event.dest = _rank;
18212 
18213  SET_SOURCE (source)
18214 
18215  SET_TAG (tag)
18216 
18217 
18218  SET_COMM (comm)
18219 
18220  /* Fill in size informations if needed */
18221  int _size = 0;
18222  #if 0
18223 
18224  #endif
18225  _container.event.mpi_event.size = _size;
18226 
18227  /********************************/
18228  /* EMIT OTF ENTER */
18229  /********************************/
18230 
18231  struct MALP_Trace_Event otf_event;
18232 
18233  uint64_t _begin = Timer_tsc ();
18234 
18237  {
18238 
18239  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18240  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18241  MALP_EVENT_MPI, _container.event.mpi_event.type );
18242  Event_Packer_push(&otf_event);
18243  }
18244 
18245  /********************************/
18246  /* ACTUAL FUNCTION CALL */
18247  /********************************/
18248 
18250  int ret = PMPI_Probe( source, tag, comm, status );
18252 
18253  /********************************/
18254  /* EMIT OTF END */
18255  /********************************/
18256 
18257  uint64_t _end = Timer_tsc();
18258  uint64_t _duration = _end - _begin;
18259 
18261  {
18263  {
18264 
18265  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18266  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18267  MALP_EVENT_MPI, _container.event.mpi_event.type );
18268 
18269 
18270  Event_Packer_push(&otf_event);
18271  }
18272 
18273  /********************************/
18274  /* EMIT MALP EVENT */
18275  /********************************/
18276 
18277  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18278 
18279  /* Submit event if MPI instrumented */
18280  Event_Packer_push(&_container);
18281  }
18282 
18283 
18284  return ret;
18285 }
18286 int MPI_Publish_name( char * service_name, MPI_Info info, char * port_name )
18287 {
18288 
18289  /* Virtualize MPI */
18290 
18291 
18292  /* Pre instrum */
18293  int _rank = Stream_desc_get()->mpi_rank;
18294 
18295  struct MALP_Trace_Event _container;
18296 
18297  /********************************/
18298  /* FILL MPI EVENT */
18299  /********************************/
18300 
18301  _container.event.mpi_event.type =
18302  T_MPI_ENUM(MPI_PUBLISH_NAME)
18303  ;
18304 
18305  /* Set default source & dest before override */
18306  _container.event.mpi_event.source = _rank;
18307  _container.event.mpi_event.dest = _rank;
18308 
18309 
18310 
18311 
18312 
18313 
18314 
18315 
18316  /* Fill in size informations if needed */
18317  int _size = 0;
18318  #if 0
18319 
18320  #endif
18321  _container.event.mpi_event.size = _size;
18322 
18323  /********************************/
18324  /* EMIT OTF ENTER */
18325  /********************************/
18326 
18327  struct MALP_Trace_Event otf_event;
18328 
18329  uint64_t _begin = Timer_tsc ();
18330 
18333  {
18334 
18335  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18336  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18337  MALP_EVENT_MPI, _container.event.mpi_event.type );
18338  Event_Packer_push(&otf_event);
18339  }
18340 
18341  /********************************/
18342  /* ACTUAL FUNCTION CALL */
18343  /********************************/
18344 
18346  int ret = PMPI_Publish_name( service_name, info, port_name );
18348 
18349  /********************************/
18350  /* EMIT OTF END */
18351  /********************************/
18352 
18353  uint64_t _end = Timer_tsc();
18354  uint64_t _duration = _end - _begin;
18355 
18357  {
18359  {
18360 
18361  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18362  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18363  MALP_EVENT_MPI, _container.event.mpi_event.type );
18364 
18365 
18366  Event_Packer_push(&otf_event);
18367  }
18368 
18369  /********************************/
18370  /* EMIT MALP EVENT */
18371  /********************************/
18372 
18373  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18374 
18375  /* Submit event if MPI instrumented */
18376  Event_Packer_push(&_container);
18377  }
18378 
18379 
18380  return ret;
18381 }
18382 int MPI_Put( void * origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win )
18383 {
18384 
18385  /* Virtualize MPI */
18386 
18387 
18388  /* Pre instrum */
18389  int _rank = Stream_desc_get()->mpi_rank;
18390 
18391  struct MALP_Trace_Event _container;
18392 
18393  /********************************/
18394  /* FILL MPI EVENT */
18395  /********************************/
18396 
18397  _container.event.mpi_event.type =
18398  T_MPI_ENUM(MPI_PUT)
18399  ;
18400 
18401  /* Set default source & dest before override */
18402  _container.event.mpi_event.source = _rank;
18403  _container.event.mpi_event.dest = _rank;
18404 
18405 
18406 
18407 
18408 
18409 
18410 
18411 
18412  /* Fill in size informations if needed */
18413  int _size = 0;
18414  #if 0
18415 
18416  #endif
18417  _container.event.mpi_event.size = _size;
18418 
18419  /********************************/
18420  /* EMIT OTF ENTER */
18421  /********************************/
18422 
18423  struct MALP_Trace_Event otf_event;
18424 
18425  uint64_t _begin = Timer_tsc ();
18426 
18429  {
18430 
18431  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18432  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18433  MALP_EVENT_MPI, _container.event.mpi_event.type );
18434  Event_Packer_push(&otf_event);
18435  }
18436 
18437  /********************************/
18438  /* ACTUAL FUNCTION CALL */
18439  /********************************/
18440 
18442  int ret = PMPI_Put( origin_addr, origin_count, origin_datatype, target_rank, target_disp, target_count, target_datatype, win );
18444 
18445  /********************************/
18446  /* EMIT OTF END */
18447  /********************************/
18448 
18449  uint64_t _end = Timer_tsc();
18450  uint64_t _duration = _end - _begin;
18451 
18453  {
18455  {
18456 
18457  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18458  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18459  MALP_EVENT_MPI, _container.event.mpi_event.type );
18460 
18461 
18462  Event_Packer_push(&otf_event);
18463  }
18464 
18465  /********************************/
18466  /* EMIT MALP EVENT */
18467  /********************************/
18468 
18469  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18470 
18471  /* Submit event if MPI instrumented */
18472  Event_Packer_push(&_container);
18473  }
18474 
18475 
18476  return ret;
18477 }
18478 int MPI_Query_thread( int * provided )
18479 {
18480 
18481  /* Virtualize MPI */
18482 
18483 
18484  /* Pre instrum */
18485  int _rank = Stream_desc_get()->mpi_rank;
18486 
18487  struct MALP_Trace_Event _container;
18488 
18489  /********************************/
18490  /* FILL MPI EVENT */
18491  /********************************/
18492 
18493  _container.event.mpi_event.type =
18494  T_MPI_ENUM(MPI_QUERY_THREAD)
18495  ;
18496 
18497  /* Set default source & dest before override */
18498  _container.event.mpi_event.source = _rank;
18499  _container.event.mpi_event.dest = _rank;
18500 
18501 
18502 
18503 
18504 
18505 
18506 
18507 
18508  /* Fill in size informations if needed */
18509  int _size = 0;
18510  #if 0
18511 
18512  #endif
18513  _container.event.mpi_event.size = _size;
18514 
18515  /********************************/
18516  /* EMIT OTF ENTER */
18517  /********************************/
18518 
18519  struct MALP_Trace_Event otf_event;
18520 
18521  uint64_t _begin = Timer_tsc ();
18522 
18525  {
18526 
18527  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18528  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18529  MALP_EVENT_MPI, _container.event.mpi_event.type );
18530  Event_Packer_push(&otf_event);
18531  }
18532 
18533  /********************************/
18534  /* ACTUAL FUNCTION CALL */
18535  /********************************/
18536 
18538  int ret = PMPI_Query_thread( provided );
18540 
18541  /********************************/
18542  /* EMIT OTF END */
18543  /********************************/
18544 
18545  uint64_t _end = Timer_tsc();
18546  uint64_t _duration = _end - _begin;
18547 
18549  {
18551  {
18552 
18553  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18554  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18555  MALP_EVENT_MPI, _container.event.mpi_event.type );
18556 
18557 
18558  Event_Packer_push(&otf_event);
18559  }
18560 
18561  /********************************/
18562  /* EMIT MALP EVENT */
18563  /********************************/
18564 
18565  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18566 
18567  /* Submit event if MPI instrumented */
18568  Event_Packer_push(&_container);
18569  }
18570 
18571 
18572  return ret;
18573 }
18574 int MPI_Recv_init( void * buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request * request )
18575 {
18576 
18577  /* Virtualize MPI */
18578  MACRO_MPI_Comm (comm)
18579 
18580  /* Pre instrum */
18581  int _rank = Stream_desc_get()->mpi_rank;
18582 
18583  struct MALP_Trace_Event _container;
18584 
18585  /********************************/
18586  /* FILL MPI EVENT */
18587  /********************************/
18588 
18589  _container.event.mpi_event.type =
18590  T_MPI_ENUM(MPI_RECV_INIT)
18591  ;
18592 
18593  /* Set default source & dest before override */
18594  _container.event.mpi_event.source = _rank;
18595  _container.event.mpi_event.dest = _rank;
18596 
18597  SET_SOURCE (source)
18598 
18599  SET_TAG (tag)
18600  SET_COUNT (count)
18601  SET_DATATYPE (datatype)
18602  SET_COMM (comm)
18603 
18604  /* Fill in size informations if needed */
18605  int _size = 0;
18606  #if 1
18607  COMP_SIZE (count)
18608  #endif
18609  _container.event.mpi_event.size = _size;
18610 
18611  /********************************/
18612  /* EMIT OTF ENTER */
18613  /********************************/
18614 
18615  struct MALP_Trace_Event otf_event;
18616 
18617  uint64_t _begin = Timer_tsc ();
18618 
18621  {
18622 
18623  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18624  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18625  MALP_EVENT_MPI, _container.event.mpi_event.type );
18626  Event_Packer_push(&otf_event);
18627  }
18628 
18629  /********************************/
18630  /* ACTUAL FUNCTION CALL */
18631  /********************************/
18632 
18634  int ret = PMPI_Recv_init( buf, count, datatype, source, tag, comm, request );
18636 
18637  /********************************/
18638  /* EMIT OTF END */
18639  /********************************/
18640 
18641  uint64_t _end = Timer_tsc();
18642  uint64_t _duration = _end - _begin;
18643 
18645  {
18647  {
18648 
18649  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18650  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18651  MALP_EVENT_MPI, _container.event.mpi_event.type );
18652 
18653 
18654  Event_Packer_push(&otf_event);
18655  }
18656 
18657  /********************************/
18658  /* EMIT MALP EVENT */
18659  /********************************/
18660 
18661  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18662 
18663  /* Submit event if MPI instrumented */
18664  Event_Packer_push(&_container);
18665  }
18666 
18667 
18668  return ret;
18669 }
18670 int MPI_Recv( void * buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status * status )
18671 {
18672 
18673  /* Virtualize MPI */
18674  MACRO_MPI_Comm (comm)
18675 
18676  /* Pre instrum */
18677  int _rank = Stream_desc_get()->mpi_rank;
18678 
18679  struct MALP_Trace_Event _container;
18680 
18681  /********************************/
18682  /* FILL MPI EVENT */
18683  /********************************/
18684 
18685  _container.event.mpi_event.type =
18686  T_MPI_ENUM(MPI_RECV)
18687  ;
18688 
18689  /* Set default source & dest before override */
18690  _container.event.mpi_event.source = _rank;
18691  _container.event.mpi_event.dest = _rank;
18692 
18693  SET_SOURCE (source)
18694 
18695  SET_TAG (tag)
18696  SET_COUNT (count)
18697  SET_DATATYPE (datatype)
18698  SET_COMM (comm)
18699 
18700  /* Fill in size informations if needed */
18701  int _size = 0;
18702  #if 1
18703  COMP_SIZE (count)
18704  #endif
18705  _container.event.mpi_event.size = _size;
18706 
18707  /********************************/
18708  /* EMIT OTF ENTER */
18709  /********************************/
18710 
18711  struct MALP_Trace_Event otf_event;
18712 
18713  uint64_t _begin = Timer_tsc ();
18714 
18717  {
18718 
18719  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18720  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18721  MALP_EVENT_MPI, _container.event.mpi_event.type );
18722  Event_Packer_push(&otf_event);
18723  }
18724 
18725  /********************************/
18726  /* ACTUAL FUNCTION CALL */
18727  /********************************/
18728 
18730  int ret = PMPI_Recv( buf, count, datatype, source, tag, comm, status );
18732 
18733  /********************************/
18734  /* EMIT OTF END */
18735  /********************************/
18736 
18737  uint64_t _end = Timer_tsc();
18738  uint64_t _duration = _end - _begin;
18739 
18741  {
18743  {
18744 
18745  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18746  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18747  MALP_EVENT_MPI, _container.event.mpi_event.type );
18748 
18749 
18750  Event_Packer_push(&otf_event);
18751  }
18752 
18753  /********************************/
18754  /* EMIT MALP EVENT */
18755  /********************************/
18756 
18757  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18758 
18759  /* Submit event if MPI instrumented */
18760  Event_Packer_push(&_container);
18761  }
18762 
18763 
18764  return ret;
18765 }
18766 int MPI_Reduce( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm )
18767 {
18768 
18769  /* Virtualize MPI */
18770  MACRO_MPI_Comm (comm)
18771 
18772  /* Pre instrum */
18773  int _rank = Stream_desc_get()->mpi_rank;
18774 
18775  struct MALP_Trace_Event _container;
18776 
18777  /********************************/
18778  /* FILL MPI EVENT */
18779  /********************************/
18780 
18781  _container.event.mpi_event.type =
18782  T_MPI_ENUM(MPI_REDUCE)
18783  ;
18784 
18785  /* Set default source & dest before override */
18786  _container.event.mpi_event.source = _rank;
18787  _container.event.mpi_event.dest = _rank;
18788 
18789 
18790 
18791 
18792  SET_COUNT (count)
18793  SET_DATATYPE (datatype)
18794  SET_COMM (comm)
18795 
18796  /* Fill in size informations if needed */
18797  int _size = 0;
18798  #if 1
18799  COMP_SIZE (count)
18800  #endif
18801  _container.event.mpi_event.size = _size;
18802 
18803  /********************************/
18804  /* EMIT OTF ENTER */
18805  /********************************/
18806 
18807  struct MALP_Trace_Event otf_event;
18808 
18809  uint64_t _begin = Timer_tsc ();
18810 
18813  {
18814 
18815  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18816  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18817  MALP_EVENT_MPI, _container.event.mpi_event.type );
18818  Event_Packer_push(&otf_event);
18819  }
18820 
18821  /********************************/
18822  /* ACTUAL FUNCTION CALL */
18823  /********************************/
18824 
18826  int ret = PMPI_Reduce( sendbuf, recvbuf, count, datatype, op, root, comm );
18828 
18829  /********************************/
18830  /* EMIT OTF END */
18831  /********************************/
18832 
18833  uint64_t _end = Timer_tsc();
18834  uint64_t _duration = _end - _begin;
18835 
18837  {
18839  {
18840 
18841  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18842  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18843  MALP_EVENT_MPI, _container.event.mpi_event.type );
18844 
18845 
18846  Event_Packer_push(&otf_event);
18847  }
18848 
18849  /********************************/
18850  /* EMIT MALP EVENT */
18851  /********************************/
18852 
18853  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18854 
18855  /* Submit event if MPI instrumented */
18856  Event_Packer_push(&_container);
18857  }
18858 
18859 
18860  return ret;
18861 }
18862 int MPI_Reduce_local( void * inbuf, void * inoutbuf, int count, MPI_Datatype datatype, MPI_Op op )
18863 {
18864 
18865  /* Virtualize MPI */
18866 
18867 
18868  /* Pre instrum */
18869  int _rank = Stream_desc_get()->mpi_rank;
18870 
18871  struct MALP_Trace_Event _container;
18872 
18873  /********************************/
18874  /* FILL MPI EVENT */
18875  /********************************/
18876 
18877  _container.event.mpi_event.type =
18878  T_MPI_ENUM(MPI_REDUCE_LOCAL)
18879  ;
18880 
18881  /* Set default source & dest before override */
18882  _container.event.mpi_event.source = _rank;
18883  _container.event.mpi_event.dest = _rank;
18884 
18885 
18886 
18887 
18888  SET_COUNT (count)
18889  SET_DATATYPE (datatype)
18890 
18891 
18892  /* Fill in size informations if needed */
18893  int _size = 0;
18894  #if 1
18895  COMP_SIZE (count)
18896  #endif
18897  _container.event.mpi_event.size = _size;
18898 
18899  /********************************/
18900  /* EMIT OTF ENTER */
18901  /********************************/
18902 
18903  struct MALP_Trace_Event otf_event;
18904 
18905  uint64_t _begin = Timer_tsc ();
18906 
18909  {
18910 
18911  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
18912  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
18913  MALP_EVENT_MPI, _container.event.mpi_event.type );
18914  Event_Packer_push(&otf_event);
18915  }
18916 
18917  /********************************/
18918  /* ACTUAL FUNCTION CALL */
18919  /********************************/
18920 
18922  int ret = PMPI_Reduce_local( inbuf, inoutbuf, count, datatype, op );
18924 
18925  /********************************/
18926  /* EMIT OTF END */
18927  /********************************/
18928 
18929  uint64_t _end = Timer_tsc();
18930  uint64_t _duration = _end - _begin;
18931 
18933  {
18935  {
18936 
18937  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
18938  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
18939  MALP_EVENT_MPI, _container.event.mpi_event.type );
18940 
18941 
18942  Event_Packer_push(&otf_event);
18943  }
18944 
18945  /********************************/
18946  /* EMIT MALP EVENT */
18947  /********************************/
18948 
18949  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
18950 
18951  /* Submit event if MPI instrumented */
18952  Event_Packer_push(&_container);
18953  }
18954 
18955 
18956  return ret;
18957 }
18958 int MPI_Reduce_scatter( void * sendbuf, void * recvbuf, int * recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
18959 {
18960 
18961  /* Virtualize MPI */
18962  MACRO_MPI_Comm (comm)
18963 
18964  /* Pre instrum */
18965  int _rank = Stream_desc_get()->mpi_rank;
18966 
18967  struct MALP_Trace_Event _container;
18968 
18969  /********************************/
18970  /* FILL MPI EVENT */
18971  /********************************/
18972 
18973  _container.event.mpi_event.type =
18974  T_MPI_ENUM(MPI_REDUCE_SCATTER)
18975  ;
18976 
18977  /* Set default source & dest before override */
18978  _container.event.mpi_event.source = _rank;
18979  _container.event.mpi_event.dest = _rank;
18980 
18981 
18982 
18983 
18984 
18985  SET_DATATYPE (datatype)
18986  SET_COMM (comm)
18987 
18988  /* Fill in size informations if needed */
18989  int _size = 0;
18990  #if 1
18991 
18992  #endif
18993  _container.event.mpi_event.size = _size;
18994 
18995  /********************************/
18996  /* EMIT OTF ENTER */
18997  /********************************/
18998 
18999  struct MALP_Trace_Event otf_event;
19000 
19001  uint64_t _begin = Timer_tsc ();
19002 
19005  {
19006 
19007  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19008  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19009  MALP_EVENT_MPI, _container.event.mpi_event.type );
19010  Event_Packer_push(&otf_event);
19011  }
19012 
19013  /********************************/
19014  /* ACTUAL FUNCTION CALL */
19015  /********************************/
19016 
19018  int ret = PMPI_Reduce_scatter( sendbuf, recvbuf, recvcounts, datatype, op, comm );
19020 
19021  /********************************/
19022  /* EMIT OTF END */
19023  /********************************/
19024 
19025  uint64_t _end = Timer_tsc();
19026  uint64_t _duration = _end - _begin;
19027 
19029  {
19031  {
19032 
19033  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19034  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19035  MALP_EVENT_MPI, _container.event.mpi_event.type );
19036 
19037 
19038  Event_Packer_push(&otf_event);
19039  }
19040 
19041  /********************************/
19042  /* EMIT MALP EVENT */
19043  /********************************/
19044 
19045  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19046 
19047  /* Submit event if MPI instrumented */
19048  Event_Packer_push(&_container);
19049  }
19050 
19051 
19052  return ret;
19053 }
19054 int MPI_Register_datarep( char * datarep, MPI_Datarep_conversion_function * read_conversion_fn, MPI_Datarep_conversion_function * write_conversion_fn, MPI_Datarep_extent_function * dtype_file_extent_fn, void * extra_state )
19055 {
19056 
19057  /* Virtualize MPI */
19058 
19059 
19060  /* Pre instrum */
19061  int _rank = Stream_desc_get()->mpi_rank;
19062 
19063  struct MALP_Trace_Event _container;
19064 
19065  /********************************/
19066  /* FILL MPI EVENT */
19067  /********************************/
19068 
19069  _container.event.mpi_event.type =
19070  T_MPI_ENUM(MPI_REGISTER_DATAREP)
19071  ;
19072 
19073  /* Set default source & dest before override */
19074  _container.event.mpi_event.source = _rank;
19075  _container.event.mpi_event.dest = _rank;
19076 
19077 
19078 
19079 
19080 
19081 
19082 
19083 
19084  /* Fill in size informations if needed */
19085  int _size = 0;
19086  #if 0
19087 
19088  #endif
19089  _container.event.mpi_event.size = _size;
19090 
19091  /********************************/
19092  /* EMIT OTF ENTER */
19093  /********************************/
19094 
19095  struct MALP_Trace_Event otf_event;
19096 
19097  uint64_t _begin = Timer_tsc ();
19098 
19101  {
19102 
19103  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19104  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19105  MALP_EVENT_MPI, _container.event.mpi_event.type );
19106  Event_Packer_push(&otf_event);
19107  }
19108 
19109  /********************************/
19110  /* ACTUAL FUNCTION CALL */
19111  /********************************/
19112 
19114  int ret = PMPI_Register_datarep( datarep, read_conversion_fn, write_conversion_fn, dtype_file_extent_fn, extra_state );
19116 
19117  /********************************/
19118  /* EMIT OTF END */
19119  /********************************/
19120 
19121  uint64_t _end = Timer_tsc();
19122  uint64_t _duration = _end - _begin;
19123 
19125  {
19127  {
19128 
19129  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19130  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19131  MALP_EVENT_MPI, _container.event.mpi_event.type );
19132 
19133 
19134  Event_Packer_push(&otf_event);
19135  }
19136 
19137  /********************************/
19138  /* EMIT MALP EVENT */
19139  /********************************/
19140 
19141  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19142 
19143  /* Submit event if MPI instrumented */
19144  Event_Packer_push(&_container);
19145  }
19146 
19147 
19148  return ret;
19149 }
19150 int MPI_Request_c2f( MPI_Request request )
19151 {
19152 
19153  /* Virtualize MPI */
19154 
19155 
19156  /* Pre instrum */
19157  int _rank = Stream_desc_get()->mpi_rank;
19158 
19159  struct MALP_Trace_Event _container;
19160 
19161  /********************************/
19162  /* FILL MPI EVENT */
19163  /********************************/
19164 
19165  _container.event.mpi_event.type =
19166  T_MPI_ENUM(MPI_REQUEST_C2F)
19167  ;
19168 
19169  /* Set default source & dest before override */
19170  _container.event.mpi_event.source = _rank;
19171  _container.event.mpi_event.dest = _rank;
19172 
19173 
19174 
19175 
19176 
19177 
19178 
19179 
19180  /* Fill in size informations if needed */
19181  int _size = 0;
19182  #if 0
19183 
19184  #endif
19185  _container.event.mpi_event.size = _size;
19186 
19187  /********************************/
19188  /* EMIT OTF ENTER */
19189  /********************************/
19190 
19191  struct MALP_Trace_Event otf_event;
19192 
19193  uint64_t _begin = Timer_tsc ();
19194 
19197  {
19198 
19199  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19200  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19201  MALP_EVENT_MPI, _container.event.mpi_event.type );
19202  Event_Packer_push(&otf_event);
19203  }
19204 
19205  /********************************/
19206  /* ACTUAL FUNCTION CALL */
19207  /********************************/
19208 
19210  int ret = PMPI_Request_c2f( request );
19212 
19213  /********************************/
19214  /* EMIT OTF END */
19215  /********************************/
19216 
19217  uint64_t _end = Timer_tsc();
19218  uint64_t _duration = _end - _begin;
19219 
19221  {
19223  {
19224 
19225  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19226  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19227  MALP_EVENT_MPI, _container.event.mpi_event.type );
19228 
19229 
19230  Event_Packer_push(&otf_event);
19231  }
19232 
19233  /********************************/
19234  /* EMIT MALP EVENT */
19235  /********************************/
19236 
19237  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19238 
19239  /* Submit event if MPI instrumented */
19240  Event_Packer_push(&_container);
19241  }
19242 
19243 
19244  return ret;
19245 }
19246 int MPI_Request_free( MPI_Request * request )
19247 {
19248 
19249  /* Virtualize MPI */
19250 
19251 
19252  /* Pre instrum */
19253  int _rank = Stream_desc_get()->mpi_rank;
19254 
19255  struct MALP_Trace_Event _container;
19256 
19257  /********************************/
19258  /* FILL MPI EVENT */
19259  /********************************/
19260 
19261  _container.event.mpi_event.type =
19262  T_MPI_ENUM(MPI_REQUEST_FREE)
19263  ;
19264 
19265  /* Set default source & dest before override */
19266  _container.event.mpi_event.source = _rank;
19267  _container.event.mpi_event.dest = _rank;
19268 
19269 
19270 
19271 
19272 
19273 
19274 
19275 
19276  /* Fill in size informations if needed */
19277  int _size = 0;
19278  #if 0
19279 
19280  #endif
19281  _container.event.mpi_event.size = _size;
19282 
19283  /********************************/
19284  /* EMIT OTF ENTER */
19285  /********************************/
19286 
19287  struct MALP_Trace_Event otf_event;
19288 
19289  uint64_t _begin = Timer_tsc ();
19290 
19293  {
19294 
19295  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19296  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19297  MALP_EVENT_MPI, _container.event.mpi_event.type );
19298  Event_Packer_push(&otf_event);
19299  }
19300 
19301  /********************************/
19302  /* ACTUAL FUNCTION CALL */
19303  /********************************/
19304 
19306  int ret = PMPI_Request_free( request );
19308 
19309  /********************************/
19310  /* EMIT OTF END */
19311  /********************************/
19312 
19313  uint64_t _end = Timer_tsc();
19314  uint64_t _duration = _end - _begin;
19315 
19317  {
19319  {
19320 
19321  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19322  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19323  MALP_EVENT_MPI, _container.event.mpi_event.type );
19324 
19325 
19326  Event_Packer_push(&otf_event);
19327  }
19328 
19329  /********************************/
19330  /* EMIT MALP EVENT */
19331  /********************************/
19332 
19333  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19334 
19335  /* Submit event if MPI instrumented */
19336  Event_Packer_push(&_container);
19337  }
19338 
19339 
19340  return ret;
19341 }
19342 int MPI_Request_get_status( MPI_Request request, int * flag, MPI_Status * status )
19343 {
19344 
19345  /* Virtualize MPI */
19346 
19347 
19348  /* Pre instrum */
19349  int _rank = Stream_desc_get()->mpi_rank;
19350 
19351  struct MALP_Trace_Event _container;
19352 
19353  /********************************/
19354  /* FILL MPI EVENT */
19355  /********************************/
19356 
19357  _container.event.mpi_event.type =
19358  T_MPI_ENUM(MPI_REQUEST_GET_STATUS)
19359  ;
19360 
19361  /* Set default source & dest before override */
19362  _container.event.mpi_event.source = _rank;
19363  _container.event.mpi_event.dest = _rank;
19364 
19365 
19366 
19367 
19368 
19369 
19370 
19371 
19372  /* Fill in size informations if needed */
19373  int _size = 0;
19374  #if 0
19375 
19376  #endif
19377  _container.event.mpi_event.size = _size;
19378 
19379  /********************************/
19380  /* EMIT OTF ENTER */
19381  /********************************/
19382 
19383  struct MALP_Trace_Event otf_event;
19384 
19385  uint64_t _begin = Timer_tsc ();
19386 
19389  {
19390 
19391  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19392  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19393  MALP_EVENT_MPI, _container.event.mpi_event.type );
19394  Event_Packer_push(&otf_event);
19395  }
19396 
19397  /********************************/
19398  /* ACTUAL FUNCTION CALL */
19399  /********************************/
19400 
19402  int ret = PMPI_Request_get_status( request, flag, status );
19404 
19405  /********************************/
19406  /* EMIT OTF END */
19407  /********************************/
19408 
19409  uint64_t _end = Timer_tsc();
19410  uint64_t _duration = _end - _begin;
19411 
19413  {
19415  {
19416 
19417  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19418  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19419  MALP_EVENT_MPI, _container.event.mpi_event.type );
19420 
19421 
19422  Event_Packer_push(&otf_event);
19423  }
19424 
19425  /********************************/
19426  /* EMIT MALP EVENT */
19427  /********************************/
19428 
19429  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19430 
19431  /* Submit event if MPI instrumented */
19432  Event_Packer_push(&_container);
19433  }
19434 
19435 
19436  return ret;
19437 }
19438 int MPI_Rsend( void * ibuf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
19439 {
19440 
19441  /* Virtualize MPI */
19442  MACRO_MPI_Comm (comm)
19443 
19444  /* Pre instrum */
19445  int _rank = Stream_desc_get()->mpi_rank;
19446 
19447  struct MALP_Trace_Event _container;
19448 
19449  /********************************/
19450  /* FILL MPI EVENT */
19451  /********************************/
19452 
19453  _container.event.mpi_event.type =
19454  T_MPI_ENUM(MPI_RSEND)
19455  ;
19456 
19457  /* Set default source & dest before override */
19458  _container.event.mpi_event.source = _rank;
19459  _container.event.mpi_event.dest = _rank;
19460 
19461 
19462  SET_DEST (dest)
19463  SET_TAG (tag)
19464  SET_COUNT (count)
19465  SET_DATATYPE (datatype)
19466  SET_COMM (comm)
19467 
19468  /* Fill in size informations if needed */
19469  int _size = 0;
19470  #if 1
19471  COMP_SIZE (count)
19472  #endif
19473  _container.event.mpi_event.size = _size;
19474 
19475  /********************************/
19476  /* EMIT OTF ENTER */
19477  /********************************/
19478 
19479  struct MALP_Trace_Event otf_event;
19480 
19481  uint64_t _begin = Timer_tsc ();
19482 
19485  {
19486 
19487  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19488  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19489  MALP_EVENT_MPI, _container.event.mpi_event.type );
19490  Event_Packer_push(&otf_event);
19491  }
19492 
19493  /********************************/
19494  /* ACTUAL FUNCTION CALL */
19495  /********************************/
19496 
19498  int ret = PMPI_Rsend( ibuf, count, datatype, dest, tag, comm );
19500 
19501  /********************************/
19502  /* EMIT OTF END */
19503  /********************************/
19504 
19505  uint64_t _end = Timer_tsc();
19506  uint64_t _duration = _end - _begin;
19507 
19509  {
19511  {
19512 
19513  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19514  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19515  MALP_EVENT_MPI, _container.event.mpi_event.type );
19516 
19517 
19518  Event_Packer_push(&otf_event);
19519  }
19520 
19521  /********************************/
19522  /* EMIT MALP EVENT */
19523  /********************************/
19524 
19525  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19526 
19527  /* Submit event if MPI instrumented */
19528  Event_Packer_push(&_container);
19529  }
19530 
19531 
19532  return ret;
19533 }
19534 int MPI_Rsend_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
19535 {
19536 
19537  /* Virtualize MPI */
19538  MACRO_MPI_Comm (comm)
19539 
19540  /* Pre instrum */
19541  int _rank = Stream_desc_get()->mpi_rank;
19542 
19543  struct MALP_Trace_Event _container;
19544 
19545  /********************************/
19546  /* FILL MPI EVENT */
19547  /********************************/
19548 
19549  _container.event.mpi_event.type =
19550  T_MPI_ENUM(MPI_RSEND_INIT)
19551  ;
19552 
19553  /* Set default source & dest before override */
19554  _container.event.mpi_event.source = _rank;
19555  _container.event.mpi_event.dest = _rank;
19556 
19557 
19558  SET_DEST (dest)
19559  SET_TAG (tag)
19560  SET_COUNT (count)
19561  SET_DATATYPE (datatype)
19562  SET_COMM (comm)
19563 
19564  /* Fill in size informations if needed */
19565  int _size = 0;
19566  #if 1
19567  COMP_SIZE (count)
19568  #endif
19569  _container.event.mpi_event.size = _size;
19570 
19571  /********************************/
19572  /* EMIT OTF ENTER */
19573  /********************************/
19574 
19575  struct MALP_Trace_Event otf_event;
19576 
19577  uint64_t _begin = Timer_tsc ();
19578 
19581  {
19582 
19583  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19584  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19585  MALP_EVENT_MPI, _container.event.mpi_event.type );
19586  Event_Packer_push(&otf_event);
19587  }
19588 
19589  /********************************/
19590  /* ACTUAL FUNCTION CALL */
19591  /********************************/
19592 
19594  int ret = PMPI_Rsend_init( buf, count, datatype, dest, tag, comm, request );
19596 
19597  /********************************/
19598  /* EMIT OTF END */
19599  /********************************/
19600 
19601  uint64_t _end = Timer_tsc();
19602  uint64_t _duration = _end - _begin;
19603 
19605  {
19607  {
19608 
19609  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19610  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19611  MALP_EVENT_MPI, _container.event.mpi_event.type );
19612 
19613 
19614  Event_Packer_push(&otf_event);
19615  }
19616 
19617  /********************************/
19618  /* EMIT MALP EVENT */
19619  /********************************/
19620 
19621  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19622 
19623  /* Submit event if MPI instrumented */
19624  Event_Packer_push(&_container);
19625  }
19626 
19627 
19628  return ret;
19629 }
19630 int MPI_Scan( void * sendbuf, void * recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm )
19631 {
19632 
19633  /* Virtualize MPI */
19634  MACRO_MPI_Comm (comm)
19635 
19636  /* Pre instrum */
19637  int _rank = Stream_desc_get()->mpi_rank;
19638 
19639  struct MALP_Trace_Event _container;
19640 
19641  /********************************/
19642  /* FILL MPI EVENT */
19643  /********************************/
19644 
19645  _container.event.mpi_event.type =
19646  T_MPI_ENUM(MPI_SCAN)
19647  ;
19648 
19649  /* Set default source & dest before override */
19650  _container.event.mpi_event.source = _rank;
19651  _container.event.mpi_event.dest = _rank;
19652 
19653 
19654 
19655 
19656  SET_COUNT (count)
19657  SET_DATATYPE (datatype)
19658  SET_COMM (comm)
19659 
19660  /* Fill in size informations if needed */
19661  int _size = 0;
19662  #if 1
19663  COMP_SIZE (count)
19664  #endif
19665  _container.event.mpi_event.size = _size;
19666 
19667  /********************************/
19668  /* EMIT OTF ENTER */
19669  /********************************/
19670 
19671  struct MALP_Trace_Event otf_event;
19672 
19673  uint64_t _begin = Timer_tsc ();
19674 
19677  {
19678 
19679  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19680  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19681  MALP_EVENT_MPI, _container.event.mpi_event.type );
19682  Event_Packer_push(&otf_event);
19683  }
19684 
19685  /********************************/
19686  /* ACTUAL FUNCTION CALL */
19687  /********************************/
19688 
19690  int ret = PMPI_Scan( sendbuf, recvbuf, count, datatype, op, comm );
19692 
19693  /********************************/
19694  /* EMIT OTF END */
19695  /********************************/
19696 
19697  uint64_t _end = Timer_tsc();
19698  uint64_t _duration = _end - _begin;
19699 
19701  {
19703  {
19704 
19705  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19706  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19707  MALP_EVENT_MPI, _container.event.mpi_event.type );
19708 
19709 
19710  Event_Packer_push(&otf_event);
19711  }
19712 
19713  /********************************/
19714  /* EMIT MALP EVENT */
19715  /********************************/
19716 
19717  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19718 
19719  /* Submit event if MPI instrumented */
19720  Event_Packer_push(&_container);
19721  }
19722 
19723 
19724  return ret;
19725 }
19726 int MPI_Scatter( void * sendbuf, int sendcount, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm )
19727 {
19728 
19729  /* Virtualize MPI */
19730  MACRO_MPI_Comm (comm)
19731 
19732  /* Pre instrum */
19733  int _rank = Stream_desc_get()->mpi_rank;
19734 
19735  struct MALP_Trace_Event _container;
19736 
19737  /********************************/
19738  /* FILL MPI EVENT */
19739  /********************************/
19740 
19741  _container.event.mpi_event.type =
19742  T_MPI_ENUM(MPI_SCATTER)
19743  ;
19744 
19745  /* Set default source & dest before override */
19746  _container.event.mpi_event.source = _rank;
19747  _container.event.mpi_event.dest = _rank;
19748 
19749 
19750 
19751 
19752 
19753 
19754  SET_COMM (comm)
19755 
19756  /* Fill in size informations if needed */
19757  int _size = 0;
19758  #if 0
19759 
19760  #endif
19761  _container.event.mpi_event.size = _size;
19762 
19763  /********************************/
19764  /* EMIT OTF ENTER */
19765  /********************************/
19766 
19767  struct MALP_Trace_Event otf_event;
19768 
19769  uint64_t _begin = Timer_tsc ();
19770 
19773  {
19774 
19775  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19776  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19777  MALP_EVENT_MPI, _container.event.mpi_event.type );
19778  Event_Packer_push(&otf_event);
19779  }
19780 
19781  /********************************/
19782  /* ACTUAL FUNCTION CALL */
19783  /********************************/
19784 
19786  int ret = PMPI_Scatter( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm );
19788 
19789  /********************************/
19790  /* EMIT OTF END */
19791  /********************************/
19792 
19793  uint64_t _end = Timer_tsc();
19794  uint64_t _duration = _end - _begin;
19795 
19797  {
19799  {
19800 
19801  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19802  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19803  MALP_EVENT_MPI, _container.event.mpi_event.type );
19804 
19805 
19806  Event_Packer_push(&otf_event);
19807  }
19808 
19809  /********************************/
19810  /* EMIT MALP EVENT */
19811  /********************************/
19812 
19813  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19814 
19815  /* Submit event if MPI instrumented */
19816  Event_Packer_push(&_container);
19817  }
19818 
19819 
19820  return ret;
19821 }
19822 int MPI_Scatterv( void * sendbuf, int * sendcounts, int * displs, MPI_Datatype sendtype, void * recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm )
19823 {
19824 
19825  /* Virtualize MPI */
19826  MACRO_MPI_Comm (comm)
19827 
19828  /* Pre instrum */
19829  int _rank = Stream_desc_get()->mpi_rank;
19830 
19831  struct MALP_Trace_Event _container;
19832 
19833  /********************************/
19834  /* FILL MPI EVENT */
19835  /********************************/
19836 
19837  _container.event.mpi_event.type =
19838  T_MPI_ENUM(MPI_SCATTERV)
19839  ;
19840 
19841  /* Set default source & dest before override */
19842  _container.event.mpi_event.source = _rank;
19843  _container.event.mpi_event.dest = _rank;
19844 
19845 
19846 
19847 
19848 
19849 
19850  SET_COMM (comm)
19851 
19852  /* Fill in size informations if needed */
19853  int _size = 0;
19854  #if 0
19855 
19856  #endif
19857  _container.event.mpi_event.size = _size;
19858 
19859  /********************************/
19860  /* EMIT OTF ENTER */
19861  /********************************/
19862 
19863  struct MALP_Trace_Event otf_event;
19864 
19865  uint64_t _begin = Timer_tsc ();
19866 
19869  {
19870 
19871  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19872  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19873  MALP_EVENT_MPI, _container.event.mpi_event.type );
19874  Event_Packer_push(&otf_event);
19875  }
19876 
19877  /********************************/
19878  /* ACTUAL FUNCTION CALL */
19879  /********************************/
19880 
19882  int ret = PMPI_Scatterv( sendbuf, sendcounts, displs, sendtype, recvbuf, recvcount, recvtype, root, comm );
19884 
19885  /********************************/
19886  /* EMIT OTF END */
19887  /********************************/
19888 
19889  uint64_t _end = Timer_tsc();
19890  uint64_t _duration = _end - _begin;
19891 
19893  {
19895  {
19896 
19897  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19898  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19899  MALP_EVENT_MPI, _container.event.mpi_event.type );
19900 
19901 
19902  Event_Packer_push(&otf_event);
19903  }
19904 
19905  /********************************/
19906  /* EMIT MALP EVENT */
19907  /********************************/
19908 
19909  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
19910 
19911  /* Submit event if MPI instrumented */
19912  Event_Packer_push(&_container);
19913  }
19914 
19915 
19916  return ret;
19917 }
19918 int MPI_Send_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
19919 {
19920 
19921  /* Virtualize MPI */
19922  MACRO_MPI_Comm (comm)
19923 
19924  /* Pre instrum */
19925  int _rank = Stream_desc_get()->mpi_rank;
19926 
19927  struct MALP_Trace_Event _container;
19928 
19929  /********************************/
19930  /* FILL MPI EVENT */
19931  /********************************/
19932 
19933  _container.event.mpi_event.type =
19934  T_MPI_ENUM(MPI_SEND_INIT)
19935  ;
19936 
19937  /* Set default source & dest before override */
19938  _container.event.mpi_event.source = _rank;
19939  _container.event.mpi_event.dest = _rank;
19940 
19941 
19942  SET_DEST (dest)
19943  SET_TAG (tag)
19944  SET_COUNT (count)
19945  SET_DATATYPE (datatype)
19946  SET_COMM (comm)
19947 
19948  /* Fill in size informations if needed */
19949  int _size = 0;
19950  #if 1
19951  COMP_SIZE (count)
19952  #endif
19953  _container.event.mpi_event.size = _size;
19954 
19955  /********************************/
19956  /* EMIT OTF ENTER */
19957  /********************************/
19958 
19959  struct MALP_Trace_Event otf_event;
19960 
19961  uint64_t _begin = Timer_tsc ();
19962 
19965  {
19966 
19967  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
19968  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
19969  MALP_EVENT_MPI, _container.event.mpi_event.type );
19970  Event_Packer_push(&otf_event);
19971  }
19972 
19973  /********************************/
19974  /* ACTUAL FUNCTION CALL */
19975  /********************************/
19976 
19978  int ret = PMPI_Send_init( buf, count, datatype, dest, tag, comm, request );
19980 
19981  /********************************/
19982  /* EMIT OTF END */
19983  /********************************/
19984 
19985  uint64_t _end = Timer_tsc();
19986  uint64_t _duration = _end - _begin;
19987 
19989  {
19991  {
19992 
19993  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
19994  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
19995  MALP_EVENT_MPI, _container.event.mpi_event.type );
19996 
19997 
19998  Event_Packer_push(&otf_event);
19999  }
20000 
20001  /********************************/
20002  /* EMIT MALP EVENT */
20003  /********************************/
20004 
20005  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20006 
20007  /* Submit event if MPI instrumented */
20008  Event_Packer_push(&_container);
20009  }
20010 
20011 
20012  return ret;
20013 }
20014 int MPI_Send( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
20015 {
20016 
20017  /* Virtualize MPI */
20018  MACRO_MPI_Comm (comm)
20019 
20020  /* Pre instrum */
20021  int _rank = Stream_desc_get()->mpi_rank;
20022 
20023  struct MALP_Trace_Event _container;
20024 
20025  /********************************/
20026  /* FILL MPI EVENT */
20027  /********************************/
20028 
20029  _container.event.mpi_event.type =
20030  T_MPI_ENUM(MPI_SEND)
20031  ;
20032 
20033  /* Set default source & dest before override */
20034  _container.event.mpi_event.source = _rank;
20035  _container.event.mpi_event.dest = _rank;
20036 
20037 
20038  SET_DEST (dest)
20039  SET_TAG (tag)
20040  SET_COUNT (count)
20041  SET_DATATYPE (datatype)
20042  SET_COMM (comm)
20043 
20044  /* Fill in size informations if needed */
20045  int _size = 0;
20046  #if 1
20047  COMP_SIZE (count)
20048  #endif
20049  _container.event.mpi_event.size = _size;
20050 
20051  /********************************/
20052  /* EMIT OTF ENTER */
20053  /********************************/
20054 
20055  struct MALP_Trace_Event otf_event;
20056 
20057  uint64_t _begin = Timer_tsc ();
20058 
20061  {
20062 
20063  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20064  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20065  MALP_EVENT_MPI, _container.event.mpi_event.type );
20066  Event_Packer_push(&otf_event);
20067  }
20068 
20069  /********************************/
20070  /* ACTUAL FUNCTION CALL */
20071  /********************************/
20072 
20074  int ret = PMPI_Send( buf, count, datatype, dest, tag, comm );
20076 
20077  /********************************/
20078  /* EMIT OTF END */
20079  /********************************/
20080 
20081  uint64_t _end = Timer_tsc();
20082  uint64_t _duration = _end - _begin;
20083 
20085  {
20087  {
20088 
20089  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20090  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20091  MALP_EVENT_MPI, _container.event.mpi_event.type );
20092 
20093 
20094  Event_Packer_push(&otf_event);
20095  }
20096 
20097  /********************************/
20098  /* EMIT MALP EVENT */
20099  /********************************/
20100 
20101  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20102 
20103  /* Submit event if MPI instrumented */
20104  Event_Packer_push(&_container);
20105  }
20106 
20107 
20108  return ret;
20109 }
20110 int MPI_Sendrecv( void * sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, void * recvbuf, int recvcount, MPI_Datatype recvtype, int source, int recvtag, MPI_Comm comm, MPI_Status * status )
20111 {
20112 
20113  /* Virtualize MPI */
20114  MACRO_MPI_Comm (comm)
20115 
20116  /* Pre instrum */
20117  int _rank = Stream_desc_get()->mpi_rank;
20118 
20119  struct MALP_Trace_Event _container;
20120 
20121  /********************************/
20122  /* FILL MPI EVENT */
20123  /********************************/
20124 
20125  _container.event.mpi_event.type =
20126  T_MPI_ENUM(MPI_SENDRECV)
20127  ;
20128 
20129  /* Set default source & dest before override */
20130  _container.event.mpi_event.source = _rank;
20131  _container.event.mpi_event.dest = _rank;
20132 
20133  SET_SOURCE (source)
20134  SET_DEST (dest)
20135 
20136 
20137 
20138  SET_COMM (comm)
20139 
20140  /* Fill in size informations if needed */
20141  int _size = 0;
20142  #if 0
20143 
20144  #endif
20145  _container.event.mpi_event.size = _size;
20146 
20147  /********************************/
20148  /* EMIT OTF ENTER */
20149  /********************************/
20150 
20151  struct MALP_Trace_Event otf_event;
20152 
20153  uint64_t _begin = Timer_tsc ();
20154 
20157  {
20158 
20159  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20160  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20161  MALP_EVENT_MPI, _container.event.mpi_event.type );
20162  Event_Packer_push(&otf_event);
20163  }
20164 
20165  /********************************/
20166  /* ACTUAL FUNCTION CALL */
20167  /********************************/
20168 
20170  int ret = PMPI_Sendrecv( sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status );
20172 
20173  /********************************/
20174  /* EMIT OTF END */
20175  /********************************/
20176 
20177  uint64_t _end = Timer_tsc();
20178  uint64_t _duration = _end - _begin;
20179 
20181  {
20183  {
20184 
20185  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20186  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20187  MALP_EVENT_MPI, _container.event.mpi_event.type );
20188 
20189 
20190  Event_Packer_push(&otf_event);
20191  }
20192 
20193  /********************************/
20194  /* EMIT MALP EVENT */
20195  /********************************/
20196 
20197  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20198 
20199  /* Submit event if MPI instrumented */
20200  Event_Packer_push(&_container);
20201  }
20202 
20203 
20204  return ret;
20205 }
20206 int MPI_Sendrecv_replace( void * buf, int count, MPI_Datatype datatype, int dest, int sendtag, int source, int recvtag, MPI_Comm comm, MPI_Status * status )
20207 {
20208 
20209  /* Virtualize MPI */
20210  MACRO_MPI_Comm (comm)
20211 
20212  /* Pre instrum */
20213  int _rank = Stream_desc_get()->mpi_rank;
20214 
20215  struct MALP_Trace_Event _container;
20216 
20217  /********************************/
20218  /* FILL MPI EVENT */
20219  /********************************/
20220 
20221  _container.event.mpi_event.type =
20222  T_MPI_ENUM(MPI_SENDRECV_REPLACE)
20223  ;
20224 
20225  /* Set default source & dest before override */
20226  _container.event.mpi_event.source = _rank;
20227  _container.event.mpi_event.dest = _rank;
20228 
20229  SET_SOURCE (source)
20230  SET_DEST (dest)
20231 
20232  SET_COUNT (count)
20233  SET_DATATYPE (datatype)
20234  SET_COMM (comm)
20235 
20236  /* Fill in size informations if needed */
20237  int _size = 0;
20238  #if 1
20239  COMP_SIZE (count)
20240  #endif
20241  _container.event.mpi_event.size = _size;
20242 
20243  /********************************/
20244  /* EMIT OTF ENTER */
20245  /********************************/
20246 
20247  struct MALP_Trace_Event otf_event;
20248 
20249  uint64_t _begin = Timer_tsc ();
20250 
20253  {
20254 
20255  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20256  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20257  MALP_EVENT_MPI, _container.event.mpi_event.type );
20258  Event_Packer_push(&otf_event);
20259  }
20260 
20261  /********************************/
20262  /* ACTUAL FUNCTION CALL */
20263  /********************************/
20264 
20266  int ret = PMPI_Sendrecv_replace( buf, count, datatype, dest, sendtag, source, recvtag, comm, status );
20268 
20269  /********************************/
20270  /* EMIT OTF END */
20271  /********************************/
20272 
20273  uint64_t _end = Timer_tsc();
20274  uint64_t _duration = _end - _begin;
20275 
20277  {
20279  {
20280 
20281  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20282  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20283  MALP_EVENT_MPI, _container.event.mpi_event.type );
20284 
20285 
20286  Event_Packer_push(&otf_event);
20287  }
20288 
20289  /********************************/
20290  /* EMIT MALP EVENT */
20291  /********************************/
20292 
20293  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20294 
20295  /* Submit event if MPI instrumented */
20296  Event_Packer_push(&_container);
20297  }
20298 
20299 
20300  return ret;
20301 }
20302 int MPI_Ssend_init( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request * request )
20303 {
20304 
20305  /* Virtualize MPI */
20306  MACRO_MPI_Comm (comm)
20307 
20308  /* Pre instrum */
20309  int _rank = Stream_desc_get()->mpi_rank;
20310 
20311  struct MALP_Trace_Event _container;
20312 
20313  /********************************/
20314  /* FILL MPI EVENT */
20315  /********************************/
20316 
20317  _container.event.mpi_event.type =
20318  T_MPI_ENUM(MPI_SSEND_INIT)
20319  ;
20320 
20321  /* Set default source & dest before override */
20322  _container.event.mpi_event.source = _rank;
20323  _container.event.mpi_event.dest = _rank;
20324 
20325 
20326  SET_DEST (dest)
20327  SET_TAG (tag)
20328  SET_COUNT (count)
20329  SET_DATATYPE (datatype)
20330  SET_COMM (comm)
20331 
20332  /* Fill in size informations if needed */
20333  int _size = 0;
20334  #if 1
20335  COMP_SIZE (count)
20336  #endif
20337  _container.event.mpi_event.size = _size;
20338 
20339  /********************************/
20340  /* EMIT OTF ENTER */
20341  /********************************/
20342 
20343  struct MALP_Trace_Event otf_event;
20344 
20345  uint64_t _begin = Timer_tsc ();
20346 
20349  {
20350 
20351  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20352  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20353  MALP_EVENT_MPI, _container.event.mpi_event.type );
20354  Event_Packer_push(&otf_event);
20355  }
20356 
20357  /********************************/
20358  /* ACTUAL FUNCTION CALL */
20359  /********************************/
20360 
20362  int ret = PMPI_Ssend_init( buf, count, datatype, dest, tag, comm, request );
20364 
20365  /********************************/
20366  /* EMIT OTF END */
20367  /********************************/
20368 
20369  uint64_t _end = Timer_tsc();
20370  uint64_t _duration = _end - _begin;
20371 
20373  {
20375  {
20376 
20377  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20378  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20379  MALP_EVENT_MPI, _container.event.mpi_event.type );
20380 
20381 
20382  Event_Packer_push(&otf_event);
20383  }
20384 
20385  /********************************/
20386  /* EMIT MALP EVENT */
20387  /********************************/
20388 
20389  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20390 
20391  /* Submit event if MPI instrumented */
20392  Event_Packer_push(&_container);
20393  }
20394 
20395 
20396  return ret;
20397 }
20398 int MPI_Ssend( void * buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm )
20399 {
20400 
20401  /* Virtualize MPI */
20402  MACRO_MPI_Comm (comm)
20403 
20404  /* Pre instrum */
20405  int _rank = Stream_desc_get()->mpi_rank;
20406 
20407  struct MALP_Trace_Event _container;
20408 
20409  /********************************/
20410  /* FILL MPI EVENT */
20411  /********************************/
20412 
20413  _container.event.mpi_event.type =
20414  T_MPI_ENUM(MPI_SSEND)
20415  ;
20416 
20417  /* Set default source & dest before override */
20418  _container.event.mpi_event.source = _rank;
20419  _container.event.mpi_event.dest = _rank;
20420 
20421 
20422  SET_DEST (dest)
20423  SET_TAG (tag)
20424  SET_COUNT (count)
20425  SET_DATATYPE (datatype)
20426  SET_COMM (comm)
20427 
20428  /* Fill in size informations if needed */
20429  int _size = 0;
20430  #if 1
20431  COMP_SIZE (count)
20432  #endif
20433  _container.event.mpi_event.size = _size;
20434 
20435  /********************************/
20436  /* EMIT OTF ENTER */
20437  /********************************/
20438 
20439  struct MALP_Trace_Event otf_event;
20440 
20441  uint64_t _begin = Timer_tsc ();
20442 
20445  {
20446 
20447  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20448  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20449  MALP_EVENT_MPI, _container.event.mpi_event.type );
20450  Event_Packer_push(&otf_event);
20451  }
20452 
20453  /********************************/
20454  /* ACTUAL FUNCTION CALL */
20455  /********************************/
20456 
20458  int ret = PMPI_Ssend( buf, count, datatype, dest, tag, comm );
20460 
20461  /********************************/
20462  /* EMIT OTF END */
20463  /********************************/
20464 
20465  uint64_t _end = Timer_tsc();
20466  uint64_t _duration = _end - _begin;
20467 
20469  {
20471  {
20472 
20473  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20474  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20475  MALP_EVENT_MPI, _container.event.mpi_event.type );
20476 
20477 
20478  Event_Packer_push(&otf_event);
20479  }
20480 
20481  /********************************/
20482  /* EMIT MALP EVENT */
20483  /********************************/
20484 
20485  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20486 
20487  /* Submit event if MPI instrumented */
20488  Event_Packer_push(&_container);
20489  }
20490 
20491 
20492  return ret;
20493 }
20494 int MPI_Start( MPI_Request * request )
20495 {
20496 
20497  /* Virtualize MPI */
20498 
20499 
20500  /* Pre instrum */
20501  int _rank = Stream_desc_get()->mpi_rank;
20502 
20503  struct MALP_Trace_Event _container;
20504 
20505  /********************************/
20506  /* FILL MPI EVENT */
20507  /********************************/
20508 
20509  _container.event.mpi_event.type =
20510  T_MPI_ENUM(MPI_START)
20511  ;
20512 
20513  /* Set default source & dest before override */
20514  _container.event.mpi_event.source = _rank;
20515  _container.event.mpi_event.dest = _rank;
20516 
20517 
20518 
20519 
20520 
20521 
20522 
20523 
20524  /* Fill in size informations if needed */
20525  int _size = 0;
20526  #if 0
20527 
20528  #endif
20529  _container.event.mpi_event.size = _size;
20530 
20531  /********************************/
20532  /* EMIT OTF ENTER */
20533  /********************************/
20534 
20535  struct MALP_Trace_Event otf_event;
20536 
20537  uint64_t _begin = Timer_tsc ();
20538 
20541  {
20542 
20543  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20544  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20545  MALP_EVENT_MPI, _container.event.mpi_event.type );
20546  Event_Packer_push(&otf_event);
20547  }
20548 
20549  /********************************/
20550  /* ACTUAL FUNCTION CALL */
20551  /********************************/
20552 
20554  int ret = PMPI_Start( request );
20556 
20557  /********************************/
20558  /* EMIT OTF END */
20559  /********************************/
20560 
20561  uint64_t _end = Timer_tsc();
20562  uint64_t _duration = _end - _begin;
20563 
20565  {
20567  {
20568 
20569  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20570  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20571  MALP_EVENT_MPI, _container.event.mpi_event.type );
20572 
20573 
20574  Event_Packer_push(&otf_event);
20575  }
20576 
20577  /********************************/
20578  /* EMIT MALP EVENT */
20579  /********************************/
20580 
20581  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20582 
20583  /* Submit event if MPI instrumented */
20584  Event_Packer_push(&_container);
20585  }
20586 
20587 
20588  return ret;
20589 }
20590 int MPI_Startall( int count, MPI_Request * array_of_requests )
20591 {
20592 
20593  /* Virtualize MPI */
20594 
20595 
20596  /* Pre instrum */
20597  int _rank = Stream_desc_get()->mpi_rank;
20598 
20599  struct MALP_Trace_Event _container;
20600 
20601  /********************************/
20602  /* FILL MPI EVENT */
20603  /********************************/
20604 
20605  _container.event.mpi_event.type =
20606  T_MPI_ENUM(MPI_STARTALL)
20607  ;
20608 
20609  /* Set default source & dest before override */
20610  _container.event.mpi_event.source = _rank;
20611  _container.event.mpi_event.dest = _rank;
20612 
20613 
20614 
20615 
20616  SET_COUNT (count)
20617 
20618 
20619 
20620  /* Fill in size informations if needed */
20621  int _size = 0;
20622  #if 0
20623  COMP_SIZE (count)
20624  #endif
20625  _container.event.mpi_event.size = _size;
20626 
20627  /********************************/
20628  /* EMIT OTF ENTER */
20629  /********************************/
20630 
20631  struct MALP_Trace_Event otf_event;
20632 
20633  uint64_t _begin = Timer_tsc ();
20634 
20637  {
20638 
20639  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20640  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20641  MALP_EVENT_MPI, _container.event.mpi_event.type );
20642  Event_Packer_push(&otf_event);
20643  }
20644 
20645  /********************************/
20646  /* ACTUAL FUNCTION CALL */
20647  /********************************/
20648 
20650  int ret = PMPI_Startall( count, array_of_requests );
20652 
20653  /********************************/
20654  /* EMIT OTF END */
20655  /********************************/
20656 
20657  uint64_t _end = Timer_tsc();
20658  uint64_t _duration = _end - _begin;
20659 
20661  {
20663  {
20664 
20665  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20666  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20667  MALP_EVENT_MPI, _container.event.mpi_event.type );
20668 
20669 
20670  Event_Packer_push(&otf_event);
20671  }
20672 
20673  /********************************/
20674  /* EMIT MALP EVENT */
20675  /********************************/
20676 
20677  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20678 
20679  /* Submit event if MPI instrumented */
20680  Event_Packer_push(&_container);
20681  }
20682 
20683 
20684  return ret;
20685 }
20686 int MPI_Status_c2f( MPI_Status * c_status, int * f_status )
20687 {
20688 
20689  /* Virtualize MPI */
20690 
20691 
20692  /* Pre instrum */
20693  int _rank = Stream_desc_get()->mpi_rank;
20694 
20695  struct MALP_Trace_Event _container;
20696 
20697  /********************************/
20698  /* FILL MPI EVENT */
20699  /********************************/
20700 
20701  _container.event.mpi_event.type =
20702  T_MPI_ENUM(MPI_STATUS_C2F)
20703  ;
20704 
20705  /* Set default source & dest before override */
20706  _container.event.mpi_event.source = _rank;
20707  _container.event.mpi_event.dest = _rank;
20708 
20709 
20710 
20711 
20712 
20713 
20714 
20715 
20716  /* Fill in size informations if needed */
20717  int _size = 0;
20718  #if 0
20719 
20720  #endif
20721  _container.event.mpi_event.size = _size;
20722 
20723  /********************************/
20724  /* EMIT OTF ENTER */
20725  /********************************/
20726 
20727  struct MALP_Trace_Event otf_event;
20728 
20729  uint64_t _begin = Timer_tsc ();
20730 
20733  {
20734 
20735  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20736  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20737  MALP_EVENT_MPI, _container.event.mpi_event.type );
20738  Event_Packer_push(&otf_event);
20739  }
20740 
20741  /********************************/
20742  /* ACTUAL FUNCTION CALL */
20743  /********************************/
20744 
20746  int ret = PMPI_Status_c2f( c_status, f_status );
20748 
20749  /********************************/
20750  /* EMIT OTF END */
20751  /********************************/
20752 
20753  uint64_t _end = Timer_tsc();
20754  uint64_t _duration = _end - _begin;
20755 
20757  {
20759  {
20760 
20761  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20762  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20763  MALP_EVENT_MPI, _container.event.mpi_event.type );
20764 
20765 
20766  Event_Packer_push(&otf_event);
20767  }
20768 
20769  /********************************/
20770  /* EMIT MALP EVENT */
20771  /********************************/
20772 
20773  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20774 
20775  /* Submit event if MPI instrumented */
20776  Event_Packer_push(&_container);
20777  }
20778 
20779 
20780  return ret;
20781 }
20782 int MPI_Status_f2c( int * f_status, MPI_Status * c_status )
20783 {
20784 
20785  /* Virtualize MPI */
20786 
20787 
20788  /* Pre instrum */
20789  int _rank = Stream_desc_get()->mpi_rank;
20790 
20791  struct MALP_Trace_Event _container;
20792 
20793  /********************************/
20794  /* FILL MPI EVENT */
20795  /********************************/
20796 
20797  _container.event.mpi_event.type =
20798  T_MPI_ENUM(MPI_STATUS_F2C)
20799  ;
20800 
20801  /* Set default source & dest before override */
20802  _container.event.mpi_event.source = _rank;
20803  _container.event.mpi_event.dest = _rank;
20804 
20805 
20806 
20807 
20808 
20809 
20810 
20811 
20812  /* Fill in size informations if needed */
20813  int _size = 0;
20814  #if 0
20815 
20816  #endif
20817  _container.event.mpi_event.size = _size;
20818 
20819  /********************************/
20820  /* EMIT OTF ENTER */
20821  /********************************/
20822 
20823  struct MALP_Trace_Event otf_event;
20824 
20825  uint64_t _begin = Timer_tsc ();
20826 
20829  {
20830 
20831  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20832  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20833  MALP_EVENT_MPI, _container.event.mpi_event.type );
20834  Event_Packer_push(&otf_event);
20835  }
20836 
20837  /********************************/
20838  /* ACTUAL FUNCTION CALL */
20839  /********************************/
20840 
20842  int ret = PMPI_Status_f2c( f_status, c_status );
20844 
20845  /********************************/
20846  /* EMIT OTF END */
20847  /********************************/
20848 
20849  uint64_t _end = Timer_tsc();
20850  uint64_t _duration = _end - _begin;
20851 
20853  {
20855  {
20856 
20857  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20858  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20859  MALP_EVENT_MPI, _container.event.mpi_event.type );
20860 
20861 
20862  Event_Packer_push(&otf_event);
20863  }
20864 
20865  /********************************/
20866  /* EMIT MALP EVENT */
20867  /********************************/
20868 
20869  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20870 
20871  /* Submit event if MPI instrumented */
20872  Event_Packer_push(&_container);
20873  }
20874 
20875 
20876  return ret;
20877 }
20878 int MPI_Status_set_cancelled( MPI_Status * status, int flag )
20879 {
20880 
20881  /* Virtualize MPI */
20882 
20883 
20884  /* Pre instrum */
20885  int _rank = Stream_desc_get()->mpi_rank;
20886 
20887  struct MALP_Trace_Event _container;
20888 
20889  /********************************/
20890  /* FILL MPI EVENT */
20891  /********************************/
20892 
20893  _container.event.mpi_event.type =
20894  T_MPI_ENUM(MPI_STATUS_SET_CANCELLED)
20895  ;
20896 
20897  /* Set default source & dest before override */
20898  _container.event.mpi_event.source = _rank;
20899  _container.event.mpi_event.dest = _rank;
20900 
20901 
20902 
20903 
20904 
20905 
20906 
20907 
20908  /* Fill in size informations if needed */
20909  int _size = 0;
20910  #if 0
20911 
20912  #endif
20913  _container.event.mpi_event.size = _size;
20914 
20915  /********************************/
20916  /* EMIT OTF ENTER */
20917  /********************************/
20918 
20919  struct MALP_Trace_Event otf_event;
20920 
20921  uint64_t _begin = Timer_tsc ();
20922 
20925  {
20926 
20927  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
20928  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
20929  MALP_EVENT_MPI, _container.event.mpi_event.type );
20930  Event_Packer_push(&otf_event);
20931  }
20932 
20933  /********************************/
20934  /* ACTUAL FUNCTION CALL */
20935  /********************************/
20936 
20938  int ret = PMPI_Status_set_cancelled( status, flag );
20940 
20941  /********************************/
20942  /* EMIT OTF END */
20943  /********************************/
20944 
20945  uint64_t _end = Timer_tsc();
20946  uint64_t _duration = _end - _begin;
20947 
20949  {
20951  {
20952 
20953  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
20954  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
20955  MALP_EVENT_MPI, _container.event.mpi_event.type );
20956 
20957 
20958  Event_Packer_push(&otf_event);
20959  }
20960 
20961  /********************************/
20962  /* EMIT MALP EVENT */
20963  /********************************/
20964 
20965  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
20966 
20967  /* Submit event if MPI instrumented */
20968  Event_Packer_push(&_container);
20969  }
20970 
20971 
20972  return ret;
20973 }
20974 int MPI_Status_set_elements( MPI_Status * status, MPI_Datatype datatype, int count )
20975 {
20976 
20977  /* Virtualize MPI */
20978 
20979 
20980  /* Pre instrum */
20981  int _rank = Stream_desc_get()->mpi_rank;
20982 
20983  struct MALP_Trace_Event _container;
20984 
20985  /********************************/
20986  /* FILL MPI EVENT */
20987  /********************************/
20988 
20989  _container.event.mpi_event.type =
20990  T_MPI_ENUM(MPI_STATUS_SET_ELEMENTS)
20991  ;
20992 
20993  /* Set default source & dest before override */
20994  _container.event.mpi_event.source = _rank;
20995  _container.event.mpi_event.dest = _rank;
20996 
20997 
20998 
20999 
21000  SET_COUNT (count)
21001  SET_DATATYPE (datatype)
21002 
21003 
21004  /* Fill in size informations if needed */
21005  int _size = 0;
21006  #if 1
21007  COMP_SIZE (count)
21008  #endif
21009  _container.event.mpi_event.size = _size;
21010 
21011  /********************************/
21012  /* EMIT OTF ENTER */
21013  /********************************/
21014 
21015  struct MALP_Trace_Event otf_event;
21016 
21017  uint64_t _begin = Timer_tsc ();
21018 
21021  {
21022 
21023  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21024  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21025  MALP_EVENT_MPI, _container.event.mpi_event.type );
21026  Event_Packer_push(&otf_event);
21027  }
21028 
21029  /********************************/
21030  /* ACTUAL FUNCTION CALL */
21031  /********************************/
21032 
21034  int ret = PMPI_Status_set_elements( status, datatype, count );
21036 
21037  /********************************/
21038  /* EMIT OTF END */
21039  /********************************/
21040 
21041  uint64_t _end = Timer_tsc();
21042  uint64_t _duration = _end - _begin;
21043 
21045  {
21047  {
21048 
21049  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21050  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21051  MALP_EVENT_MPI, _container.event.mpi_event.type );
21052 
21053 
21054  Event_Packer_push(&otf_event);
21055  }
21056 
21057  /********************************/
21058  /* EMIT MALP EVENT */
21059  /********************************/
21060 
21061  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21062 
21063  /* Submit event if MPI instrumented */
21064  Event_Packer_push(&_container);
21065  }
21066 
21067 
21068  return ret;
21069 }
21070 int MPI_Testall( int count, MPI_Request array_of_requests[], int * flag, MPI_Status array_of_statuses[] )
21071 {
21072 
21073  /* Virtualize MPI */
21074 
21075 
21076  /* Pre instrum */
21077  int _rank = Stream_desc_get()->mpi_rank;
21078 
21079  struct MALP_Trace_Event _container;
21080 
21081  /********************************/
21082  /* FILL MPI EVENT */
21083  /********************************/
21084 
21085  _container.event.mpi_event.type =
21086  T_MPI_ENUM(MPI_TESTALL)
21087  ;
21088 
21089  /* Set default source & dest before override */
21090  _container.event.mpi_event.source = _rank;
21091  _container.event.mpi_event.dest = _rank;
21092 
21093 
21094 
21095 
21096  SET_COUNT (count)
21097 
21098 
21099 
21100  /* Fill in size informations if needed */
21101  int _size = 0;
21102  #if 0
21103  COMP_SIZE (count)
21104  #endif
21105  _container.event.mpi_event.size = _size;
21106 
21107  /********************************/
21108  /* EMIT OTF ENTER */
21109  /********************************/
21110 
21111  struct MALP_Trace_Event otf_event;
21112 
21113  uint64_t _begin = Timer_tsc ();
21114 
21117  {
21118 
21119  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21120  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21121  MALP_EVENT_MPI, _container.event.mpi_event.type );
21122  Event_Packer_push(&otf_event);
21123  }
21124 
21125  /********************************/
21126  /* ACTUAL FUNCTION CALL */
21127  /********************************/
21128 
21130  int ret = PMPI_Testall( count, array_of_requests, flag, array_of_statuses );
21132 
21133  /********************************/
21134  /* EMIT OTF END */
21135  /********************************/
21136 
21137  uint64_t _end = Timer_tsc();
21138  uint64_t _duration = _end - _begin;
21139 
21141  {
21143  {
21144 
21145  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21146  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21147  MALP_EVENT_MPI, _container.event.mpi_event.type );
21148 
21149 
21150  Event_Packer_push(&otf_event);
21151  }
21152 
21153  /********************************/
21154  /* EMIT MALP EVENT */
21155  /********************************/
21156 
21157  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21158 
21159  /* Submit event if MPI instrumented */
21160  Event_Packer_push(&_container);
21161  }
21162 
21163 
21164  return ret;
21165 }
21166 int MPI_Testany( int count, MPI_Request array_of_requests[], int * index, int * flag, MPI_Status * status )
21167 {
21168 
21169  /* Virtualize MPI */
21170 
21171 
21172  /* Pre instrum */
21173  int _rank = Stream_desc_get()->mpi_rank;
21174 
21175  struct MALP_Trace_Event _container;
21176 
21177  /********************************/
21178  /* FILL MPI EVENT */
21179  /********************************/
21180 
21181  _container.event.mpi_event.type =
21182  T_MPI_ENUM(MPI_TESTANY)
21183  ;
21184 
21185  /* Set default source & dest before override */
21186  _container.event.mpi_event.source = _rank;
21187  _container.event.mpi_event.dest = _rank;
21188 
21189 
21190 
21191 
21192  SET_COUNT (count)
21193 
21194 
21195 
21196  /* Fill in size informations if needed */
21197  int _size = 0;
21198  #if 0
21199  COMP_SIZE (count)
21200  #endif
21201  _container.event.mpi_event.size = _size;
21202 
21203  /********************************/
21204  /* EMIT OTF ENTER */
21205  /********************************/
21206 
21207  struct MALP_Trace_Event otf_event;
21208 
21209  uint64_t _begin = Timer_tsc ();
21210 
21213  {
21214 
21215  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21216  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21217  MALP_EVENT_MPI, _container.event.mpi_event.type );
21218  Event_Packer_push(&otf_event);
21219  }
21220 
21221  /********************************/
21222  /* ACTUAL FUNCTION CALL */
21223  /********************************/
21224 
21226  int ret = PMPI_Testany( count, array_of_requests, index, flag, status );
21228 
21229  /********************************/
21230  /* EMIT OTF END */
21231  /********************************/
21232 
21233  uint64_t _end = Timer_tsc();
21234  uint64_t _duration = _end - _begin;
21235 
21237  {
21239  {
21240 
21241  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21242  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21243  MALP_EVENT_MPI, _container.event.mpi_event.type );
21244 
21245 
21246  Event_Packer_push(&otf_event);
21247  }
21248 
21249  /********************************/
21250  /* EMIT MALP EVENT */
21251  /********************************/
21252 
21253  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21254 
21255  /* Submit event if MPI instrumented */
21256  Event_Packer_push(&_container);
21257  }
21258 
21259 
21260  return ret;
21261 }
21262 int MPI_Test( MPI_Request * request, int * flag, MPI_Status * status )
21263 {
21264 
21265  /* Virtualize MPI */
21266 
21267 
21268  /* Pre instrum */
21269  int _rank = Stream_desc_get()->mpi_rank;
21270 
21271  struct MALP_Trace_Event _container;
21272 
21273  /********************************/
21274  /* FILL MPI EVENT */
21275  /********************************/
21276 
21277  _container.event.mpi_event.type =
21278  T_MPI_ENUM(MPI_TEST)
21279  ;
21280 
21281  /* Set default source & dest before override */
21282  _container.event.mpi_event.source = _rank;
21283  _container.event.mpi_event.dest = _rank;
21284 
21285 
21286 
21287 
21288 
21289 
21290 
21291 
21292  /* Fill in size informations if needed */
21293  int _size = 0;
21294  #if 0
21295 
21296  #endif
21297  _container.event.mpi_event.size = _size;
21298 
21299  /********************************/
21300  /* EMIT OTF ENTER */
21301  /********************************/
21302 
21303  struct MALP_Trace_Event otf_event;
21304 
21305  uint64_t _begin = Timer_tsc ();
21306 
21309  {
21310 
21311  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21312  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21313  MALP_EVENT_MPI, _container.event.mpi_event.type );
21314  Event_Packer_push(&otf_event);
21315  }
21316 
21317  /********************************/
21318  /* ACTUAL FUNCTION CALL */
21319  /********************************/
21320 
21322  int ret = PMPI_Test( request, flag, status );
21324 
21325  /********************************/
21326  /* EMIT OTF END */
21327  /********************************/
21328 
21329  uint64_t _end = Timer_tsc();
21330  uint64_t _duration = _end - _begin;
21331 
21333  {
21335  {
21336 
21337  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21338  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21339  MALP_EVENT_MPI, _container.event.mpi_event.type );
21340 
21341 
21342  Event_Packer_push(&otf_event);
21343  }
21344 
21345  /********************************/
21346  /* EMIT MALP EVENT */
21347  /********************************/
21348 
21349  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21350 
21351  /* Submit event if MPI instrumented */
21352  Event_Packer_push(&_container);
21353  }
21354 
21355 
21356  return ret;
21357 }
21358 int MPI_Test_cancelled( MPI_Status * status, int * flag )
21359 {
21360 
21361  /* Virtualize MPI */
21362 
21363 
21364  /* Pre instrum */
21365  int _rank = Stream_desc_get()->mpi_rank;
21366 
21367  struct MALP_Trace_Event _container;
21368 
21369  /********************************/
21370  /* FILL MPI EVENT */
21371  /********************************/
21372 
21373  _container.event.mpi_event.type =
21374  T_MPI_ENUM(MPI_TEST_CANCELLED)
21375  ;
21376 
21377  /* Set default source & dest before override */
21378  _container.event.mpi_event.source = _rank;
21379  _container.event.mpi_event.dest = _rank;
21380 
21381 
21382 
21383 
21384 
21385 
21386 
21387 
21388  /* Fill in size informations if needed */
21389  int _size = 0;
21390  #if 0
21391 
21392  #endif
21393  _container.event.mpi_event.size = _size;
21394 
21395  /********************************/
21396  /* EMIT OTF ENTER */
21397  /********************************/
21398 
21399  struct MALP_Trace_Event otf_event;
21400 
21401  uint64_t _begin = Timer_tsc ();
21402 
21405  {
21406 
21407  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21408  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21409  MALP_EVENT_MPI, _container.event.mpi_event.type );
21410  Event_Packer_push(&otf_event);
21411  }
21412 
21413  /********************************/
21414  /* ACTUAL FUNCTION CALL */
21415  /********************************/
21416 
21418  int ret = PMPI_Test_cancelled( status, flag );
21420 
21421  /********************************/
21422  /* EMIT OTF END */
21423  /********************************/
21424 
21425  uint64_t _end = Timer_tsc();
21426  uint64_t _duration = _end - _begin;
21427 
21429  {
21431  {
21432 
21433  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21434  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21435  MALP_EVENT_MPI, _container.event.mpi_event.type );
21436 
21437 
21438  Event_Packer_push(&otf_event);
21439  }
21440 
21441  /********************************/
21442  /* EMIT MALP EVENT */
21443  /********************************/
21444 
21445  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21446 
21447  /* Submit event if MPI instrumented */
21448  Event_Packer_push(&_container);
21449  }
21450 
21451 
21452  return ret;
21453 }
21454 int MPI_Testsome( int incount, MPI_Request array_of_requests[], int * outcount, int array_of_indices[], MPI_Status array_of_statuses[] )
21455 {
21456 
21457  /* Virtualize MPI */
21458 
21459 
21460  /* Pre instrum */
21461  int _rank = Stream_desc_get()->mpi_rank;
21462 
21463  struct MALP_Trace_Event _container;
21464 
21465  /********************************/
21466  /* FILL MPI EVENT */
21467  /********************************/
21468 
21469  _container.event.mpi_event.type =
21470  T_MPI_ENUM(MPI_TESTSOME)
21471  ;
21472 
21473  /* Set default source & dest before override */
21474  _container.event.mpi_event.source = _rank;
21475  _container.event.mpi_event.dest = _rank;
21476 
21477 
21478 
21479 
21480 
21481 
21482 
21483 
21484  /* Fill in size informations if needed */
21485  int _size = 0;
21486  #if 0
21487 
21488  #endif
21489  _container.event.mpi_event.size = _size;
21490 
21491  /********************************/
21492  /* EMIT OTF ENTER */
21493  /********************************/
21494 
21495  struct MALP_Trace_Event otf_event;
21496 
21497  uint64_t _begin = Timer_tsc ();
21498 
21501  {
21502 
21503  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21504  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21505  MALP_EVENT_MPI, _container.event.mpi_event.type );
21506  Event_Packer_push(&otf_event);
21507  }
21508 
21509  /********************************/
21510  /* ACTUAL FUNCTION CALL */
21511  /********************************/
21512 
21514  int ret = PMPI_Testsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );
21516 
21517  /********************************/
21518  /* EMIT OTF END */
21519  /********************************/
21520 
21521  uint64_t _end = Timer_tsc();
21522  uint64_t _duration = _end - _begin;
21523 
21525  {
21527  {
21528 
21529  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21530  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21531  MALP_EVENT_MPI, _container.event.mpi_event.type );
21532 
21533 
21534  Event_Packer_push(&otf_event);
21535  }
21536 
21537  /********************************/
21538  /* EMIT MALP EVENT */
21539  /********************************/
21540 
21541  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21542 
21543  /* Submit event if MPI instrumented */
21544  Event_Packer_push(&_container);
21545  }
21546 
21547 
21548  return ret;
21549 }
21550 int MPI_Topo_test( MPI_Comm comm, int * status )
21551 {
21552 
21553  /* Virtualize MPI */
21554  MACRO_MPI_Comm (comm)
21555 
21556  /* Pre instrum */
21557  int _rank = Stream_desc_get()->mpi_rank;
21558 
21559  struct MALP_Trace_Event _container;
21560 
21561  /********************************/
21562  /* FILL MPI EVENT */
21563  /********************************/
21564 
21565  _container.event.mpi_event.type =
21566  T_MPI_ENUM(MPI_TOPO_TEST)
21567  ;
21568 
21569  /* Set default source & dest before override */
21570  _container.event.mpi_event.source = _rank;
21571  _container.event.mpi_event.dest = _rank;
21572 
21573 
21574 
21575 
21576 
21577 
21578  SET_COMM (comm)
21579 
21580  /* Fill in size informations if needed */
21581  int _size = 0;
21582  #if 0
21583 
21584  #endif
21585  _container.event.mpi_event.size = _size;
21586 
21587  /********************************/
21588  /* EMIT OTF ENTER */
21589  /********************************/
21590 
21591  struct MALP_Trace_Event otf_event;
21592 
21593  uint64_t _begin = Timer_tsc ();
21594 
21597  {
21598 
21599  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21600  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21601  MALP_EVENT_MPI, _container.event.mpi_event.type );
21602  Event_Packer_push(&otf_event);
21603  }
21604 
21605  /********************************/
21606  /* ACTUAL FUNCTION CALL */
21607  /********************************/
21608 
21610  int ret = PMPI_Topo_test( comm, status );
21612 
21613  /********************************/
21614  /* EMIT OTF END */
21615  /********************************/
21616 
21617  uint64_t _end = Timer_tsc();
21618  uint64_t _duration = _end - _begin;
21619 
21621  {
21623  {
21624 
21625  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21626  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21627  MALP_EVENT_MPI, _container.event.mpi_event.type );
21628 
21629 
21630  Event_Packer_push(&otf_event);
21631  }
21632 
21633  /********************************/
21634  /* EMIT MALP EVENT */
21635  /********************************/
21636 
21637  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21638 
21639  /* Submit event if MPI instrumented */
21640  Event_Packer_push(&_container);
21641  }
21642 
21643 
21644  return ret;
21645 }
21646 int MPI_Type_c2f( MPI_Datatype datatype )
21647 {
21648 
21649  /* Virtualize MPI */
21650 
21651 
21652  /* Pre instrum */
21653  int _rank = Stream_desc_get()->mpi_rank;
21654 
21655  struct MALP_Trace_Event _container;
21656 
21657  /********************************/
21658  /* FILL MPI EVENT */
21659  /********************************/
21660 
21661  _container.event.mpi_event.type =
21662  T_MPI_ENUM(MPI_TYPE_C2F)
21663  ;
21664 
21665  /* Set default source & dest before override */
21666  _container.event.mpi_event.source = _rank;
21667  _container.event.mpi_event.dest = _rank;
21668 
21669 
21670 
21671 
21672 
21673  SET_DATATYPE (datatype)
21674 
21675 
21676  /* Fill in size informations if needed */
21677  int _size = 0;
21678  #if 1
21679 
21680  #endif
21681  _container.event.mpi_event.size = _size;
21682 
21683  /********************************/
21684  /* EMIT OTF ENTER */
21685  /********************************/
21686 
21687  struct MALP_Trace_Event otf_event;
21688 
21689  uint64_t _begin = Timer_tsc ();
21690 
21693  {
21694 
21695  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21696  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21697  MALP_EVENT_MPI, _container.event.mpi_event.type );
21698  Event_Packer_push(&otf_event);
21699  }
21700 
21701  /********************************/
21702  /* ACTUAL FUNCTION CALL */
21703  /********************************/
21704 
21706  int ret = PMPI_Type_c2f( datatype );
21708 
21709  /********************************/
21710  /* EMIT OTF END */
21711  /********************************/
21712 
21713  uint64_t _end = Timer_tsc();
21714  uint64_t _duration = _end - _begin;
21715 
21717  {
21719  {
21720 
21721  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21722  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21723  MALP_EVENT_MPI, _container.event.mpi_event.type );
21724 
21725 
21726  Event_Packer_push(&otf_event);
21727  }
21728 
21729  /********************************/
21730  /* EMIT MALP EVENT */
21731  /********************************/
21732 
21733  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21734 
21735  /* Submit event if MPI instrumented */
21736  Event_Packer_push(&_container);
21737  }
21738 
21739 
21740  return ret;
21741 }
21742 int MPI_Type_commit( MPI_Datatype * type )
21743 {
21744 
21745  /* Virtualize MPI */
21746 
21747 
21748  /* Pre instrum */
21749  int _rank = Stream_desc_get()->mpi_rank;
21750 
21751  struct MALP_Trace_Event _container;
21752 
21753  /********************************/
21754  /* FILL MPI EVENT */
21755  /********************************/
21756 
21757  _container.event.mpi_event.type =
21758  T_MPI_ENUM(MPI_TYPE_COMMIT)
21759  ;
21760 
21761  /* Set default source & dest before override */
21762  _container.event.mpi_event.source = _rank;
21763  _container.event.mpi_event.dest = _rank;
21764 
21765 
21766 
21767 
21768 
21769 
21770 
21771 
21772  /* Fill in size informations if needed */
21773  int _size = 0;
21774  #if 0
21775 
21776  #endif
21777  _container.event.mpi_event.size = _size;
21778 
21779  /********************************/
21780  /* EMIT OTF ENTER */
21781  /********************************/
21782 
21783  struct MALP_Trace_Event otf_event;
21784 
21785  uint64_t _begin = Timer_tsc ();
21786 
21789  {
21790 
21791  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21792  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21793  MALP_EVENT_MPI, _container.event.mpi_event.type );
21794  Event_Packer_push(&otf_event);
21795  }
21796 
21797  /********************************/
21798  /* ACTUAL FUNCTION CALL */
21799  /********************************/
21800 
21802  int ret = PMPI_Type_commit( type );
21804 
21805  /********************************/
21806  /* EMIT OTF END */
21807  /********************************/
21808 
21809  uint64_t _end = Timer_tsc();
21810  uint64_t _duration = _end - _begin;
21811 
21813  {
21815  {
21816 
21817  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21818  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21819  MALP_EVENT_MPI, _container.event.mpi_event.type );
21820 
21821 
21822  Event_Packer_push(&otf_event);
21823  }
21824 
21825  /********************************/
21826  /* EMIT MALP EVENT */
21827  /********************************/
21828 
21829  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21830 
21831  /* Submit event if MPI instrumented */
21832  Event_Packer_push(&_container);
21833  }
21834 
21835 
21836  return ret;
21837 }
21838 int MPI_Type_contiguous( int count, MPI_Datatype oldtype, MPI_Datatype * newtype )
21839 {
21840 
21841  /* Virtualize MPI */
21842 
21843 
21844  /* Pre instrum */
21845  int _rank = Stream_desc_get()->mpi_rank;
21846 
21847  struct MALP_Trace_Event _container;
21848 
21849  /********************************/
21850  /* FILL MPI EVENT */
21851  /********************************/
21852 
21853  _container.event.mpi_event.type =
21854  T_MPI_ENUM(MPI_TYPE_CONTIGUOUS)
21855  ;
21856 
21857  /* Set default source & dest before override */
21858  _container.event.mpi_event.source = _rank;
21859  _container.event.mpi_event.dest = _rank;
21860 
21861 
21862 
21863 
21864  SET_COUNT (count)
21865 
21866 
21867 
21868  /* Fill in size informations if needed */
21869  int _size = 0;
21870  #if 0
21871  COMP_SIZE (count)
21872  #endif
21873  _container.event.mpi_event.size = _size;
21874 
21875  /********************************/
21876  /* EMIT OTF ENTER */
21877  /********************************/
21878 
21879  struct MALP_Trace_Event otf_event;
21880 
21881  uint64_t _begin = Timer_tsc ();
21882 
21885  {
21886 
21887  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21888  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21889  MALP_EVENT_MPI, _container.event.mpi_event.type );
21890  Event_Packer_push(&otf_event);
21891  }
21892 
21893  /********************************/
21894  /* ACTUAL FUNCTION CALL */
21895  /********************************/
21896 
21898  int ret = PMPI_Type_contiguous( count, oldtype, newtype );
21900 
21901  /********************************/
21902  /* EMIT OTF END */
21903  /********************************/
21904 
21905  uint64_t _end = Timer_tsc();
21906  uint64_t _duration = _end - _begin;
21907 
21909  {
21911  {
21912 
21913  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
21914  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
21915  MALP_EVENT_MPI, _container.event.mpi_event.type );
21916 
21917 
21918  Event_Packer_push(&otf_event);
21919  }
21920 
21921  /********************************/
21922  /* EMIT MALP EVENT */
21923  /********************************/
21924 
21925  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
21926 
21927  /* Submit event if MPI instrumented */
21928  Event_Packer_push(&_container);
21929  }
21930 
21931 
21932  return ret;
21933 }
21934 int MPI_Type_create_darray( int size, int rank, int ndims, int gsize_array[], int distrib_array[], int darg_array[], int psize_array[], int order, MPI_Datatype oldtype, MPI_Datatype * newtype )
21935 {
21936 
21937  /* Virtualize MPI */
21938 
21939 
21940  /* Pre instrum */
21941  int _rank = Stream_desc_get()->mpi_rank;
21942 
21943  struct MALP_Trace_Event _container;
21944 
21945  /********************************/
21946  /* FILL MPI EVENT */
21947  /********************************/
21948 
21949  _container.event.mpi_event.type =
21950  T_MPI_ENUM(MPI_TYPE_CREATE_DARRAY)
21951  ;
21952 
21953  /* Set default source & dest before override */
21954  _container.event.mpi_event.source = _rank;
21955  _container.event.mpi_event.dest = _rank;
21956 
21957 
21958 
21959 
21960 
21961 
21962 
21963 
21964  /* Fill in size informations if needed */
21965  int _size = 0;
21966  #if 0
21967 
21968  #endif
21969  _container.event.mpi_event.size = _size;
21970 
21971  /********************************/
21972  /* EMIT OTF ENTER */
21973  /********************************/
21974 
21975  struct MALP_Trace_Event otf_event;
21976 
21977  uint64_t _begin = Timer_tsc ();
21978 
21981  {
21982 
21983  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
21984  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
21985  MALP_EVENT_MPI, _container.event.mpi_event.type );
21986  Event_Packer_push(&otf_event);
21987  }
21988 
21989  /********************************/
21990  /* ACTUAL FUNCTION CALL */
21991  /********************************/
21992 
21994  int ret = PMPI_Type_create_darray( size, rank, ndims, gsize_array, distrib_array, darg_array, psize_array, order, oldtype, newtype );
21996 
21997  /********************************/
21998  /* EMIT OTF END */
21999  /********************************/
22000 
22001  uint64_t _end = Timer_tsc();
22002  uint64_t _duration = _end - _begin;
22003 
22005  {
22007  {
22008 
22009  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22010  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22011  MALP_EVENT_MPI, _container.event.mpi_event.type );
22012 
22013 
22014  Event_Packer_push(&otf_event);
22015  }
22016 
22017  /********************************/
22018  /* EMIT MALP EVENT */
22019  /********************************/
22020 
22021  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22022 
22023  /* Submit event if MPI instrumented */
22024  Event_Packer_push(&_container);
22025  }
22026 
22027 
22028  return ret;
22029 }
22030 int MPI_Type_create_f90_complex( int p, int r, MPI_Datatype * newtype )
22031 {
22032 
22033  /* Virtualize MPI */
22034 
22035 
22036  /* Pre instrum */
22037  int _rank = Stream_desc_get()->mpi_rank;
22038 
22039  struct MALP_Trace_Event _container;
22040 
22041  /********************************/
22042  /* FILL MPI EVENT */
22043  /********************************/
22044 
22045  _container.event.mpi_event.type =
22046  T_MPI_ENUM(MPI_TYPE_CREATE_F90_COMPLEX)
22047  ;
22048 
22049  /* Set default source & dest before override */
22050  _container.event.mpi_event.source = _rank;
22051  _container.event.mpi_event.dest = _rank;
22052 
22053 
22054 
22055 
22056 
22057 
22058 
22059 
22060  /* Fill in size informations if needed */
22061  int _size = 0;
22062  #if 0
22063 
22064  #endif
22065  _container.event.mpi_event.size = _size;
22066 
22067  /********************************/
22068  /* EMIT OTF ENTER */
22069  /********************************/
22070 
22071  struct MALP_Trace_Event otf_event;
22072 
22073  uint64_t _begin = Timer_tsc ();
22074 
22077  {
22078 
22079  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22080  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22081  MALP_EVENT_MPI, _container.event.mpi_event.type );
22082  Event_Packer_push(&otf_event);
22083  }
22084 
22085  /********************************/
22086  /* ACTUAL FUNCTION CALL */
22087  /********************************/
22088 
22090  int ret = PMPI_Type_create_f90_complex( p, r, newtype );
22092 
22093  /********************************/
22094  /* EMIT OTF END */
22095  /********************************/
22096 
22097  uint64_t _end = Timer_tsc();
22098  uint64_t _duration = _end - _begin;
22099 
22101  {
22103  {
22104 
22105  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22106  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22107  MALP_EVENT_MPI, _container.event.mpi_event.type );
22108 
22109 
22110  Event_Packer_push(&otf_event);
22111  }
22112 
22113  /********************************/
22114  /* EMIT MALP EVENT */
22115  /********************************/
22116 
22117  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22118 
22119  /* Submit event if MPI instrumented */
22120  Event_Packer_push(&_container);
22121  }
22122 
22123 
22124  return ret;
22125 }
22126 int MPI_Type_create_f90_integer( int r, MPI_Datatype * newtype )
22127 {
22128 
22129  /* Virtualize MPI */
22130 
22131 
22132  /* Pre instrum */
22133  int _rank = Stream_desc_get()->mpi_rank;
22134 
22135  struct MALP_Trace_Event _container;
22136 
22137  /********************************/
22138  /* FILL MPI EVENT */
22139  /********************************/
22140 
22141  _container.event.mpi_event.type =
22142  T_MPI_ENUM(MPI_TYPE_CREATE_F90_INTEGER)
22143  ;
22144 
22145  /* Set default source & dest before override */
22146  _container.event.mpi_event.source = _rank;
22147  _container.event.mpi_event.dest = _rank;
22148 
22149 
22150 
22151 
22152 
22153 
22154 
22155 
22156  /* Fill in size informations if needed */
22157  int _size = 0;
22158  #if 0
22159 
22160  #endif
22161  _container.event.mpi_event.size = _size;
22162 
22163  /********************************/
22164  /* EMIT OTF ENTER */
22165  /********************************/
22166 
22167  struct MALP_Trace_Event otf_event;
22168 
22169  uint64_t _begin = Timer_tsc ();
22170 
22173  {
22174 
22175  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22176  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22177  MALP_EVENT_MPI, _container.event.mpi_event.type );
22178  Event_Packer_push(&otf_event);
22179  }
22180 
22181  /********************************/
22182  /* ACTUAL FUNCTION CALL */
22183  /********************************/
22184 
22186  int ret = PMPI_Type_create_f90_integer( r, newtype );
22188 
22189  /********************************/
22190  /* EMIT OTF END */
22191  /********************************/
22192 
22193  uint64_t _end = Timer_tsc();
22194  uint64_t _duration = _end - _begin;
22195 
22197  {
22199  {
22200 
22201  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22202  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22203  MALP_EVENT_MPI, _container.event.mpi_event.type );
22204 
22205 
22206  Event_Packer_push(&otf_event);
22207  }
22208 
22209  /********************************/
22210  /* EMIT MALP EVENT */
22211  /********************************/
22212 
22213  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22214 
22215  /* Submit event if MPI instrumented */
22216  Event_Packer_push(&_container);
22217  }
22218 
22219 
22220  return ret;
22221 }
22222 int MPI_Type_create_f90_real( int p, int r, MPI_Datatype * newtype )
22223 {
22224 
22225  /* Virtualize MPI */
22226 
22227 
22228  /* Pre instrum */
22229  int _rank = Stream_desc_get()->mpi_rank;
22230 
22231  struct MALP_Trace_Event _container;
22232 
22233  /********************************/
22234  /* FILL MPI EVENT */
22235  /********************************/
22236 
22237  _container.event.mpi_event.type =
22238  T_MPI_ENUM(MPI_TYPE_CREATE_F90_REAL)
22239  ;
22240 
22241  /* Set default source & dest before override */
22242  _container.event.mpi_event.source = _rank;
22243  _container.event.mpi_event.dest = _rank;
22244 
22245 
22246 
22247 
22248 
22249 
22250 
22251 
22252  /* Fill in size informations if needed */
22253  int _size = 0;
22254  #if 0
22255 
22256  #endif
22257  _container.event.mpi_event.size = _size;
22258 
22259  /********************************/
22260  /* EMIT OTF ENTER */
22261  /********************************/
22262 
22263  struct MALP_Trace_Event otf_event;
22264 
22265  uint64_t _begin = Timer_tsc ();
22266 
22269  {
22270 
22271  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22272  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22273  MALP_EVENT_MPI, _container.event.mpi_event.type );
22274  Event_Packer_push(&otf_event);
22275  }
22276 
22277  /********************************/
22278  /* ACTUAL FUNCTION CALL */
22279  /********************************/
22280 
22282  int ret = PMPI_Type_create_f90_real( p, r, newtype );
22284 
22285  /********************************/
22286  /* EMIT OTF END */
22287  /********************************/
22288 
22289  uint64_t _end = Timer_tsc();
22290  uint64_t _duration = _end - _begin;
22291 
22293  {
22295  {
22296 
22297  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22298  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22299  MALP_EVENT_MPI, _container.event.mpi_event.type );
22300 
22301 
22302  Event_Packer_push(&otf_event);
22303  }
22304 
22305  /********************************/
22306  /* EMIT MALP EVENT */
22307  /********************************/
22308 
22309  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22310 
22311  /* Submit event if MPI instrumented */
22312  Event_Packer_push(&_container);
22313  }
22314 
22315 
22316  return ret;
22317 }
22318 int MPI_Type_create_hindexed( int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
22319 {
22320 
22321  /* Virtualize MPI */
22322 
22323 
22324  /* Pre instrum */
22325  int _rank = Stream_desc_get()->mpi_rank;
22326 
22327  struct MALP_Trace_Event _container;
22328 
22329  /********************************/
22330  /* FILL MPI EVENT */
22331  /********************************/
22332 
22333  _container.event.mpi_event.type =
22334  T_MPI_ENUM(MPI_TYPE_CREATE_HINDEXED)
22335  ;
22336 
22337  /* Set default source & dest before override */
22338  _container.event.mpi_event.source = _rank;
22339  _container.event.mpi_event.dest = _rank;
22340 
22341 
22342 
22343 
22344  SET_COUNT (count)
22345 
22346 
22347 
22348  /* Fill in size informations if needed */
22349  int _size = 0;
22350  #if 0
22351  COMP_SIZE (count)
22352  #endif
22353  _container.event.mpi_event.size = _size;
22354 
22355  /********************************/
22356  /* EMIT OTF ENTER */
22357  /********************************/
22358 
22359  struct MALP_Trace_Event otf_event;
22360 
22361  uint64_t _begin = Timer_tsc ();
22362 
22365  {
22366 
22367  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22368  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22369  MALP_EVENT_MPI, _container.event.mpi_event.type );
22370  Event_Packer_push(&otf_event);
22371  }
22372 
22373  /********************************/
22374  /* ACTUAL FUNCTION CALL */
22375  /********************************/
22376 
22378  int ret = PMPI_Type_create_hindexed( count, array_of_blocklengths, array_of_displacements, oldtype, newtype );
22380 
22381  /********************************/
22382  /* EMIT OTF END */
22383  /********************************/
22384 
22385  uint64_t _end = Timer_tsc();
22386  uint64_t _duration = _end - _begin;
22387 
22389  {
22391  {
22392 
22393  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22394  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22395  MALP_EVENT_MPI, _container.event.mpi_event.type );
22396 
22397 
22398  Event_Packer_push(&otf_event);
22399  }
22400 
22401  /********************************/
22402  /* EMIT MALP EVENT */
22403  /********************************/
22404 
22405  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22406 
22407  /* Submit event if MPI instrumented */
22408  Event_Packer_push(&_container);
22409  }
22410 
22411 
22412  return ret;
22413 }
22414 int MPI_Type_create_hvector( int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype * newtype )
22415 {
22416 
22417  /* Virtualize MPI */
22418 
22419 
22420  /* Pre instrum */
22421  int _rank = Stream_desc_get()->mpi_rank;
22422 
22423  struct MALP_Trace_Event _container;
22424 
22425  /********************************/
22426  /* FILL MPI EVENT */
22427  /********************************/
22428 
22429  _container.event.mpi_event.type =
22430  T_MPI_ENUM(MPI_TYPE_CREATE_HVECTOR)
22431  ;
22432 
22433  /* Set default source & dest before override */
22434  _container.event.mpi_event.source = _rank;
22435  _container.event.mpi_event.dest = _rank;
22436 
22437 
22438 
22439 
22440  SET_COUNT (count)
22441 
22442 
22443 
22444  /* Fill in size informations if needed */
22445  int _size = 0;
22446  #if 0
22447  COMP_SIZE (count)
22448  #endif
22449  _container.event.mpi_event.size = _size;
22450 
22451  /********************************/
22452  /* EMIT OTF ENTER */
22453  /********************************/
22454 
22455  struct MALP_Trace_Event otf_event;
22456 
22457  uint64_t _begin = Timer_tsc ();
22458 
22461  {
22462 
22463  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22464  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22465  MALP_EVENT_MPI, _container.event.mpi_event.type );
22466  Event_Packer_push(&otf_event);
22467  }
22468 
22469  /********************************/
22470  /* ACTUAL FUNCTION CALL */
22471  /********************************/
22472 
22474  int ret = PMPI_Type_create_hvector( count, blocklength, stride, oldtype, newtype );
22476 
22477  /********************************/
22478  /* EMIT OTF END */
22479  /********************************/
22480 
22481  uint64_t _end = Timer_tsc();
22482  uint64_t _duration = _end - _begin;
22483 
22485  {
22487  {
22488 
22489  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22490  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22491  MALP_EVENT_MPI, _container.event.mpi_event.type );
22492 
22493 
22494  Event_Packer_push(&otf_event);
22495  }
22496 
22497  /********************************/
22498  /* EMIT MALP EVENT */
22499  /********************************/
22500 
22501  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22502 
22503  /* Submit event if MPI instrumented */
22504  Event_Packer_push(&_container);
22505  }
22506 
22507 
22508  return ret;
22509 }
22510 int MPI_Type_create_keyval( MPI_Type_copy_attr_function * type_copy_attr_fn, MPI_Type_delete_attr_function * type_delete_attr_fn, int * type_keyval, void * extra_state )
22511 {
22512 
22513  /* Virtualize MPI */
22514 
22515 
22516  /* Pre instrum */
22517  int _rank = Stream_desc_get()->mpi_rank;
22518 
22519  struct MALP_Trace_Event _container;
22520 
22521  /********************************/
22522  /* FILL MPI EVENT */
22523  /********************************/
22524 
22525  _container.event.mpi_event.type =
22526  T_MPI_ENUM(MPI_TYPE_CREATE_KEYVAL)
22527  ;
22528 
22529  /* Set default source & dest before override */
22530  _container.event.mpi_event.source = _rank;
22531  _container.event.mpi_event.dest = _rank;
22532 
22533 
22534 
22535 
22536 
22537 
22538 
22539 
22540  /* Fill in size informations if needed */
22541  int _size = 0;
22542  #if 0
22543 
22544  #endif
22545  _container.event.mpi_event.size = _size;
22546 
22547  /********************************/
22548  /* EMIT OTF ENTER */
22549  /********************************/
22550 
22551  struct MALP_Trace_Event otf_event;
22552 
22553  uint64_t _begin = Timer_tsc ();
22554 
22557  {
22558 
22559  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22560  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22561  MALP_EVENT_MPI, _container.event.mpi_event.type );
22562  Event_Packer_push(&otf_event);
22563  }
22564 
22565  /********************************/
22566  /* ACTUAL FUNCTION CALL */
22567  /********************************/
22568 
22570  int ret = PMPI_Type_create_keyval( type_copy_attr_fn, type_delete_attr_fn, type_keyval, extra_state );
22572 
22573  /********************************/
22574  /* EMIT OTF END */
22575  /********************************/
22576 
22577  uint64_t _end = Timer_tsc();
22578  uint64_t _duration = _end - _begin;
22579 
22581  {
22583  {
22584 
22585  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22586  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22587  MALP_EVENT_MPI, _container.event.mpi_event.type );
22588 
22589 
22590  Event_Packer_push(&otf_event);
22591  }
22592 
22593  /********************************/
22594  /* EMIT MALP EVENT */
22595  /********************************/
22596 
22597  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22598 
22599  /* Submit event if MPI instrumented */
22600  Event_Packer_push(&_container);
22601  }
22602 
22603 
22604  return ret;
22605 }
22606 int MPI_Type_create_indexed_block( int count, int blocklength, int array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
22607 {
22608 
22609  /* Virtualize MPI */
22610 
22611 
22612  /* Pre instrum */
22613  int _rank = Stream_desc_get()->mpi_rank;
22614 
22615  struct MALP_Trace_Event _container;
22616 
22617  /********************************/
22618  /* FILL MPI EVENT */
22619  /********************************/
22620 
22621  _container.event.mpi_event.type =
22622  T_MPI_ENUM(MPI_TYPE_CREATE_INDEXED_BLOCK)
22623  ;
22624 
22625  /* Set default source & dest before override */
22626  _container.event.mpi_event.source = _rank;
22627  _container.event.mpi_event.dest = _rank;
22628 
22629 
22630 
22631 
22632  SET_COUNT (count)
22633 
22634 
22635 
22636  /* Fill in size informations if needed */
22637  int _size = 0;
22638  #if 0
22639  COMP_SIZE (count)
22640  #endif
22641  _container.event.mpi_event.size = _size;
22642 
22643  /********************************/
22644  /* EMIT OTF ENTER */
22645  /********************************/
22646 
22647  struct MALP_Trace_Event otf_event;
22648 
22649  uint64_t _begin = Timer_tsc ();
22650 
22653  {
22654 
22655  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22656  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22657  MALP_EVENT_MPI, _container.event.mpi_event.type );
22658  Event_Packer_push(&otf_event);
22659  }
22660 
22661  /********************************/
22662  /* ACTUAL FUNCTION CALL */
22663  /********************************/
22664 
22666  int ret = PMPI_Type_create_indexed_block( count, blocklength, array_of_displacements, oldtype, newtype );
22668 
22669  /********************************/
22670  /* EMIT OTF END */
22671  /********************************/
22672 
22673  uint64_t _end = Timer_tsc();
22674  uint64_t _duration = _end - _begin;
22675 
22677  {
22679  {
22680 
22681  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22682  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22683  MALP_EVENT_MPI, _container.event.mpi_event.type );
22684 
22685 
22686  Event_Packer_push(&otf_event);
22687  }
22688 
22689  /********************************/
22690  /* EMIT MALP EVENT */
22691  /********************************/
22692 
22693  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22694 
22695  /* Submit event if MPI instrumented */
22696  Event_Packer_push(&_container);
22697  }
22698 
22699 
22700  return ret;
22701 }
22702 int MPI_Type_create_struct( int count, int array_of_block_lengths[], MPI_Aint array_of_displacements[], MPI_Datatype array_of_types[], MPI_Datatype * newtype )
22703 {
22704 
22705  /* Virtualize MPI */
22706 
22707 
22708  /* Pre instrum */
22709  int _rank = Stream_desc_get()->mpi_rank;
22710 
22711  struct MALP_Trace_Event _container;
22712 
22713  /********************************/
22714  /* FILL MPI EVENT */
22715  /********************************/
22716 
22717  _container.event.mpi_event.type =
22718  T_MPI_ENUM(MPI_TYPE_CREATE_STRUCT)
22719  ;
22720 
22721  /* Set default source & dest before override */
22722  _container.event.mpi_event.source = _rank;
22723  _container.event.mpi_event.dest = _rank;
22724 
22725 
22726 
22727 
22728  SET_COUNT (count)
22729 
22730 
22731 
22732  /* Fill in size informations if needed */
22733  int _size = 0;
22734  #if 0
22735  COMP_SIZE (count)
22736  #endif
22737  _container.event.mpi_event.size = _size;
22738 
22739  /********************************/
22740  /* EMIT OTF ENTER */
22741  /********************************/
22742 
22743  struct MALP_Trace_Event otf_event;
22744 
22745  uint64_t _begin = Timer_tsc ();
22746 
22749  {
22750 
22751  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22752  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22753  MALP_EVENT_MPI, _container.event.mpi_event.type );
22754  Event_Packer_push(&otf_event);
22755  }
22756 
22757  /********************************/
22758  /* ACTUAL FUNCTION CALL */
22759  /********************************/
22760 
22762  int ret = PMPI_Type_create_struct( count, array_of_block_lengths, array_of_displacements, array_of_types, newtype );
22764 
22765  /********************************/
22766  /* EMIT OTF END */
22767  /********************************/
22768 
22769  uint64_t _end = Timer_tsc();
22770  uint64_t _duration = _end - _begin;
22771 
22773  {
22775  {
22776 
22777  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22778  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22779  MALP_EVENT_MPI, _container.event.mpi_event.type );
22780 
22781 
22782  Event_Packer_push(&otf_event);
22783  }
22784 
22785  /********************************/
22786  /* EMIT MALP EVENT */
22787  /********************************/
22788 
22789  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22790 
22791  /* Submit event if MPI instrumented */
22792  Event_Packer_push(&_container);
22793  }
22794 
22795 
22796  return ret;
22797 }
22798 int MPI_Type_create_subarray( int ndims, int size_array[], int subsize_array[], int start_array[], int order, MPI_Datatype oldtype, MPI_Datatype * newtype )
22799 {
22800 
22801  /* Virtualize MPI */
22802 
22803 
22804  /* Pre instrum */
22805  int _rank = Stream_desc_get()->mpi_rank;
22806 
22807  struct MALP_Trace_Event _container;
22808 
22809  /********************************/
22810  /* FILL MPI EVENT */
22811  /********************************/
22812 
22813  _container.event.mpi_event.type =
22814  T_MPI_ENUM(MPI_TYPE_CREATE_SUBARRAY)
22815  ;
22816 
22817  /* Set default source & dest before override */
22818  _container.event.mpi_event.source = _rank;
22819  _container.event.mpi_event.dest = _rank;
22820 
22821 
22822 
22823 
22824 
22825 
22826 
22827 
22828  /* Fill in size informations if needed */
22829  int _size = 0;
22830  #if 0
22831 
22832  #endif
22833  _container.event.mpi_event.size = _size;
22834 
22835  /********************************/
22836  /* EMIT OTF ENTER */
22837  /********************************/
22838 
22839  struct MALP_Trace_Event otf_event;
22840 
22841  uint64_t _begin = Timer_tsc ();
22842 
22845  {
22846 
22847  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22848  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22849  MALP_EVENT_MPI, _container.event.mpi_event.type );
22850  Event_Packer_push(&otf_event);
22851  }
22852 
22853  /********************************/
22854  /* ACTUAL FUNCTION CALL */
22855  /********************************/
22856 
22858  int ret = PMPI_Type_create_subarray( ndims, size_array, subsize_array, start_array, order, oldtype, newtype );
22860 
22861  /********************************/
22862  /* EMIT OTF END */
22863  /********************************/
22864 
22865  uint64_t _end = Timer_tsc();
22866  uint64_t _duration = _end - _begin;
22867 
22869  {
22871  {
22872 
22873  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22874  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22875  MALP_EVENT_MPI, _container.event.mpi_event.type );
22876 
22877 
22878  Event_Packer_push(&otf_event);
22879  }
22880 
22881  /********************************/
22882  /* EMIT MALP EVENT */
22883  /********************************/
22884 
22885  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22886 
22887  /* Submit event if MPI instrumented */
22888  Event_Packer_push(&_container);
22889  }
22890 
22891 
22892  return ret;
22893 }
22894 int MPI_Type_create_resized( MPI_Datatype oldtype, MPI_Aint lb, MPI_Aint extent, MPI_Datatype * newtype )
22895 {
22896 
22897  /* Virtualize MPI */
22898 
22899 
22900  /* Pre instrum */
22901  int _rank = Stream_desc_get()->mpi_rank;
22902 
22903  struct MALP_Trace_Event _container;
22904 
22905  /********************************/
22906  /* FILL MPI EVENT */
22907  /********************************/
22908 
22909  _container.event.mpi_event.type =
22910  T_MPI_ENUM(MPI_TYPE_CREATE_RESIZED)
22911  ;
22912 
22913  /* Set default source & dest before override */
22914  _container.event.mpi_event.source = _rank;
22915  _container.event.mpi_event.dest = _rank;
22916 
22917 
22918 
22919 
22920 
22921 
22922 
22923 
22924  /* Fill in size informations if needed */
22925  int _size = 0;
22926  #if 0
22927 
22928  #endif
22929  _container.event.mpi_event.size = _size;
22930 
22931  /********************************/
22932  /* EMIT OTF ENTER */
22933  /********************************/
22934 
22935  struct MALP_Trace_Event otf_event;
22936 
22937  uint64_t _begin = Timer_tsc ();
22938 
22941  {
22942 
22943  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
22944  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
22945  MALP_EVENT_MPI, _container.event.mpi_event.type );
22946  Event_Packer_push(&otf_event);
22947  }
22948 
22949  /********************************/
22950  /* ACTUAL FUNCTION CALL */
22951  /********************************/
22952 
22954  int ret = PMPI_Type_create_resized( oldtype, lb, extent, newtype );
22956 
22957  /********************************/
22958  /* EMIT OTF END */
22959  /********************************/
22960 
22961  uint64_t _end = Timer_tsc();
22962  uint64_t _duration = _end - _begin;
22963 
22965  {
22967  {
22968 
22969  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
22970  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
22971  MALP_EVENT_MPI, _container.event.mpi_event.type );
22972 
22973 
22974  Event_Packer_push(&otf_event);
22975  }
22976 
22977  /********************************/
22978  /* EMIT MALP EVENT */
22979  /********************************/
22980 
22981  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
22982 
22983  /* Submit event if MPI instrumented */
22984  Event_Packer_push(&_container);
22985  }
22986 
22987 
22988  return ret;
22989 }
22990 int MPI_Type_delete_attr( MPI_Datatype type, int type_keyval )
22991 {
22992 
22993  /* Virtualize MPI */
22994 
22995 
22996  /* Pre instrum */
22997  int _rank = Stream_desc_get()->mpi_rank;
22998 
22999  struct MALP_Trace_Event _container;
23000 
23001  /********************************/
23002  /* FILL MPI EVENT */
23003  /********************************/
23004 
23005  _container.event.mpi_event.type =
23006  T_MPI_ENUM(MPI_TYPE_DELETE_ATTR)
23007  ;
23008 
23009  /* Set default source & dest before override */
23010  _container.event.mpi_event.source = _rank;
23011  _container.event.mpi_event.dest = _rank;
23012 
23013 
23014 
23015 
23016 
23017 
23018 
23019 
23020  /* Fill in size informations if needed */
23021  int _size = 0;
23022  #if 0
23023 
23024  #endif
23025  _container.event.mpi_event.size = _size;
23026 
23027  /********************************/
23028  /* EMIT OTF ENTER */
23029  /********************************/
23030 
23031  struct MALP_Trace_Event otf_event;
23032 
23033  uint64_t _begin = Timer_tsc ();
23034 
23037  {
23038 
23039  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23040  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23041  MALP_EVENT_MPI, _container.event.mpi_event.type );
23042  Event_Packer_push(&otf_event);
23043  }
23044 
23045  /********************************/
23046  /* ACTUAL FUNCTION CALL */
23047  /********************************/
23048 
23050  int ret = PMPI_Type_delete_attr( type, type_keyval );
23052 
23053  /********************************/
23054  /* EMIT OTF END */
23055  /********************************/
23056 
23057  uint64_t _end = Timer_tsc();
23058  uint64_t _duration = _end - _begin;
23059 
23061  {
23063  {
23064 
23065  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23066  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23067  MALP_EVENT_MPI, _container.event.mpi_event.type );
23068 
23069 
23070  Event_Packer_push(&otf_event);
23071  }
23072 
23073  /********************************/
23074  /* EMIT MALP EVENT */
23075  /********************************/
23076 
23077  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23078 
23079  /* Submit event if MPI instrumented */
23080  Event_Packer_push(&_container);
23081  }
23082 
23083 
23084  return ret;
23085 }
23086 int MPI_Type_dup( MPI_Datatype type, MPI_Datatype * newtype )
23087 {
23088 
23089  /* Virtualize MPI */
23090 
23091 
23092  /* Pre instrum */
23093  int _rank = Stream_desc_get()->mpi_rank;
23094 
23095  struct MALP_Trace_Event _container;
23096 
23097  /********************************/
23098  /* FILL MPI EVENT */
23099  /********************************/
23100 
23101  _container.event.mpi_event.type =
23102  T_MPI_ENUM(MPI_TYPE_DUP)
23103  ;
23104 
23105  /* Set default source & dest before override */
23106  _container.event.mpi_event.source = _rank;
23107  _container.event.mpi_event.dest = _rank;
23108 
23109 
23110 
23111 
23112 
23113 
23114 
23115 
23116  /* Fill in size informations if needed */
23117  int _size = 0;
23118  #if 0
23119 
23120  #endif
23121  _container.event.mpi_event.size = _size;
23122 
23123  /********************************/
23124  /* EMIT OTF ENTER */
23125  /********************************/
23126 
23127  struct MALP_Trace_Event otf_event;
23128 
23129  uint64_t _begin = Timer_tsc ();
23130 
23133  {
23134 
23135  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23136  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23137  MALP_EVENT_MPI, _container.event.mpi_event.type );
23138  Event_Packer_push(&otf_event);
23139  }
23140 
23141  /********************************/
23142  /* ACTUAL FUNCTION CALL */
23143  /********************************/
23144 
23146  int ret = PMPI_Type_dup( type, newtype );
23148 
23149  /********************************/
23150  /* EMIT OTF END */
23151  /********************************/
23152 
23153  uint64_t _end = Timer_tsc();
23154  uint64_t _duration = _end - _begin;
23155 
23157  {
23159  {
23160 
23161  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23162  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23163  MALP_EVENT_MPI, _container.event.mpi_event.type );
23164 
23165 
23166  Event_Packer_push(&otf_event);
23167  }
23168 
23169  /********************************/
23170  /* EMIT MALP EVENT */
23171  /********************************/
23172 
23173  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23174 
23175  /* Submit event if MPI instrumented */
23176  Event_Packer_push(&_container);
23177  }
23178 
23179 
23180  return ret;
23181 }
23182 int MPI_Type_extent( MPI_Datatype type, MPI_Aint * extent )
23183 {
23184 
23185  /* Virtualize MPI */
23186 
23187 
23188  /* Pre instrum */
23189  int _rank = Stream_desc_get()->mpi_rank;
23190 
23191  struct MALP_Trace_Event _container;
23192 
23193  /********************************/
23194  /* FILL MPI EVENT */
23195  /********************************/
23196 
23197  _container.event.mpi_event.type =
23198  T_MPI_ENUM(MPI_TYPE_EXTENT)
23199  ;
23200 
23201  /* Set default source & dest before override */
23202  _container.event.mpi_event.source = _rank;
23203  _container.event.mpi_event.dest = _rank;
23204 
23205 
23206 
23207 
23208 
23209 
23210 
23211 
23212  /* Fill in size informations if needed */
23213  int _size = 0;
23214  #if 0
23215 
23216  #endif
23217  _container.event.mpi_event.size = _size;
23218 
23219  /********************************/
23220  /* EMIT OTF ENTER */
23221  /********************************/
23222 
23223  struct MALP_Trace_Event otf_event;
23224 
23225  uint64_t _begin = Timer_tsc ();
23226 
23229  {
23230 
23231  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23232  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23233  MALP_EVENT_MPI, _container.event.mpi_event.type );
23234  Event_Packer_push(&otf_event);
23235  }
23236 
23237  /********************************/
23238  /* ACTUAL FUNCTION CALL */
23239  /********************************/
23240 
23242  int ret = PMPI_Type_extent( type, extent );
23244 
23245  /********************************/
23246  /* EMIT OTF END */
23247  /********************************/
23248 
23249  uint64_t _end = Timer_tsc();
23250  uint64_t _duration = _end - _begin;
23251 
23253  {
23255  {
23256 
23257  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23258  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23259  MALP_EVENT_MPI, _container.event.mpi_event.type );
23260 
23261 
23262  Event_Packer_push(&otf_event);
23263  }
23264 
23265  /********************************/
23266  /* EMIT MALP EVENT */
23267  /********************************/
23268 
23269  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23270 
23271  /* Submit event if MPI instrumented */
23272  Event_Packer_push(&_container);
23273  }
23274 
23275 
23276  return ret;
23277 }
23278 int MPI_Type_free( MPI_Datatype * type )
23279 {
23280 
23281  /* Virtualize MPI */
23282 
23283 
23284  /* Pre instrum */
23285  int _rank = Stream_desc_get()->mpi_rank;
23286 
23287  struct MALP_Trace_Event _container;
23288 
23289  /********************************/
23290  /* FILL MPI EVENT */
23291  /********************************/
23292 
23293  _container.event.mpi_event.type =
23294  T_MPI_ENUM(MPI_TYPE_FREE)
23295  ;
23296 
23297  /* Set default source & dest before override */
23298  _container.event.mpi_event.source = _rank;
23299  _container.event.mpi_event.dest = _rank;
23300 
23301 
23302 
23303 
23304 
23305 
23306 
23307 
23308  /* Fill in size informations if needed */
23309  int _size = 0;
23310  #if 0
23311 
23312  #endif
23313  _container.event.mpi_event.size = _size;
23314 
23315  /********************************/
23316  /* EMIT OTF ENTER */
23317  /********************************/
23318 
23319  struct MALP_Trace_Event otf_event;
23320 
23321  uint64_t _begin = Timer_tsc ();
23322 
23325  {
23326 
23327  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23328  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23329  MALP_EVENT_MPI, _container.event.mpi_event.type );
23330  Event_Packer_push(&otf_event);
23331  }
23332 
23333  /********************************/
23334  /* ACTUAL FUNCTION CALL */
23335  /********************************/
23336 
23338  int ret = PMPI_Type_free( type );
23340 
23341  /********************************/
23342  /* EMIT OTF END */
23343  /********************************/
23344 
23345  uint64_t _end = Timer_tsc();
23346  uint64_t _duration = _end - _begin;
23347 
23349  {
23351  {
23352 
23353  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23354  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23355  MALP_EVENT_MPI, _container.event.mpi_event.type );
23356 
23357 
23358  Event_Packer_push(&otf_event);
23359  }
23360 
23361  /********************************/
23362  /* EMIT MALP EVENT */
23363  /********************************/
23364 
23365  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23366 
23367  /* Submit event if MPI instrumented */
23368  Event_Packer_push(&_container);
23369  }
23370 
23371 
23372  return ret;
23373 }
23374 int MPI_Type_free_keyval( int * type_keyval )
23375 {
23376 
23377  /* Virtualize MPI */
23378 
23379 
23380  /* Pre instrum */
23381  int _rank = Stream_desc_get()->mpi_rank;
23382 
23383  struct MALP_Trace_Event _container;
23384 
23385  /********************************/
23386  /* FILL MPI EVENT */
23387  /********************************/
23388 
23389  _container.event.mpi_event.type =
23390  T_MPI_ENUM(MPI_TYPE_FREE_KEYVAL)
23391  ;
23392 
23393  /* Set default source & dest before override */
23394  _container.event.mpi_event.source = _rank;
23395  _container.event.mpi_event.dest = _rank;
23396 
23397 
23398 
23399 
23400 
23401 
23402 
23403 
23404  /* Fill in size informations if needed */
23405  int _size = 0;
23406  #if 0
23407 
23408  #endif
23409  _container.event.mpi_event.size = _size;
23410 
23411  /********************************/
23412  /* EMIT OTF ENTER */
23413  /********************************/
23414 
23415  struct MALP_Trace_Event otf_event;
23416 
23417  uint64_t _begin = Timer_tsc ();
23418 
23421  {
23422 
23423  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23424  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23425  MALP_EVENT_MPI, _container.event.mpi_event.type );
23426  Event_Packer_push(&otf_event);
23427  }
23428 
23429  /********************************/
23430  /* ACTUAL FUNCTION CALL */
23431  /********************************/
23432 
23434  int ret = PMPI_Type_free_keyval( type_keyval );
23436 
23437  /********************************/
23438  /* EMIT OTF END */
23439  /********************************/
23440 
23441  uint64_t _end = Timer_tsc();
23442  uint64_t _duration = _end - _begin;
23443 
23445  {
23447  {
23448 
23449  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23450  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23451  MALP_EVENT_MPI, _container.event.mpi_event.type );
23452 
23453 
23454  Event_Packer_push(&otf_event);
23455  }
23456 
23457  /********************************/
23458  /* EMIT MALP EVENT */
23459  /********************************/
23460 
23461  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23462 
23463  /* Submit event if MPI instrumented */
23464  Event_Packer_push(&_container);
23465  }
23466 
23467 
23468  return ret;
23469 }
23470 int MPI_Type_get_attr( MPI_Datatype type, int type_keyval, void * attribute_val, int * flag )
23471 {
23472 
23473  /* Virtualize MPI */
23474 
23475 
23476  /* Pre instrum */
23477  int _rank = Stream_desc_get()->mpi_rank;
23478 
23479  struct MALP_Trace_Event _container;
23480 
23481  /********************************/
23482  /* FILL MPI EVENT */
23483  /********************************/
23484 
23485  _container.event.mpi_event.type =
23486  T_MPI_ENUM(MPI_TYPE_GET_ATTR)
23487  ;
23488 
23489  /* Set default source & dest before override */
23490  _container.event.mpi_event.source = _rank;
23491  _container.event.mpi_event.dest = _rank;
23492 
23493 
23494 
23495 
23496 
23497 
23498 
23499 
23500  /* Fill in size informations if needed */
23501  int _size = 0;
23502  #if 0
23503 
23504  #endif
23505  _container.event.mpi_event.size = _size;
23506 
23507  /********************************/
23508  /* EMIT OTF ENTER */
23509  /********************************/
23510 
23511  struct MALP_Trace_Event otf_event;
23512 
23513  uint64_t _begin = Timer_tsc ();
23514 
23517  {
23518 
23519  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23520  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23521  MALP_EVENT_MPI, _container.event.mpi_event.type );
23522  Event_Packer_push(&otf_event);
23523  }
23524 
23525  /********************************/
23526  /* ACTUAL FUNCTION CALL */
23527  /********************************/
23528 
23530  int ret = PMPI_Type_get_attr( type, type_keyval, attribute_val, flag );
23532 
23533  /********************************/
23534  /* EMIT OTF END */
23535  /********************************/
23536 
23537  uint64_t _end = Timer_tsc();
23538  uint64_t _duration = _end - _begin;
23539 
23541  {
23543  {
23544 
23545  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23546  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23547  MALP_EVENT_MPI, _container.event.mpi_event.type );
23548 
23549 
23550  Event_Packer_push(&otf_event);
23551  }
23552 
23553  /********************************/
23554  /* EMIT MALP EVENT */
23555  /********************************/
23556 
23557  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23558 
23559  /* Submit event if MPI instrumented */
23560  Event_Packer_push(&_container);
23561  }
23562 
23563 
23564  return ret;
23565 }
23566 int MPI_Type_get_contents( MPI_Datatype mtype, int max_integers, int max_addresses, int max_datatypes, int array_of_integers[], MPI_Aint array_of_addresses[], MPI_Datatype array_of_datatypes[] )
23567 {
23568 
23569  /* Virtualize MPI */
23570 
23571 
23572  /* Pre instrum */
23573  int _rank = Stream_desc_get()->mpi_rank;
23574 
23575  struct MALP_Trace_Event _container;
23576 
23577  /********************************/
23578  /* FILL MPI EVENT */
23579  /********************************/
23580 
23581  _container.event.mpi_event.type =
23582  T_MPI_ENUM(MPI_TYPE_GET_CONTENTS)
23583  ;
23584 
23585  /* Set default source & dest before override */
23586  _container.event.mpi_event.source = _rank;
23587  _container.event.mpi_event.dest = _rank;
23588 
23589 
23590 
23591 
23592 
23593 
23594 
23595 
23596  /* Fill in size informations if needed */
23597  int _size = 0;
23598  #if 0
23599 
23600  #endif
23601  _container.event.mpi_event.size = _size;
23602 
23603  /********************************/
23604  /* EMIT OTF ENTER */
23605  /********************************/
23606 
23607  struct MALP_Trace_Event otf_event;
23608 
23609  uint64_t _begin = Timer_tsc ();
23610 
23613  {
23614 
23615  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23616  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23617  MALP_EVENT_MPI, _container.event.mpi_event.type );
23618  Event_Packer_push(&otf_event);
23619  }
23620 
23621  /********************************/
23622  /* ACTUAL FUNCTION CALL */
23623  /********************************/
23624 
23626  int ret = PMPI_Type_get_contents( mtype, max_integers, max_addresses, max_datatypes, array_of_integers, array_of_addresses, array_of_datatypes );
23628 
23629  /********************************/
23630  /* EMIT OTF END */
23631  /********************************/
23632 
23633  uint64_t _end = Timer_tsc();
23634  uint64_t _duration = _end - _begin;
23635 
23637  {
23639  {
23640 
23641  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23642  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23643  MALP_EVENT_MPI, _container.event.mpi_event.type );
23644 
23645 
23646  Event_Packer_push(&otf_event);
23647  }
23648 
23649  /********************************/
23650  /* EMIT MALP EVENT */
23651  /********************************/
23652 
23653  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23654 
23655  /* Submit event if MPI instrumented */
23656  Event_Packer_push(&_container);
23657  }
23658 
23659 
23660  return ret;
23661 }
23662 int MPI_Type_get_envelope( MPI_Datatype type, int * num_integers, int * num_addresses, int * num_datatypes, int * combiner )
23663 {
23664 
23665  /* Virtualize MPI */
23666 
23667 
23668  /* Pre instrum */
23669  int _rank = Stream_desc_get()->mpi_rank;
23670 
23671  struct MALP_Trace_Event _container;
23672 
23673  /********************************/
23674  /* FILL MPI EVENT */
23675  /********************************/
23676 
23677  _container.event.mpi_event.type =
23678  T_MPI_ENUM(MPI_TYPE_GET_ENVELOPE)
23679  ;
23680 
23681  /* Set default source & dest before override */
23682  _container.event.mpi_event.source = _rank;
23683  _container.event.mpi_event.dest = _rank;
23684 
23685 
23686 
23687 
23688 
23689 
23690 
23691 
23692  /* Fill in size informations if needed */
23693  int _size = 0;
23694  #if 0
23695 
23696  #endif
23697  _container.event.mpi_event.size = _size;
23698 
23699  /********************************/
23700  /* EMIT OTF ENTER */
23701  /********************************/
23702 
23703  struct MALP_Trace_Event otf_event;
23704 
23705  uint64_t _begin = Timer_tsc ();
23706 
23709  {
23710 
23711  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23712  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23713  MALP_EVENT_MPI, _container.event.mpi_event.type );
23714  Event_Packer_push(&otf_event);
23715  }
23716 
23717  /********************************/
23718  /* ACTUAL FUNCTION CALL */
23719  /********************************/
23720 
23722  int ret = PMPI_Type_get_envelope( type, num_integers, num_addresses, num_datatypes, combiner );
23724 
23725  /********************************/
23726  /* EMIT OTF END */
23727  /********************************/
23728 
23729  uint64_t _end = Timer_tsc();
23730  uint64_t _duration = _end - _begin;
23731 
23733  {
23735  {
23736 
23737  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23738  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23739  MALP_EVENT_MPI, _container.event.mpi_event.type );
23740 
23741 
23742  Event_Packer_push(&otf_event);
23743  }
23744 
23745  /********************************/
23746  /* EMIT MALP EVENT */
23747  /********************************/
23748 
23749  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23750 
23751  /* Submit event if MPI instrumented */
23752  Event_Packer_push(&_container);
23753  }
23754 
23755 
23756  return ret;
23757 }
23758 int MPI_Type_get_extent( MPI_Datatype type, MPI_Aint * lb, MPI_Aint * extent )
23759 {
23760 
23761  /* Virtualize MPI */
23762 
23763 
23764  /* Pre instrum */
23765  int _rank = Stream_desc_get()->mpi_rank;
23766 
23767  struct MALP_Trace_Event _container;
23768 
23769  /********************************/
23770  /* FILL MPI EVENT */
23771  /********************************/
23772 
23773  _container.event.mpi_event.type =
23774  T_MPI_ENUM(MPI_TYPE_GET_EXTENT)
23775  ;
23776 
23777  /* Set default source & dest before override */
23778  _container.event.mpi_event.source = _rank;
23779  _container.event.mpi_event.dest = _rank;
23780 
23781 
23782 
23783 
23784 
23785 
23786 
23787 
23788  /* Fill in size informations if needed */
23789  int _size = 0;
23790  #if 0
23791 
23792  #endif
23793  _container.event.mpi_event.size = _size;
23794 
23795  /********************************/
23796  /* EMIT OTF ENTER */
23797  /********************************/
23798 
23799  struct MALP_Trace_Event otf_event;
23800 
23801  uint64_t _begin = Timer_tsc ();
23802 
23805  {
23806 
23807  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23808  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23809  MALP_EVENT_MPI, _container.event.mpi_event.type );
23810  Event_Packer_push(&otf_event);
23811  }
23812 
23813  /********************************/
23814  /* ACTUAL FUNCTION CALL */
23815  /********************************/
23816 
23818  int ret = PMPI_Type_get_extent( type, lb, extent );
23820 
23821  /********************************/
23822  /* EMIT OTF END */
23823  /********************************/
23824 
23825  uint64_t _end = Timer_tsc();
23826  uint64_t _duration = _end - _begin;
23827 
23829  {
23831  {
23832 
23833  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23834  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23835  MALP_EVENT_MPI, _container.event.mpi_event.type );
23836 
23837 
23838  Event_Packer_push(&otf_event);
23839  }
23840 
23841  /********************************/
23842  /* EMIT MALP EVENT */
23843  /********************************/
23844 
23845  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23846 
23847  /* Submit event if MPI instrumented */
23848  Event_Packer_push(&_container);
23849  }
23850 
23851 
23852  return ret;
23853 }
23854 int MPI_Type_get_name( MPI_Datatype type, char * type_name, int * resultlen )
23855 {
23856 
23857  /* Virtualize MPI */
23858 
23859 
23860  /* Pre instrum */
23861  int _rank = Stream_desc_get()->mpi_rank;
23862 
23863  struct MALP_Trace_Event _container;
23864 
23865  /********************************/
23866  /* FILL MPI EVENT */
23867  /********************************/
23868 
23869  _container.event.mpi_event.type =
23870  T_MPI_ENUM(MPI_TYPE_GET_NAME)
23871  ;
23872 
23873  /* Set default source & dest before override */
23874  _container.event.mpi_event.source = _rank;
23875  _container.event.mpi_event.dest = _rank;
23876 
23877 
23878 
23879 
23880 
23881 
23882 
23883 
23884  /* Fill in size informations if needed */
23885  int _size = 0;
23886  #if 0
23887 
23888  #endif
23889  _container.event.mpi_event.size = _size;
23890 
23891  /********************************/
23892  /* EMIT OTF ENTER */
23893  /********************************/
23894 
23895  struct MALP_Trace_Event otf_event;
23896 
23897  uint64_t _begin = Timer_tsc ();
23898 
23901  {
23902 
23903  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
23904  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
23905  MALP_EVENT_MPI, _container.event.mpi_event.type );
23906  Event_Packer_push(&otf_event);
23907  }
23908 
23909  /********************************/
23910  /* ACTUAL FUNCTION CALL */
23911  /********************************/
23912 
23914  int ret = PMPI_Type_get_name( type, type_name, resultlen );
23916 
23917  /********************************/
23918  /* EMIT OTF END */
23919  /********************************/
23920 
23921  uint64_t _end = Timer_tsc();
23922  uint64_t _duration = _end - _begin;
23923 
23925  {
23927  {
23928 
23929  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
23930  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
23931  MALP_EVENT_MPI, _container.event.mpi_event.type );
23932 
23933 
23934  Event_Packer_push(&otf_event);
23935  }
23936 
23937  /********************************/
23938  /* EMIT MALP EVENT */
23939  /********************************/
23940 
23941  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
23942 
23943  /* Submit event if MPI instrumented */
23944  Event_Packer_push(&_container);
23945  }
23946 
23947 
23948  return ret;
23949 }
23950 int MPI_Type_get_true_extent( MPI_Datatype datatype, MPI_Aint * true_lb, MPI_Aint * true_extent )
23951 {
23952 
23953  /* Virtualize MPI */
23954 
23955 
23956  /* Pre instrum */
23957  int _rank = Stream_desc_get()->mpi_rank;
23958 
23959  struct MALP_Trace_Event _container;
23960 
23961  /********************************/
23962  /* FILL MPI EVENT */
23963  /********************************/
23964 
23965  _container.event.mpi_event.type =
23966  T_MPI_ENUM(MPI_TYPE_GET_TRUE_EXTENT)
23967  ;
23968 
23969  /* Set default source & dest before override */
23970  _container.event.mpi_event.source = _rank;
23971  _container.event.mpi_event.dest = _rank;
23972 
23973 
23974 
23975 
23976 
23977  SET_DATATYPE (datatype)
23978 
23979 
23980  /* Fill in size informations if needed */
23981  int _size = 0;
23982  #if 1
23983 
23984  #endif
23985  _container.event.mpi_event.size = _size;
23986 
23987  /********************************/
23988  /* EMIT OTF ENTER */
23989  /********************************/
23990 
23991  struct MALP_Trace_Event otf_event;
23992 
23993  uint64_t _begin = Timer_tsc ();
23994 
23997  {
23998 
23999  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24000  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24001  MALP_EVENT_MPI, _container.event.mpi_event.type );
24002  Event_Packer_push(&otf_event);
24003  }
24004 
24005  /********************************/
24006  /* ACTUAL FUNCTION CALL */
24007  /********************************/
24008 
24010  int ret = PMPI_Type_get_true_extent( datatype, true_lb, true_extent );
24012 
24013  /********************************/
24014  /* EMIT OTF END */
24015  /********************************/
24016 
24017  uint64_t _end = Timer_tsc();
24018  uint64_t _duration = _end - _begin;
24019 
24021  {
24023  {
24024 
24025  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24026  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24027  MALP_EVENT_MPI, _container.event.mpi_event.type );
24028 
24029 
24030  Event_Packer_push(&otf_event);
24031  }
24032 
24033  /********************************/
24034  /* EMIT MALP EVENT */
24035  /********************************/
24036 
24037  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24038 
24039  /* Submit event if MPI instrumented */
24040  Event_Packer_push(&_container);
24041  }
24042 
24043 
24044  return ret;
24045 }
24046 int MPI_Type_hindexed( int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
24047 {
24048 
24049  /* Virtualize MPI */
24050 
24051 
24052  /* Pre instrum */
24053  int _rank = Stream_desc_get()->mpi_rank;
24054 
24055  struct MALP_Trace_Event _container;
24056 
24057  /********************************/
24058  /* FILL MPI EVENT */
24059  /********************************/
24060 
24061  _container.event.mpi_event.type =
24062  T_MPI_ENUM(MPI_TYPE_HINDEXED)
24063  ;
24064 
24065  /* Set default source & dest before override */
24066  _container.event.mpi_event.source = _rank;
24067  _container.event.mpi_event.dest = _rank;
24068 
24069 
24070 
24071 
24072  SET_COUNT (count)
24073 
24074 
24075 
24076  /* Fill in size informations if needed */
24077  int _size = 0;
24078  #if 0
24079  COMP_SIZE (count)
24080  #endif
24081  _container.event.mpi_event.size = _size;
24082 
24083  /********************************/
24084  /* EMIT OTF ENTER */
24085  /********************************/
24086 
24087  struct MALP_Trace_Event otf_event;
24088 
24089  uint64_t _begin = Timer_tsc ();
24090 
24093  {
24094 
24095  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24096  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24097  MALP_EVENT_MPI, _container.event.mpi_event.type );
24098  Event_Packer_push(&otf_event);
24099  }
24100 
24101  /********************************/
24102  /* ACTUAL FUNCTION CALL */
24103  /********************************/
24104 
24106  int ret = PMPI_Type_hindexed( count, array_of_blocklengths, array_of_displacements, oldtype, newtype );
24108 
24109  /********************************/
24110  /* EMIT OTF END */
24111  /********************************/
24112 
24113  uint64_t _end = Timer_tsc();
24114  uint64_t _duration = _end - _begin;
24115 
24117  {
24119  {
24120 
24121  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24122  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24123  MALP_EVENT_MPI, _container.event.mpi_event.type );
24124 
24125 
24126  Event_Packer_push(&otf_event);
24127  }
24128 
24129  /********************************/
24130  /* EMIT MALP EVENT */
24131  /********************************/
24132 
24133  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24134 
24135  /* Submit event if MPI instrumented */
24136  Event_Packer_push(&_container);
24137  }
24138 
24139 
24140  return ret;
24141 }
24142 int MPI_Type_hvector( int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype * newtype )
24143 {
24144 
24145  /* Virtualize MPI */
24146 
24147 
24148  /* Pre instrum */
24149  int _rank = Stream_desc_get()->mpi_rank;
24150 
24151  struct MALP_Trace_Event _container;
24152 
24153  /********************************/
24154  /* FILL MPI EVENT */
24155  /********************************/
24156 
24157  _container.event.mpi_event.type =
24158  T_MPI_ENUM(MPI_TYPE_HVECTOR)
24159  ;
24160 
24161  /* Set default source & dest before override */
24162  _container.event.mpi_event.source = _rank;
24163  _container.event.mpi_event.dest = _rank;
24164 
24165 
24166 
24167 
24168  SET_COUNT (count)
24169 
24170 
24171 
24172  /* Fill in size informations if needed */
24173  int _size = 0;
24174  #if 0
24175  COMP_SIZE (count)
24176  #endif
24177  _container.event.mpi_event.size = _size;
24178 
24179  /********************************/
24180  /* EMIT OTF ENTER */
24181  /********************************/
24182 
24183  struct MALP_Trace_Event otf_event;
24184 
24185  uint64_t _begin = Timer_tsc ();
24186 
24189  {
24190 
24191  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24192  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24193  MALP_EVENT_MPI, _container.event.mpi_event.type );
24194  Event_Packer_push(&otf_event);
24195  }
24196 
24197  /********************************/
24198  /* ACTUAL FUNCTION CALL */
24199  /********************************/
24200 
24202  int ret = PMPI_Type_hvector( count, blocklength, stride, oldtype, newtype );
24204 
24205  /********************************/
24206  /* EMIT OTF END */
24207  /********************************/
24208 
24209  uint64_t _end = Timer_tsc();
24210  uint64_t _duration = _end - _begin;
24211 
24213  {
24215  {
24216 
24217  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24218  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24219  MALP_EVENT_MPI, _container.event.mpi_event.type );
24220 
24221 
24222  Event_Packer_push(&otf_event);
24223  }
24224 
24225  /********************************/
24226  /* EMIT MALP EVENT */
24227  /********************************/
24228 
24229  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24230 
24231  /* Submit event if MPI instrumented */
24232  Event_Packer_push(&_container);
24233  }
24234 
24235 
24236  return ret;
24237 }
24238 int MPI_Type_indexed( int count, int array_of_blocklengths[], int array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype * newtype )
24239 {
24240 
24241  /* Virtualize MPI */
24242 
24243 
24244  /* Pre instrum */
24245  int _rank = Stream_desc_get()->mpi_rank;
24246 
24247  struct MALP_Trace_Event _container;
24248 
24249  /********************************/
24250  /* FILL MPI EVENT */
24251  /********************************/
24252 
24253  _container.event.mpi_event.type =
24254  T_MPI_ENUM(MPI_TYPE_INDEXED)
24255  ;
24256 
24257  /* Set default source & dest before override */
24258  _container.event.mpi_event.source = _rank;
24259  _container.event.mpi_event.dest = _rank;
24260 
24261 
24262 
24263 
24264  SET_COUNT (count)
24265 
24266 
24267 
24268  /* Fill in size informations if needed */
24269  int _size = 0;
24270  #if 0
24271  COMP_SIZE (count)
24272  #endif
24273  _container.event.mpi_event.size = _size;
24274 
24275  /********************************/
24276  /* EMIT OTF ENTER */
24277  /********************************/
24278 
24279  struct MALP_Trace_Event otf_event;
24280 
24281  uint64_t _begin = Timer_tsc ();
24282 
24285  {
24286 
24287  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24288  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24289  MALP_EVENT_MPI, _container.event.mpi_event.type );
24290  Event_Packer_push(&otf_event);
24291  }
24292 
24293  /********************************/
24294  /* ACTUAL FUNCTION CALL */
24295  /********************************/
24296 
24298  int ret = PMPI_Type_indexed( count, array_of_blocklengths, array_of_displacements, oldtype, newtype );
24300 
24301  /********************************/
24302  /* EMIT OTF END */
24303  /********************************/
24304 
24305  uint64_t _end = Timer_tsc();
24306  uint64_t _duration = _end - _begin;
24307 
24309  {
24311  {
24312 
24313  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24314  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24315  MALP_EVENT_MPI, _container.event.mpi_event.type );
24316 
24317 
24318  Event_Packer_push(&otf_event);
24319  }
24320 
24321  /********************************/
24322  /* EMIT MALP EVENT */
24323  /********************************/
24324 
24325  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24326 
24327  /* Submit event if MPI instrumented */
24328  Event_Packer_push(&_container);
24329  }
24330 
24331 
24332  return ret;
24333 }
24334 int MPI_Type_lb( MPI_Datatype type, MPI_Aint * lb )
24335 {
24336 
24337  /* Virtualize MPI */
24338 
24339 
24340  /* Pre instrum */
24341  int _rank = Stream_desc_get()->mpi_rank;
24342 
24343  struct MALP_Trace_Event _container;
24344 
24345  /********************************/
24346  /* FILL MPI EVENT */
24347  /********************************/
24348 
24349  _container.event.mpi_event.type =
24350  T_MPI_ENUM(MPI_TYPE_LB)
24351  ;
24352 
24353  /* Set default source & dest before override */
24354  _container.event.mpi_event.source = _rank;
24355  _container.event.mpi_event.dest = _rank;
24356 
24357 
24358 
24359 
24360 
24361 
24362 
24363 
24364  /* Fill in size informations if needed */
24365  int _size = 0;
24366  #if 0
24367 
24368  #endif
24369  _container.event.mpi_event.size = _size;
24370 
24371  /********************************/
24372  /* EMIT OTF ENTER */
24373  /********************************/
24374 
24375  struct MALP_Trace_Event otf_event;
24376 
24377  uint64_t _begin = Timer_tsc ();
24378 
24381  {
24382 
24383  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24384  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24385  MALP_EVENT_MPI, _container.event.mpi_event.type );
24386  Event_Packer_push(&otf_event);
24387  }
24388 
24389  /********************************/
24390  /* ACTUAL FUNCTION CALL */
24391  /********************************/
24392 
24394  int ret = PMPI_Type_lb( type, lb );
24396 
24397  /********************************/
24398  /* EMIT OTF END */
24399  /********************************/
24400 
24401  uint64_t _end = Timer_tsc();
24402  uint64_t _duration = _end - _begin;
24403 
24405  {
24407  {
24408 
24409  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24410  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24411  MALP_EVENT_MPI, _container.event.mpi_event.type );
24412 
24413 
24414  Event_Packer_push(&otf_event);
24415  }
24416 
24417  /********************************/
24418  /* EMIT MALP EVENT */
24419  /********************************/
24420 
24421  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24422 
24423  /* Submit event if MPI instrumented */
24424  Event_Packer_push(&_container);
24425  }
24426 
24427 
24428  return ret;
24429 }
24430 int MPI_Type_match_size( int typeclass, int size, MPI_Datatype * type )
24431 {
24432 
24433  /* Virtualize MPI */
24434 
24435 
24436  /* Pre instrum */
24437  int _rank = Stream_desc_get()->mpi_rank;
24438 
24439  struct MALP_Trace_Event _container;
24440 
24441  /********************************/
24442  /* FILL MPI EVENT */
24443  /********************************/
24444 
24445  _container.event.mpi_event.type =
24446  T_MPI_ENUM(MPI_TYPE_MATCH_SIZE)
24447  ;
24448 
24449  /* Set default source & dest before override */
24450  _container.event.mpi_event.source = _rank;
24451  _container.event.mpi_event.dest = _rank;
24452 
24453 
24454 
24455 
24456 
24457 
24458 
24459 
24460  /* Fill in size informations if needed */
24461  int _size = 0;
24462  #if 0
24463 
24464  #endif
24465  _container.event.mpi_event.size = _size;
24466 
24467  /********************************/
24468  /* EMIT OTF ENTER */
24469  /********************************/
24470 
24471  struct MALP_Trace_Event otf_event;
24472 
24473  uint64_t _begin = Timer_tsc ();
24474 
24477  {
24478 
24479  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24480  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24481  MALP_EVENT_MPI, _container.event.mpi_event.type );
24482  Event_Packer_push(&otf_event);
24483  }
24484 
24485  /********************************/
24486  /* ACTUAL FUNCTION CALL */
24487  /********************************/
24488 
24490  int ret = PMPI_Type_match_size( typeclass, size, type );
24492 
24493  /********************************/
24494  /* EMIT OTF END */
24495  /********************************/
24496 
24497  uint64_t _end = Timer_tsc();
24498  uint64_t _duration = _end - _begin;
24499 
24501  {
24503  {
24504 
24505  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24506  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24507  MALP_EVENT_MPI, _container.event.mpi_event.type );
24508 
24509 
24510  Event_Packer_push(&otf_event);
24511  }
24512 
24513  /********************************/
24514  /* EMIT MALP EVENT */
24515  /********************************/
24516 
24517  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24518 
24519  /* Submit event if MPI instrumented */
24520  Event_Packer_push(&_container);
24521  }
24522 
24523 
24524  return ret;
24525 }
24526 int MPI_Type_set_attr( MPI_Datatype type, int type_keyval, void * attr_val )
24527 {
24528 
24529  /* Virtualize MPI */
24530 
24531 
24532  /* Pre instrum */
24533  int _rank = Stream_desc_get()->mpi_rank;
24534 
24535  struct MALP_Trace_Event _container;
24536 
24537  /********************************/
24538  /* FILL MPI EVENT */
24539  /********************************/
24540 
24541  _container.event.mpi_event.type =
24542  T_MPI_ENUM(MPI_TYPE_SET_ATTR)
24543  ;
24544 
24545  /* Set default source & dest before override */
24546  _container.event.mpi_event.source = _rank;
24547  _container.event.mpi_event.dest = _rank;
24548 
24549 
24550 
24551 
24552 
24553 
24554 
24555 
24556  /* Fill in size informations if needed */
24557  int _size = 0;
24558  #if 0
24559 
24560  #endif
24561  _container.event.mpi_event.size = _size;
24562 
24563  /********************************/
24564  /* EMIT OTF ENTER */
24565  /********************************/
24566 
24567  struct MALP_Trace_Event otf_event;
24568 
24569  uint64_t _begin = Timer_tsc ();
24570 
24573  {
24574 
24575  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24576  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24577  MALP_EVENT_MPI, _container.event.mpi_event.type );
24578  Event_Packer_push(&otf_event);
24579  }
24580 
24581  /********************************/
24582  /* ACTUAL FUNCTION CALL */
24583  /********************************/
24584 
24586  int ret = PMPI_Type_set_attr( type, type_keyval, attr_val );
24588 
24589  /********************************/
24590  /* EMIT OTF END */
24591  /********************************/
24592 
24593  uint64_t _end = Timer_tsc();
24594  uint64_t _duration = _end - _begin;
24595 
24597  {
24599  {
24600 
24601  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24602  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24603  MALP_EVENT_MPI, _container.event.mpi_event.type );
24604 
24605 
24606  Event_Packer_push(&otf_event);
24607  }
24608 
24609  /********************************/
24610  /* EMIT MALP EVENT */
24611  /********************************/
24612 
24613  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24614 
24615  /* Submit event if MPI instrumented */
24616  Event_Packer_push(&_container);
24617  }
24618 
24619 
24620  return ret;
24621 }
24622 int MPI_Type_set_name( MPI_Datatype type, char * type_name )
24623 {
24624 
24625  /* Virtualize MPI */
24626 
24627 
24628  /* Pre instrum */
24629  int _rank = Stream_desc_get()->mpi_rank;
24630 
24631  struct MALP_Trace_Event _container;
24632 
24633  /********************************/
24634  /* FILL MPI EVENT */
24635  /********************************/
24636 
24637  _container.event.mpi_event.type =
24638  T_MPI_ENUM(MPI_TYPE_SET_NAME)
24639  ;
24640 
24641  /* Set default source & dest before override */
24642  _container.event.mpi_event.source = _rank;
24643  _container.event.mpi_event.dest = _rank;
24644 
24645 
24646 
24647 
24648 
24649 
24650 
24651 
24652  /* Fill in size informations if needed */
24653  int _size = 0;
24654  #if 0
24655 
24656  #endif
24657  _container.event.mpi_event.size = _size;
24658 
24659  /********************************/
24660  /* EMIT OTF ENTER */
24661  /********************************/
24662 
24663  struct MALP_Trace_Event otf_event;
24664 
24665  uint64_t _begin = Timer_tsc ();
24666 
24669  {
24670 
24671  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24672  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24673  MALP_EVENT_MPI, _container.event.mpi_event.type );
24674  Event_Packer_push(&otf_event);
24675  }
24676 
24677  /********************************/
24678  /* ACTUAL FUNCTION CALL */
24679  /********************************/
24680 
24682  int ret = PMPI_Type_set_name( type, type_name );
24684 
24685  /********************************/
24686  /* EMIT OTF END */
24687  /********************************/
24688 
24689  uint64_t _end = Timer_tsc();
24690  uint64_t _duration = _end - _begin;
24691 
24693  {
24695  {
24696 
24697  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24698  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24699  MALP_EVENT_MPI, _container.event.mpi_event.type );
24700 
24701 
24702  Event_Packer_push(&otf_event);
24703  }
24704 
24705  /********************************/
24706  /* EMIT MALP EVENT */
24707  /********************************/
24708 
24709  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24710 
24711  /* Submit event if MPI instrumented */
24712  Event_Packer_push(&_container);
24713  }
24714 
24715 
24716  return ret;
24717 }
24718 int MPI_Type_size( MPI_Datatype type, int * size )
24719 {
24720 
24721  /* Virtualize MPI */
24722 
24723 
24724  /* Pre instrum */
24725  int _rank = Stream_desc_get()->mpi_rank;
24726 
24727  struct MALP_Trace_Event _container;
24728 
24729  /********************************/
24730  /* FILL MPI EVENT */
24731  /********************************/
24732 
24733  _container.event.mpi_event.type =
24734  T_MPI_ENUM(MPI_TYPE_SIZE)
24735  ;
24736 
24737  /* Set default source & dest before override */
24738  _container.event.mpi_event.source = _rank;
24739  _container.event.mpi_event.dest = _rank;
24740 
24741 
24742 
24743 
24744 
24745 
24746 
24747 
24748  /* Fill in size informations if needed */
24749  int _size = 0;
24750  #if 0
24751 
24752  #endif
24753  _container.event.mpi_event.size = _size;
24754 
24755  /********************************/
24756  /* EMIT OTF ENTER */
24757  /********************************/
24758 
24759  struct MALP_Trace_Event otf_event;
24760 
24761  uint64_t _begin = Timer_tsc ();
24762 
24765  {
24766 
24767  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24768  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24769  MALP_EVENT_MPI, _container.event.mpi_event.type );
24770  Event_Packer_push(&otf_event);
24771  }
24772 
24773  /********************************/
24774  /* ACTUAL FUNCTION CALL */
24775  /********************************/
24776 
24778  int ret = PMPI_Type_size( type, size );
24780 
24781  /********************************/
24782  /* EMIT OTF END */
24783  /********************************/
24784 
24785  uint64_t _end = Timer_tsc();
24786  uint64_t _duration = _end - _begin;
24787 
24789  {
24791  {
24792 
24793  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24794  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24795  MALP_EVENT_MPI, _container.event.mpi_event.type );
24796 
24797 
24798  Event_Packer_push(&otf_event);
24799  }
24800 
24801  /********************************/
24802  /* EMIT MALP EVENT */
24803  /********************************/
24804 
24805  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24806 
24807  /* Submit event if MPI instrumented */
24808  Event_Packer_push(&_container);
24809  }
24810 
24811 
24812  return ret;
24813 }
24814 int MPI_Type_struct( int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype array_of_types[], MPI_Datatype * newtype )
24815 {
24816 
24817  /* Virtualize MPI */
24818 
24819 
24820  /* Pre instrum */
24821  int _rank = Stream_desc_get()->mpi_rank;
24822 
24823  struct MALP_Trace_Event _container;
24824 
24825  /********************************/
24826  /* FILL MPI EVENT */
24827  /********************************/
24828 
24829  _container.event.mpi_event.type =
24830  T_MPI_ENUM(MPI_TYPE_STRUCT)
24831  ;
24832 
24833  /* Set default source & dest before override */
24834  _container.event.mpi_event.source = _rank;
24835  _container.event.mpi_event.dest = _rank;
24836 
24837 
24838 
24839 
24840  SET_COUNT (count)
24841 
24842 
24843 
24844  /* Fill in size informations if needed */
24845  int _size = 0;
24846  #if 0
24847  COMP_SIZE (count)
24848  #endif
24849  _container.event.mpi_event.size = _size;
24850 
24851  /********************************/
24852  /* EMIT OTF ENTER */
24853  /********************************/
24854 
24855  struct MALP_Trace_Event otf_event;
24856 
24857  uint64_t _begin = Timer_tsc ();
24858 
24861  {
24862 
24863  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24864  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24865  MALP_EVENT_MPI, _container.event.mpi_event.type );
24866  Event_Packer_push(&otf_event);
24867  }
24868 
24869  /********************************/
24870  /* ACTUAL FUNCTION CALL */
24871  /********************************/
24872 
24874  int ret = PMPI_Type_struct( count, array_of_blocklengths, array_of_displacements, array_of_types, newtype );
24876 
24877  /********************************/
24878  /* EMIT OTF END */
24879  /********************************/
24880 
24881  uint64_t _end = Timer_tsc();
24882  uint64_t _duration = _end - _begin;
24883 
24885  {
24887  {
24888 
24889  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24890  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24891  MALP_EVENT_MPI, _container.event.mpi_event.type );
24892 
24893 
24894  Event_Packer_push(&otf_event);
24895  }
24896 
24897  /********************************/
24898  /* EMIT MALP EVENT */
24899  /********************************/
24900 
24901  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24902 
24903  /* Submit event if MPI instrumented */
24904  Event_Packer_push(&_container);
24905  }
24906 
24907 
24908  return ret;
24909 }
24910 int MPI_Type_ub( MPI_Datatype mtype, MPI_Aint * ub )
24911 {
24912 
24913  /* Virtualize MPI */
24914 
24915 
24916  /* Pre instrum */
24917  int _rank = Stream_desc_get()->mpi_rank;
24918 
24919  struct MALP_Trace_Event _container;
24920 
24921  /********************************/
24922  /* FILL MPI EVENT */
24923  /********************************/
24924 
24925  _container.event.mpi_event.type =
24926  T_MPI_ENUM(MPI_TYPE_UB)
24927  ;
24928 
24929  /* Set default source & dest before override */
24930  _container.event.mpi_event.source = _rank;
24931  _container.event.mpi_event.dest = _rank;
24932 
24933 
24934 
24935 
24936 
24937 
24938 
24939 
24940  /* Fill in size informations if needed */
24941  int _size = 0;
24942  #if 0
24943 
24944  #endif
24945  _container.event.mpi_event.size = _size;
24946 
24947  /********************************/
24948  /* EMIT OTF ENTER */
24949  /********************************/
24950 
24951  struct MALP_Trace_Event otf_event;
24952 
24953  uint64_t _begin = Timer_tsc ();
24954 
24957  {
24958 
24959  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
24960  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
24961  MALP_EVENT_MPI, _container.event.mpi_event.type );
24962  Event_Packer_push(&otf_event);
24963  }
24964 
24965  /********************************/
24966  /* ACTUAL FUNCTION CALL */
24967  /********************************/
24968 
24970  int ret = PMPI_Type_ub( mtype, ub );
24972 
24973  /********************************/
24974  /* EMIT OTF END */
24975  /********************************/
24976 
24977  uint64_t _end = Timer_tsc();
24978  uint64_t _duration = _end - _begin;
24979 
24981  {
24983  {
24984 
24985  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
24986  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
24987  MALP_EVENT_MPI, _container.event.mpi_event.type );
24988 
24989 
24990  Event_Packer_push(&otf_event);
24991  }
24992 
24993  /********************************/
24994  /* EMIT MALP EVENT */
24995  /********************************/
24996 
24997  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
24998 
24999  /* Submit event if MPI instrumented */
25000  Event_Packer_push(&_container);
25001  }
25002 
25003 
25004  return ret;
25005 }
25006 int MPI_Type_vector( int count, int blocklength, int stride, MPI_Datatype oldtype, MPI_Datatype * newtype )
25007 {
25008 
25009  /* Virtualize MPI */
25010 
25011 
25012  /* Pre instrum */
25013  int _rank = Stream_desc_get()->mpi_rank;
25014 
25015  struct MALP_Trace_Event _container;
25016 
25017  /********************************/
25018  /* FILL MPI EVENT */
25019  /********************************/
25020 
25021  _container.event.mpi_event.type =
25022  T_MPI_ENUM(MPI_TYPE_VECTOR)
25023  ;
25024 
25025  /* Set default source & dest before override */
25026  _container.event.mpi_event.source = _rank;
25027  _container.event.mpi_event.dest = _rank;
25028 
25029 
25030 
25031 
25032  SET_COUNT (count)
25033 
25034 
25035 
25036  /* Fill in size informations if needed */
25037  int _size = 0;
25038  #if 0
25039  COMP_SIZE (count)
25040  #endif
25041  _container.event.mpi_event.size = _size;
25042 
25043  /********************************/
25044  /* EMIT OTF ENTER */
25045  /********************************/
25046 
25047  struct MALP_Trace_Event otf_event;
25048 
25049  uint64_t _begin = Timer_tsc ();
25050 
25053  {
25054 
25055  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25056  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25057  MALP_EVENT_MPI, _container.event.mpi_event.type );
25058  Event_Packer_push(&otf_event);
25059  }
25060 
25061  /********************************/
25062  /* ACTUAL FUNCTION CALL */
25063  /********************************/
25064 
25066  int ret = PMPI_Type_vector( count, blocklength, stride, oldtype, newtype );
25068 
25069  /********************************/
25070  /* EMIT OTF END */
25071  /********************************/
25072 
25073  uint64_t _end = Timer_tsc();
25074  uint64_t _duration = _end - _begin;
25075 
25077  {
25079  {
25080 
25081  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25082  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25083  MALP_EVENT_MPI, _container.event.mpi_event.type );
25084 
25085 
25086  Event_Packer_push(&otf_event);
25087  }
25088 
25089  /********************************/
25090  /* EMIT MALP EVENT */
25091  /********************************/
25092 
25093  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25094 
25095  /* Submit event if MPI instrumented */
25096  Event_Packer_push(&_container);
25097  }
25098 
25099 
25100  return ret;
25101 }
25102 int MPI_Unpack( void * inbuf, int insize, int * position, void * outbuf, int outcount, MPI_Datatype datatype, MPI_Comm comm )
25103 {
25104 
25105  /* Virtualize MPI */
25106  MACRO_MPI_Comm (comm)
25107 
25108  /* Pre instrum */
25109  int _rank = Stream_desc_get()->mpi_rank;
25110 
25111  struct MALP_Trace_Event _container;
25112 
25113  /********************************/
25114  /* FILL MPI EVENT */
25115  /********************************/
25116 
25117  _container.event.mpi_event.type =
25118  T_MPI_ENUM(MPI_UNPACK)
25119  ;
25120 
25121  /* Set default source & dest before override */
25122  _container.event.mpi_event.source = _rank;
25123  _container.event.mpi_event.dest = _rank;
25124 
25125 
25126 
25127 
25128 
25129  SET_DATATYPE (datatype)
25130  SET_COMM (comm)
25131 
25132  /* Fill in size informations if needed */
25133  int _size = 0;
25134  #if 1
25135 
25136  #endif
25137  _container.event.mpi_event.size = _size;
25138 
25139  /********************************/
25140  /* EMIT OTF ENTER */
25141  /********************************/
25142 
25143  struct MALP_Trace_Event otf_event;
25144 
25145  uint64_t _begin = Timer_tsc ();
25146 
25149  {
25150 
25151  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25152  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25153  MALP_EVENT_MPI, _container.event.mpi_event.type );
25154  Event_Packer_push(&otf_event);
25155  }
25156 
25157  /********************************/
25158  /* ACTUAL FUNCTION CALL */
25159  /********************************/
25160 
25162  int ret = PMPI_Unpack( inbuf, insize, position, outbuf, outcount, datatype, comm );
25164 
25165  /********************************/
25166  /* EMIT OTF END */
25167  /********************************/
25168 
25169  uint64_t _end = Timer_tsc();
25170  uint64_t _duration = _end - _begin;
25171 
25173  {
25175  {
25176 
25177  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25178  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25179  MALP_EVENT_MPI, _container.event.mpi_event.type );
25180 
25181 
25182  Event_Packer_push(&otf_event);
25183  }
25184 
25185  /********************************/
25186  /* EMIT MALP EVENT */
25187  /********************************/
25188 
25189  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25190 
25191  /* Submit event if MPI instrumented */
25192  Event_Packer_push(&_container);
25193  }
25194 
25195 
25196  return ret;
25197 }
25198 int MPI_Unpublish_name( char * service_name, MPI_Info info, char * port_name )
25199 {
25200 
25201  /* Virtualize MPI */
25202 
25203 
25204  /* Pre instrum */
25205  int _rank = Stream_desc_get()->mpi_rank;
25206 
25207  struct MALP_Trace_Event _container;
25208 
25209  /********************************/
25210  /* FILL MPI EVENT */
25211  /********************************/
25212 
25213  _container.event.mpi_event.type =
25214  T_MPI_ENUM(MPI_UNPUBLISH_NAME)
25215  ;
25216 
25217  /* Set default source & dest before override */
25218  _container.event.mpi_event.source = _rank;
25219  _container.event.mpi_event.dest = _rank;
25220 
25221 
25222 
25223 
25224 
25225 
25226 
25227 
25228  /* Fill in size informations if needed */
25229  int _size = 0;
25230  #if 0
25231 
25232  #endif
25233  _container.event.mpi_event.size = _size;
25234 
25235  /********************************/
25236  /* EMIT OTF ENTER */
25237  /********************************/
25238 
25239  struct MALP_Trace_Event otf_event;
25240 
25241  uint64_t _begin = Timer_tsc ();
25242 
25245  {
25246 
25247  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25248  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25249  MALP_EVENT_MPI, _container.event.mpi_event.type );
25250  Event_Packer_push(&otf_event);
25251  }
25252 
25253  /********************************/
25254  /* ACTUAL FUNCTION CALL */
25255  /********************************/
25256 
25258  int ret = PMPI_Unpublish_name( service_name, info, port_name );
25260 
25261  /********************************/
25262  /* EMIT OTF END */
25263  /********************************/
25264 
25265  uint64_t _end = Timer_tsc();
25266  uint64_t _duration = _end - _begin;
25267 
25269  {
25271  {
25272 
25273  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25274  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25275  MALP_EVENT_MPI, _container.event.mpi_event.type );
25276 
25277 
25278  Event_Packer_push(&otf_event);
25279  }
25280 
25281  /********************************/
25282  /* EMIT MALP EVENT */
25283  /********************************/
25284 
25285  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25286 
25287  /* Submit event if MPI instrumented */
25288  Event_Packer_push(&_container);
25289  }
25290 
25291 
25292  return ret;
25293 }
25294 int MPI_Unpack_external( char * datarep, void * inbuf, MPI_Aint insize, MPI_Aint * position, void * outbuf, int outcount, MPI_Datatype datatype )
25295 {
25296 
25297  /* Virtualize MPI */
25298 
25299 
25300  /* Pre instrum */
25301  int _rank = Stream_desc_get()->mpi_rank;
25302 
25303  struct MALP_Trace_Event _container;
25304 
25305  /********************************/
25306  /* FILL MPI EVENT */
25307  /********************************/
25308 
25309  _container.event.mpi_event.type =
25310  T_MPI_ENUM(MPI_UNPACK_EXTERNAL)
25311  ;
25312 
25313  /* Set default source & dest before override */
25314  _container.event.mpi_event.source = _rank;
25315  _container.event.mpi_event.dest = _rank;
25316 
25317 
25318 
25319 
25320 
25321  SET_DATATYPE (datatype)
25322 
25323 
25324  /* Fill in size informations if needed */
25325  int _size = 0;
25326  #if 1
25327 
25328  #endif
25329  _container.event.mpi_event.size = _size;
25330 
25331  /********************************/
25332  /* EMIT OTF ENTER */
25333  /********************************/
25334 
25335  struct MALP_Trace_Event otf_event;
25336 
25337  uint64_t _begin = Timer_tsc ();
25338 
25341  {
25342 
25343  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25344  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25345  MALP_EVENT_MPI, _container.event.mpi_event.type );
25346  Event_Packer_push(&otf_event);
25347  }
25348 
25349  /********************************/
25350  /* ACTUAL FUNCTION CALL */
25351  /********************************/
25352 
25354  int ret = PMPI_Unpack_external( datarep, inbuf, insize, position, outbuf, outcount, datatype );
25356 
25357  /********************************/
25358  /* EMIT OTF END */
25359  /********************************/
25360 
25361  uint64_t _end = Timer_tsc();
25362  uint64_t _duration = _end - _begin;
25363 
25365  {
25367  {
25368 
25369  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25370  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25371  MALP_EVENT_MPI, _container.event.mpi_event.type );
25372 
25373 
25374  Event_Packer_push(&otf_event);
25375  }
25376 
25377  /********************************/
25378  /* EMIT MALP EVENT */
25379  /********************************/
25380 
25381  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25382 
25383  /* Submit event if MPI instrumented */
25384  Event_Packer_push(&_container);
25385  }
25386 
25387 
25388  return ret;
25389 }
25390 int MPI_Waitall( int count, MPI_Request * array_of_requests, MPI_Status * array_of_statuses )
25391 {
25392 
25393  /* Virtualize MPI */
25394 
25395 
25396  /* Pre instrum */
25397  int _rank = Stream_desc_get()->mpi_rank;
25398 
25399  struct MALP_Trace_Event _container;
25400 
25401  /********************************/
25402  /* FILL MPI EVENT */
25403  /********************************/
25404 
25405  _container.event.mpi_event.type =
25406  T_MPI_ENUM(MPI_WAITALL)
25407  ;
25408 
25409  /* Set default source & dest before override */
25410  _container.event.mpi_event.source = _rank;
25411  _container.event.mpi_event.dest = _rank;
25412 
25413 
25414 
25415 
25416  SET_COUNT (count)
25417 
25418 
25419 
25420  /* Fill in size informations if needed */
25421  int _size = 0;
25422  #if 0
25423  COMP_SIZE (count)
25424  #endif
25425  _container.event.mpi_event.size = _size;
25426 
25427  /********************************/
25428  /* EMIT OTF ENTER */
25429  /********************************/
25430 
25431  struct MALP_Trace_Event otf_event;
25432 
25433  uint64_t _begin = Timer_tsc ();
25434 
25437  {
25438 
25439  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25440  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25441  MALP_EVENT_MPI, _container.event.mpi_event.type );
25442  Event_Packer_push(&otf_event);
25443  }
25444 
25445  /********************************/
25446  /* ACTUAL FUNCTION CALL */
25447  /********************************/
25448 
25450  int ret = PMPI_Waitall( count, array_of_requests, array_of_statuses );
25452 
25453  /********************************/
25454  /* EMIT OTF END */
25455  /********************************/
25456 
25457  uint64_t _end = Timer_tsc();
25458  uint64_t _duration = _end - _begin;
25459 
25461  {
25463  {
25464 
25465  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25466  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25467  MALP_EVENT_MPI, _container.event.mpi_event.type );
25468 
25469 
25470  Event_Packer_push(&otf_event);
25471  }
25472 
25473  /********************************/
25474  /* EMIT MALP EVENT */
25475  /********************************/
25476 
25477  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25478 
25479  /* Submit event if MPI instrumented */
25480  Event_Packer_push(&_container);
25481  }
25482 
25483 
25484  return ret;
25485 }
25486 int MPI_Waitany( int count, MPI_Request * array_of_requests, int * index, MPI_Status * status )
25487 {
25488 
25489  /* Virtualize MPI */
25490 
25491 
25492  /* Pre instrum */
25493  int _rank = Stream_desc_get()->mpi_rank;
25494 
25495  struct MALP_Trace_Event _container;
25496 
25497  /********************************/
25498  /* FILL MPI EVENT */
25499  /********************************/
25500 
25501  _container.event.mpi_event.type =
25502  T_MPI_ENUM(MPI_WAITANY)
25503  ;
25504 
25505  /* Set default source & dest before override */
25506  _container.event.mpi_event.source = _rank;
25507  _container.event.mpi_event.dest = _rank;
25508 
25509 
25510 
25511 
25512  SET_COUNT (count)
25513 
25514 
25515 
25516  /* Fill in size informations if needed */
25517  int _size = 0;
25518  #if 0
25519  COMP_SIZE (count)
25520  #endif
25521  _container.event.mpi_event.size = _size;
25522 
25523  /********************************/
25524  /* EMIT OTF ENTER */
25525  /********************************/
25526 
25527  struct MALP_Trace_Event otf_event;
25528 
25529  uint64_t _begin = Timer_tsc ();
25530 
25533  {
25534 
25535  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25536  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25537  MALP_EVENT_MPI, _container.event.mpi_event.type );
25538  Event_Packer_push(&otf_event);
25539  }
25540 
25541  /********************************/
25542  /* ACTUAL FUNCTION CALL */
25543  /********************************/
25544 
25546  int ret = PMPI_Waitany( count, array_of_requests, index, status );
25548 
25549  /********************************/
25550  /* EMIT OTF END */
25551  /********************************/
25552 
25553  uint64_t _end = Timer_tsc();
25554  uint64_t _duration = _end - _begin;
25555 
25557  {
25559  {
25560 
25561  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25562  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25563  MALP_EVENT_MPI, _container.event.mpi_event.type );
25564 
25565 
25566  Event_Packer_push(&otf_event);
25567  }
25568 
25569  /********************************/
25570  /* EMIT MALP EVENT */
25571  /********************************/
25572 
25573  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25574 
25575  /* Submit event if MPI instrumented */
25576  Event_Packer_push(&_container);
25577  }
25578 
25579 
25580  return ret;
25581 }
25582 int MPI_Wait( MPI_Request * request, MPI_Status * status )
25583 {
25584 
25585  /* Virtualize MPI */
25586 
25587 
25588  /* Pre instrum */
25589  int _rank = Stream_desc_get()->mpi_rank;
25590 
25591  struct MALP_Trace_Event _container;
25592 
25593  /********************************/
25594  /* FILL MPI EVENT */
25595  /********************************/
25596 
25597  _container.event.mpi_event.type =
25598  T_MPI_ENUM(MPI_WAIT)
25599  ;
25600 
25601  /* Set default source & dest before override */
25602  _container.event.mpi_event.source = _rank;
25603  _container.event.mpi_event.dest = _rank;
25604 
25605 
25606 
25607 
25608 
25609 
25610 
25611 
25612  /* Fill in size informations if needed */
25613  int _size = 0;
25614  #if 0
25615 
25616  #endif
25617  _container.event.mpi_event.size = _size;
25618 
25619  /********************************/
25620  /* EMIT OTF ENTER */
25621  /********************************/
25622 
25623  struct MALP_Trace_Event otf_event;
25624 
25625  uint64_t _begin = Timer_tsc ();
25626 
25629  {
25630 
25631  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25632  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25633  MALP_EVENT_MPI, _container.event.mpi_event.type );
25634  Event_Packer_push(&otf_event);
25635  }
25636 
25637  /********************************/
25638  /* ACTUAL FUNCTION CALL */
25639  /********************************/
25640 
25642  int ret = PMPI_Wait( request, status );
25644 
25645  /********************************/
25646  /* EMIT OTF END */
25647  /********************************/
25648 
25649  uint64_t _end = Timer_tsc();
25650  uint64_t _duration = _end - _begin;
25651 
25653  {
25655  {
25656 
25657  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25658  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25659  MALP_EVENT_MPI, _container.event.mpi_event.type );
25660 
25661 
25662  Event_Packer_push(&otf_event);
25663  }
25664 
25665  /********************************/
25666  /* EMIT MALP EVENT */
25667  /********************************/
25668 
25669  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25670 
25671  /* Submit event if MPI instrumented */
25672  Event_Packer_push(&_container);
25673  }
25674 
25675 
25676  return ret;
25677 }
25678 int MPI_Waitsome( int incount, MPI_Request * array_of_requests, int * outcount, int * array_of_indices, MPI_Status * array_of_statuses )
25679 {
25680 
25681  /* Virtualize MPI */
25682 
25683 
25684  /* Pre instrum */
25685  int _rank = Stream_desc_get()->mpi_rank;
25686 
25687  struct MALP_Trace_Event _container;
25688 
25689  /********************************/
25690  /* FILL MPI EVENT */
25691  /********************************/
25692 
25693  _container.event.mpi_event.type =
25694  T_MPI_ENUM(MPI_WAITSOME)
25695  ;
25696 
25697  /* Set default source & dest before override */
25698  _container.event.mpi_event.source = _rank;
25699  _container.event.mpi_event.dest = _rank;
25700 
25701 
25702 
25703 
25704 
25705 
25706 
25707 
25708  /* Fill in size informations if needed */
25709  int _size = 0;
25710  #if 0
25711 
25712  #endif
25713  _container.event.mpi_event.size = _size;
25714 
25715  /********************************/
25716  /* EMIT OTF ENTER */
25717  /********************************/
25718 
25719  struct MALP_Trace_Event otf_event;
25720 
25721  uint64_t _begin = Timer_tsc ();
25722 
25725  {
25726 
25727  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25728  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25729  MALP_EVENT_MPI, _container.event.mpi_event.type );
25730  Event_Packer_push(&otf_event);
25731  }
25732 
25733  /********************************/
25734  /* ACTUAL FUNCTION CALL */
25735  /********************************/
25736 
25738  int ret = PMPI_Waitsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );
25740 
25741  /********************************/
25742  /* EMIT OTF END */
25743  /********************************/
25744 
25745  uint64_t _end = Timer_tsc();
25746  uint64_t _duration = _end - _begin;
25747 
25749  {
25751  {
25752 
25753  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25754  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25755  MALP_EVENT_MPI, _container.event.mpi_event.type );
25756 
25757 
25758  Event_Packer_push(&otf_event);
25759  }
25760 
25761  /********************************/
25762  /* EMIT MALP EVENT */
25763  /********************************/
25764 
25765  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25766 
25767  /* Submit event if MPI instrumented */
25768  Event_Packer_push(&_container);
25769  }
25770 
25771 
25772  return ret;
25773 }
25774 int MPI_Win_c2f( MPI_Win win )
25775 {
25776 
25777  /* Virtualize MPI */
25778 
25779 
25780  /* Pre instrum */
25781  int _rank = Stream_desc_get()->mpi_rank;
25782 
25783  struct MALP_Trace_Event _container;
25784 
25785  /********************************/
25786  /* FILL MPI EVENT */
25787  /********************************/
25788 
25789  _container.event.mpi_event.type =
25790  T_MPI_ENUM(MPI_WIN_C2F)
25791  ;
25792 
25793  /* Set default source & dest before override */
25794  _container.event.mpi_event.source = _rank;
25795  _container.event.mpi_event.dest = _rank;
25796 
25797 
25798 
25799 
25800 
25801 
25802 
25803 
25804  /* Fill in size informations if needed */
25805  int _size = 0;
25806  #if 0
25807 
25808  #endif
25809  _container.event.mpi_event.size = _size;
25810 
25811  /********************************/
25812  /* EMIT OTF ENTER */
25813  /********************************/
25814 
25815  struct MALP_Trace_Event otf_event;
25816 
25817  uint64_t _begin = Timer_tsc ();
25818 
25821  {
25822 
25823  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25824  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25825  MALP_EVENT_MPI, _container.event.mpi_event.type );
25826  Event_Packer_push(&otf_event);
25827  }
25828 
25829  /********************************/
25830  /* ACTUAL FUNCTION CALL */
25831  /********************************/
25832 
25834  int ret = PMPI_Win_c2f( win );
25836 
25837  /********************************/
25838  /* EMIT OTF END */
25839  /********************************/
25840 
25841  uint64_t _end = Timer_tsc();
25842  uint64_t _duration = _end - _begin;
25843 
25845  {
25847  {
25848 
25849  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25850  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25851  MALP_EVENT_MPI, _container.event.mpi_event.type );
25852 
25853 
25854  Event_Packer_push(&otf_event);
25855  }
25856 
25857  /********************************/
25858  /* EMIT MALP EVENT */
25859  /********************************/
25860 
25861  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25862 
25863  /* Submit event if MPI instrumented */
25864  Event_Packer_push(&_container);
25865  }
25866 
25867 
25868  return ret;
25869 }
25870 int MPI_Win_call_errhandler( MPI_Win win, int errorcode )
25871 {
25872 
25873  /* Virtualize MPI */
25874 
25875 
25876  /* Pre instrum */
25877  int _rank = Stream_desc_get()->mpi_rank;
25878 
25879  struct MALP_Trace_Event _container;
25880 
25881  /********************************/
25882  /* FILL MPI EVENT */
25883  /********************************/
25884 
25885  _container.event.mpi_event.type =
25886  T_MPI_ENUM(MPI_WIN_CALL_ERRHANDLER)
25887  ;
25888 
25889  /* Set default source & dest before override */
25890  _container.event.mpi_event.source = _rank;
25891  _container.event.mpi_event.dest = _rank;
25892 
25893 
25894 
25895 
25896 
25897 
25898 
25899 
25900  /* Fill in size informations if needed */
25901  int _size = 0;
25902  #if 0
25903 
25904  #endif
25905  _container.event.mpi_event.size = _size;
25906 
25907  /********************************/
25908  /* EMIT OTF ENTER */
25909  /********************************/
25910 
25911  struct MALP_Trace_Event otf_event;
25912 
25913  uint64_t _begin = Timer_tsc ();
25914 
25917  {
25918 
25919  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
25920  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
25921  MALP_EVENT_MPI, _container.event.mpi_event.type );
25922  Event_Packer_push(&otf_event);
25923  }
25924 
25925  /********************************/
25926  /* ACTUAL FUNCTION CALL */
25927  /********************************/
25928 
25930  int ret = PMPI_Win_call_errhandler( win, errorcode );
25932 
25933  /********************************/
25934  /* EMIT OTF END */
25935  /********************************/
25936 
25937  uint64_t _end = Timer_tsc();
25938  uint64_t _duration = _end - _begin;
25939 
25941  {
25943  {
25944 
25945  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
25946  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
25947  MALP_EVENT_MPI, _container.event.mpi_event.type );
25948 
25949 
25950  Event_Packer_push(&otf_event);
25951  }
25952 
25953  /********************************/
25954  /* EMIT MALP EVENT */
25955  /********************************/
25956 
25957  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
25958 
25959  /* Submit event if MPI instrumented */
25960  Event_Packer_push(&_container);
25961  }
25962 
25963 
25964  return ret;
25965 }
25966 int MPI_Win_complete( MPI_Win win )
25967 {
25968 
25969  /* Virtualize MPI */
25970 
25971 
25972  /* Pre instrum */
25973  int _rank = Stream_desc_get()->mpi_rank;
25974 
25975  struct MALP_Trace_Event _container;
25976 
25977  /********************************/
25978  /* FILL MPI EVENT */
25979  /********************************/
25980 
25981  _container.event.mpi_event.type =
25982  T_MPI_ENUM(MPI_WIN_COMPLETE)
25983  ;
25984 
25985  /* Set default source & dest before override */
25986  _container.event.mpi_event.source = _rank;
25987  _container.event.mpi_event.dest = _rank;
25988 
25989 
25990 
25991 
25992 
25993 
25994 
25995 
25996  /* Fill in size informations if needed */
25997  int _size = 0;
25998  #if 0
25999 
26000  #endif
26001  _container.event.mpi_event.size = _size;
26002 
26003  /********************************/
26004  /* EMIT OTF ENTER */
26005  /********************************/
26006 
26007  struct MALP_Trace_Event otf_event;
26008 
26009  uint64_t _begin = Timer_tsc ();
26010 
26013  {
26014 
26015  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26016  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26017  MALP_EVENT_MPI, _container.event.mpi_event.type );
26018  Event_Packer_push(&otf_event);
26019  }
26020 
26021  /********************************/
26022  /* ACTUAL FUNCTION CALL */
26023  /********************************/
26024 
26026  int ret = PMPI_Win_complete( win );
26028 
26029  /********************************/
26030  /* EMIT OTF END */
26031  /********************************/
26032 
26033  uint64_t _end = Timer_tsc();
26034  uint64_t _duration = _end - _begin;
26035 
26037  {
26039  {
26040 
26041  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26042  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26043  MALP_EVENT_MPI, _container.event.mpi_event.type );
26044 
26045 
26046  Event_Packer_push(&otf_event);
26047  }
26048 
26049  /********************************/
26050  /* EMIT MALP EVENT */
26051  /********************************/
26052 
26053  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26054 
26055  /* Submit event if MPI instrumented */
26056  Event_Packer_push(&_container);
26057  }
26058 
26059 
26060  return ret;
26061 }
26062 int MPI_Win_create( void * base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win * win )
26063 {
26064 
26065  /* Virtualize MPI */
26066  MACRO_MPI_Comm (comm)
26067 
26068  /* Pre instrum */
26069  int _rank = Stream_desc_get()->mpi_rank;
26070 
26071  struct MALP_Trace_Event _container;
26072 
26073  /********************************/
26074  /* FILL MPI EVENT */
26075  /********************************/
26076 
26077  _container.event.mpi_event.type =
26078  T_MPI_ENUM(MPI_WIN_CREATE)
26079  ;
26080 
26081  /* Set default source & dest before override */
26082  _container.event.mpi_event.source = _rank;
26083  _container.event.mpi_event.dest = _rank;
26084 
26085 
26086 
26087 
26088 
26089 
26090  SET_COMM (comm)
26091 
26092  /* Fill in size informations if needed */
26093  int _size = 0;
26094  #if 0
26095 
26096  #endif
26097  _container.event.mpi_event.size = _size;
26098 
26099  /********************************/
26100  /* EMIT OTF ENTER */
26101  /********************************/
26102 
26103  struct MALP_Trace_Event otf_event;
26104 
26105  uint64_t _begin = Timer_tsc ();
26106 
26109  {
26110 
26111  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26112  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26113  MALP_EVENT_MPI, _container.event.mpi_event.type );
26114  Event_Packer_push(&otf_event);
26115  }
26116 
26117  /********************************/
26118  /* ACTUAL FUNCTION CALL */
26119  /********************************/
26120 
26122  int ret = PMPI_Win_create( base, size, disp_unit, info, comm, win );
26124 
26125  /********************************/
26126  /* EMIT OTF END */
26127  /********************************/
26128 
26129  uint64_t _end = Timer_tsc();
26130  uint64_t _duration = _end - _begin;
26131 
26133  {
26135  {
26136 
26137  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26138  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26139  MALP_EVENT_MPI, _container.event.mpi_event.type );
26140 
26141 
26142  Event_Packer_push(&otf_event);
26143  }
26144 
26145  /********************************/
26146  /* EMIT MALP EVENT */
26147  /********************************/
26148 
26149  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26150 
26151  /* Submit event if MPI instrumented */
26152  Event_Packer_push(&_container);
26153  }
26154 
26155 
26156  return ret;
26157 }
26158 int MPI_Win_create_errhandler( MPI_Win_errhandler_function * function, MPI_Errhandler * errhandler )
26159 {
26160 
26161  /* Virtualize MPI */
26162 
26163 
26164  /* Pre instrum */
26165  int _rank = Stream_desc_get()->mpi_rank;
26166 
26167  struct MALP_Trace_Event _container;
26168 
26169  /********************************/
26170  /* FILL MPI EVENT */
26171  /********************************/
26172 
26173  _container.event.mpi_event.type =
26174  T_MPI_ENUM(MPI_WIN_CREATE_ERRHANDLER)
26175  ;
26176 
26177  /* Set default source & dest before override */
26178  _container.event.mpi_event.source = _rank;
26179  _container.event.mpi_event.dest = _rank;
26180 
26181 
26182 
26183 
26184 
26185 
26186 
26187 
26188  /* Fill in size informations if needed */
26189  int _size = 0;
26190  #if 0
26191 
26192  #endif
26193  _container.event.mpi_event.size = _size;
26194 
26195  /********************************/
26196  /* EMIT OTF ENTER */
26197  /********************************/
26198 
26199  struct MALP_Trace_Event otf_event;
26200 
26201  uint64_t _begin = Timer_tsc ();
26202 
26205  {
26206 
26207  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26208  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26209  MALP_EVENT_MPI, _container.event.mpi_event.type );
26210  Event_Packer_push(&otf_event);
26211  }
26212 
26213  /********************************/
26214  /* ACTUAL FUNCTION CALL */
26215  /********************************/
26216 
26218  int ret = PMPI_Win_create_errhandler( function, errhandler );
26220 
26221  /********************************/
26222  /* EMIT OTF END */
26223  /********************************/
26224 
26225  uint64_t _end = Timer_tsc();
26226  uint64_t _duration = _end - _begin;
26227 
26229  {
26231  {
26232 
26233  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26234  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26235  MALP_EVENT_MPI, _container.event.mpi_event.type );
26236 
26237 
26238  Event_Packer_push(&otf_event);
26239  }
26240 
26241  /********************************/
26242  /* EMIT MALP EVENT */
26243  /********************************/
26244 
26245  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26246 
26247  /* Submit event if MPI instrumented */
26248  Event_Packer_push(&_container);
26249  }
26250 
26251 
26252  return ret;
26253 }
26254 int MPI_Win_create_keyval( MPI_Win_copy_attr_function * win_copy_attr_fn, MPI_Win_delete_attr_function * win_delete_attr_fn, int * win_keyval, void * extra_state )
26255 {
26256 
26257  /* Virtualize MPI */
26258 
26259 
26260  /* Pre instrum */
26261  int _rank = Stream_desc_get()->mpi_rank;
26262 
26263  struct MALP_Trace_Event _container;
26264 
26265  /********************************/
26266  /* FILL MPI EVENT */
26267  /********************************/
26268 
26269  _container.event.mpi_event.type =
26270  T_MPI_ENUM(MPI_WIN_CREATE_KEYVAL)
26271  ;
26272 
26273  /* Set default source & dest before override */
26274  _container.event.mpi_event.source = _rank;
26275  _container.event.mpi_event.dest = _rank;
26276 
26277 
26278 
26279 
26280 
26281 
26282 
26283 
26284  /* Fill in size informations if needed */
26285  int _size = 0;
26286  #if 0
26287 
26288  #endif
26289  _container.event.mpi_event.size = _size;
26290 
26291  /********************************/
26292  /* EMIT OTF ENTER */
26293  /********************************/
26294 
26295  struct MALP_Trace_Event otf_event;
26296 
26297  uint64_t _begin = Timer_tsc ();
26298 
26301  {
26302 
26303  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26304  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26305  MALP_EVENT_MPI, _container.event.mpi_event.type );
26306  Event_Packer_push(&otf_event);
26307  }
26308 
26309  /********************************/
26310  /* ACTUAL FUNCTION CALL */
26311  /********************************/
26312 
26314  int ret = PMPI_Win_create_keyval( win_copy_attr_fn, win_delete_attr_fn, win_keyval, extra_state );
26316 
26317  /********************************/
26318  /* EMIT OTF END */
26319  /********************************/
26320 
26321  uint64_t _end = Timer_tsc();
26322  uint64_t _duration = _end - _begin;
26323 
26325  {
26327  {
26328 
26329  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26330  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26331  MALP_EVENT_MPI, _container.event.mpi_event.type );
26332 
26333 
26334  Event_Packer_push(&otf_event);
26335  }
26336 
26337  /********************************/
26338  /* EMIT MALP EVENT */
26339  /********************************/
26340 
26341  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26342 
26343  /* Submit event if MPI instrumented */
26344  Event_Packer_push(&_container);
26345  }
26346 
26347 
26348  return ret;
26349 }
26350 int MPI_Win_delete_attr( MPI_Win win, int win_keyval )
26351 {
26352 
26353  /* Virtualize MPI */
26354 
26355 
26356  /* Pre instrum */
26357  int _rank = Stream_desc_get()->mpi_rank;
26358 
26359  struct MALP_Trace_Event _container;
26360 
26361  /********************************/
26362  /* FILL MPI EVENT */
26363  /********************************/
26364 
26365  _container.event.mpi_event.type =
26366  T_MPI_ENUM(MPI_WIN_DELETE_ATTR)
26367  ;
26368 
26369  /* Set default source & dest before override */
26370  _container.event.mpi_event.source = _rank;
26371  _container.event.mpi_event.dest = _rank;
26372 
26373 
26374 
26375 
26376 
26377 
26378 
26379 
26380  /* Fill in size informations if needed */
26381  int _size = 0;
26382  #if 0
26383 
26384  #endif
26385  _container.event.mpi_event.size = _size;
26386 
26387  /********************************/
26388  /* EMIT OTF ENTER */
26389  /********************************/
26390 
26391  struct MALP_Trace_Event otf_event;
26392 
26393  uint64_t _begin = Timer_tsc ();
26394 
26397  {
26398 
26399  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26400  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26401  MALP_EVENT_MPI, _container.event.mpi_event.type );
26402  Event_Packer_push(&otf_event);
26403  }
26404 
26405  /********************************/
26406  /* ACTUAL FUNCTION CALL */
26407  /********************************/
26408 
26410  int ret = PMPI_Win_delete_attr( win, win_keyval );
26412 
26413  /********************************/
26414  /* EMIT OTF END */
26415  /********************************/
26416 
26417  uint64_t _end = Timer_tsc();
26418  uint64_t _duration = _end - _begin;
26419 
26421  {
26423  {
26424 
26425  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26426  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26427  MALP_EVENT_MPI, _container.event.mpi_event.type );
26428 
26429 
26430  Event_Packer_push(&otf_event);
26431  }
26432 
26433  /********************************/
26434  /* EMIT MALP EVENT */
26435  /********************************/
26436 
26437  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26438 
26439  /* Submit event if MPI instrumented */
26440  Event_Packer_push(&_container);
26441  }
26442 
26443 
26444  return ret;
26445 }
26446 int MPI_Win_fence( int assert, MPI_Win win )
26447 {
26448 
26449  /* Virtualize MPI */
26450 
26451 
26452  /* Pre instrum */
26453  int _rank = Stream_desc_get()->mpi_rank;
26454 
26455  struct MALP_Trace_Event _container;
26456 
26457  /********************************/
26458  /* FILL MPI EVENT */
26459  /********************************/
26460 
26461  _container.event.mpi_event.type =
26462  T_MPI_ENUM(MPI_WIN_FENCE)
26463  ;
26464 
26465  /* Set default source & dest before override */
26466  _container.event.mpi_event.source = _rank;
26467  _container.event.mpi_event.dest = _rank;
26468 
26469 
26470 
26471 
26472 
26473 
26474 
26475 
26476  /* Fill in size informations if needed */
26477  int _size = 0;
26478  #if 0
26479 
26480  #endif
26481  _container.event.mpi_event.size = _size;
26482 
26483  /********************************/
26484  /* EMIT OTF ENTER */
26485  /********************************/
26486 
26487  struct MALP_Trace_Event otf_event;
26488 
26489  uint64_t _begin = Timer_tsc ();
26490 
26493  {
26494 
26495  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26496  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26497  MALP_EVENT_MPI, _container.event.mpi_event.type );
26498  Event_Packer_push(&otf_event);
26499  }
26500 
26501  /********************************/
26502  /* ACTUAL FUNCTION CALL */
26503  /********************************/
26504 
26506  int ret = PMPI_Win_fence( assert, win );
26508 
26509  /********************************/
26510  /* EMIT OTF END */
26511  /********************************/
26512 
26513  uint64_t _end = Timer_tsc();
26514  uint64_t _duration = _end - _begin;
26515 
26517  {
26519  {
26520 
26521  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26522  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26523  MALP_EVENT_MPI, _container.event.mpi_event.type );
26524 
26525 
26526  Event_Packer_push(&otf_event);
26527  }
26528 
26529  /********************************/
26530  /* EMIT MALP EVENT */
26531  /********************************/
26532 
26533  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26534 
26535  /* Submit event if MPI instrumented */
26536  Event_Packer_push(&_container);
26537  }
26538 
26539 
26540  return ret;
26541 }
26542 int MPI_Win_free( MPI_Win * win )
26543 {
26544 
26545  /* Virtualize MPI */
26546 
26547 
26548  /* Pre instrum */
26549  int _rank = Stream_desc_get()->mpi_rank;
26550 
26551  struct MALP_Trace_Event _container;
26552 
26553  /********************************/
26554  /* FILL MPI EVENT */
26555  /********************************/
26556 
26557  _container.event.mpi_event.type =
26558  T_MPI_ENUM(MPI_WIN_FREE)
26559  ;
26560 
26561  /* Set default source & dest before override */
26562  _container.event.mpi_event.source = _rank;
26563  _container.event.mpi_event.dest = _rank;
26564 
26565 
26566 
26567 
26568 
26569 
26570 
26571 
26572  /* Fill in size informations if needed */
26573  int _size = 0;
26574  #if 0
26575 
26576  #endif
26577  _container.event.mpi_event.size = _size;
26578 
26579  /********************************/
26580  /* EMIT OTF ENTER */
26581  /********************************/
26582 
26583  struct MALP_Trace_Event otf_event;
26584 
26585  uint64_t _begin = Timer_tsc ();
26586 
26589  {
26590 
26591  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26592  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26593  MALP_EVENT_MPI, _container.event.mpi_event.type );
26594  Event_Packer_push(&otf_event);
26595  }
26596 
26597  /********************************/
26598  /* ACTUAL FUNCTION CALL */
26599  /********************************/
26600 
26602  int ret = PMPI_Win_free( win );
26604 
26605  /********************************/
26606  /* EMIT OTF END */
26607  /********************************/
26608 
26609  uint64_t _end = Timer_tsc();
26610  uint64_t _duration = _end - _begin;
26611 
26613  {
26615  {
26616 
26617  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26618  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26619  MALP_EVENT_MPI, _container.event.mpi_event.type );
26620 
26621 
26622  Event_Packer_push(&otf_event);
26623  }
26624 
26625  /********************************/
26626  /* EMIT MALP EVENT */
26627  /********************************/
26628 
26629  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26630 
26631  /* Submit event if MPI instrumented */
26632  Event_Packer_push(&_container);
26633  }
26634 
26635 
26636  return ret;
26637 }
26638 int MPI_Win_free_keyval( int * win_keyval )
26639 {
26640 
26641  /* Virtualize MPI */
26642 
26643 
26644  /* Pre instrum */
26645  int _rank = Stream_desc_get()->mpi_rank;
26646 
26647  struct MALP_Trace_Event _container;
26648 
26649  /********************************/
26650  /* FILL MPI EVENT */
26651  /********************************/
26652 
26653  _container.event.mpi_event.type =
26654  T_MPI_ENUM(MPI_WIN_FREE_KEYVAL)
26655  ;
26656 
26657  /* Set default source & dest before override */
26658  _container.event.mpi_event.source = _rank;
26659  _container.event.mpi_event.dest = _rank;
26660 
26661 
26662 
26663 
26664 
26665 
26666 
26667 
26668  /* Fill in size informations if needed */
26669  int _size = 0;
26670  #if 0
26671 
26672  #endif
26673  _container.event.mpi_event.size = _size;
26674 
26675  /********************************/
26676  /* EMIT OTF ENTER */
26677  /********************************/
26678 
26679  struct MALP_Trace_Event otf_event;
26680 
26681  uint64_t _begin = Timer_tsc ();
26682 
26685  {
26686 
26687  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26688  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26689  MALP_EVENT_MPI, _container.event.mpi_event.type );
26690  Event_Packer_push(&otf_event);
26691  }
26692 
26693  /********************************/
26694  /* ACTUAL FUNCTION CALL */
26695  /********************************/
26696 
26698  int ret = PMPI_Win_free_keyval( win_keyval );
26700 
26701  /********************************/
26702  /* EMIT OTF END */
26703  /********************************/
26704 
26705  uint64_t _end = Timer_tsc();
26706  uint64_t _duration = _end - _begin;
26707 
26709  {
26711  {
26712 
26713  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26714  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26715  MALP_EVENT_MPI, _container.event.mpi_event.type );
26716 
26717 
26718  Event_Packer_push(&otf_event);
26719  }
26720 
26721  /********************************/
26722  /* EMIT MALP EVENT */
26723  /********************************/
26724 
26725  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26726 
26727  /* Submit event if MPI instrumented */
26728  Event_Packer_push(&_container);
26729  }
26730 
26731 
26732  return ret;
26733 }
26734 int MPI_Win_get_attr( MPI_Win win, int win_keyval, void * attribute_val, int * flag )
26735 {
26736 
26737  /* Virtualize MPI */
26738 
26739 
26740  /* Pre instrum */
26741  int _rank = Stream_desc_get()->mpi_rank;
26742 
26743  struct MALP_Trace_Event _container;
26744 
26745  /********************************/
26746  /* FILL MPI EVENT */
26747  /********************************/
26748 
26749  _container.event.mpi_event.type =
26750  T_MPI_ENUM(MPI_WIN_GET_ATTR)
26751  ;
26752 
26753  /* Set default source & dest before override */
26754  _container.event.mpi_event.source = _rank;
26755  _container.event.mpi_event.dest = _rank;
26756 
26757 
26758 
26759 
26760 
26761 
26762 
26763 
26764  /* Fill in size informations if needed */
26765  int _size = 0;
26766  #if 0
26767 
26768  #endif
26769  _container.event.mpi_event.size = _size;
26770 
26771  /********************************/
26772  /* EMIT OTF ENTER */
26773  /********************************/
26774 
26775  struct MALP_Trace_Event otf_event;
26776 
26777  uint64_t _begin = Timer_tsc ();
26778 
26781  {
26782 
26783  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26784  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26785  MALP_EVENT_MPI, _container.event.mpi_event.type );
26786  Event_Packer_push(&otf_event);
26787  }
26788 
26789  /********************************/
26790  /* ACTUAL FUNCTION CALL */
26791  /********************************/
26792 
26794  int ret = PMPI_Win_get_attr( win, win_keyval, attribute_val, flag );
26796 
26797  /********************************/
26798  /* EMIT OTF END */
26799  /********************************/
26800 
26801  uint64_t _end = Timer_tsc();
26802  uint64_t _duration = _end - _begin;
26803 
26805  {
26807  {
26808 
26809  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26810  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26811  MALP_EVENT_MPI, _container.event.mpi_event.type );
26812 
26813 
26814  Event_Packer_push(&otf_event);
26815  }
26816 
26817  /********************************/
26818  /* EMIT MALP EVENT */
26819  /********************************/
26820 
26821  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26822 
26823  /* Submit event if MPI instrumented */
26824  Event_Packer_push(&_container);
26825  }
26826 
26827 
26828  return ret;
26829 }
26830 int MPI_Win_get_errhandler( MPI_Win win, MPI_Errhandler * errhandler )
26831 {
26832 
26833  /* Virtualize MPI */
26834 
26835 
26836  /* Pre instrum */
26837  int _rank = Stream_desc_get()->mpi_rank;
26838 
26839  struct MALP_Trace_Event _container;
26840 
26841  /********************************/
26842  /* FILL MPI EVENT */
26843  /********************************/
26844 
26845  _container.event.mpi_event.type =
26846  T_MPI_ENUM(MPI_WIN_GET_ERRHANDLER)
26847  ;
26848 
26849  /* Set default source & dest before override */
26850  _container.event.mpi_event.source = _rank;
26851  _container.event.mpi_event.dest = _rank;
26852 
26853 
26854 
26855 
26856 
26857 
26858 
26859 
26860  /* Fill in size informations if needed */
26861  int _size = 0;
26862  #if 0
26863 
26864  #endif
26865  _container.event.mpi_event.size = _size;
26866 
26867  /********************************/
26868  /* EMIT OTF ENTER */
26869  /********************************/
26870 
26871  struct MALP_Trace_Event otf_event;
26872 
26873  uint64_t _begin = Timer_tsc ();
26874 
26877  {
26878 
26879  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26880  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26881  MALP_EVENT_MPI, _container.event.mpi_event.type );
26882  Event_Packer_push(&otf_event);
26883  }
26884 
26885  /********************************/
26886  /* ACTUAL FUNCTION CALL */
26887  /********************************/
26888 
26890  int ret = PMPI_Win_get_errhandler( win, errhandler );
26892 
26893  /********************************/
26894  /* EMIT OTF END */
26895  /********************************/
26896 
26897  uint64_t _end = Timer_tsc();
26898  uint64_t _duration = _end - _begin;
26899 
26901  {
26903  {
26904 
26905  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
26906  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
26907  MALP_EVENT_MPI, _container.event.mpi_event.type );
26908 
26909 
26910  Event_Packer_push(&otf_event);
26911  }
26912 
26913  /********************************/
26914  /* EMIT MALP EVENT */
26915  /********************************/
26916 
26917  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
26918 
26919  /* Submit event if MPI instrumented */
26920  Event_Packer_push(&_container);
26921  }
26922 
26923 
26924  return ret;
26925 }
26926 int MPI_Win_get_group( MPI_Win win, MPI_Group * group )
26927 {
26928 
26929  /* Virtualize MPI */
26930 
26931 
26932  /* Pre instrum */
26933  int _rank = Stream_desc_get()->mpi_rank;
26934 
26935  struct MALP_Trace_Event _container;
26936 
26937  /********************************/
26938  /* FILL MPI EVENT */
26939  /********************************/
26940 
26941  _container.event.mpi_event.type =
26942  T_MPI_ENUM(MPI_WIN_GET_GROUP)
26943  ;
26944 
26945  /* Set default source & dest before override */
26946  _container.event.mpi_event.source = _rank;
26947  _container.event.mpi_event.dest = _rank;
26948 
26949 
26950 
26951 
26952 
26953 
26954 
26955 
26956  /* Fill in size informations if needed */
26957  int _size = 0;
26958  #if 0
26959 
26960  #endif
26961  _container.event.mpi_event.size = _size;
26962 
26963  /********************************/
26964  /* EMIT OTF ENTER */
26965  /********************************/
26966 
26967  struct MALP_Trace_Event otf_event;
26968 
26969  uint64_t _begin = Timer_tsc ();
26970 
26973  {
26974 
26975  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
26976  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
26977  MALP_EVENT_MPI, _container.event.mpi_event.type );
26978  Event_Packer_push(&otf_event);
26979  }
26980 
26981  /********************************/
26982  /* ACTUAL FUNCTION CALL */
26983  /********************************/
26984 
26986  int ret = PMPI_Win_get_group( win, group );
26988 
26989  /********************************/
26990  /* EMIT OTF END */
26991  /********************************/
26992 
26993  uint64_t _end = Timer_tsc();
26994  uint64_t _duration = _end - _begin;
26995 
26997  {
26999  {
27000 
27001  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27002  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27003  MALP_EVENT_MPI, _container.event.mpi_event.type );
27004 
27005 
27006  Event_Packer_push(&otf_event);
27007  }
27008 
27009  /********************************/
27010  /* EMIT MALP EVENT */
27011  /********************************/
27012 
27013  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27014 
27015  /* Submit event if MPI instrumented */
27016  Event_Packer_push(&_container);
27017  }
27018 
27019 
27020  return ret;
27021 }
27022 int MPI_Win_get_name( MPI_Win win, char * win_name, int * resultlen )
27023 {
27024 
27025  /* Virtualize MPI */
27026 
27027 
27028  /* Pre instrum */
27029  int _rank = Stream_desc_get()->mpi_rank;
27030 
27031  struct MALP_Trace_Event _container;
27032 
27033  /********************************/
27034  /* FILL MPI EVENT */
27035  /********************************/
27036 
27037  _container.event.mpi_event.type =
27038  T_MPI_ENUM(MPI_WIN_GET_NAME)
27039  ;
27040 
27041  /* Set default source & dest before override */
27042  _container.event.mpi_event.source = _rank;
27043  _container.event.mpi_event.dest = _rank;
27044 
27045 
27046 
27047 
27048 
27049 
27050 
27051 
27052  /* Fill in size informations if needed */
27053  int _size = 0;
27054  #if 0
27055 
27056  #endif
27057  _container.event.mpi_event.size = _size;
27058 
27059  /********************************/
27060  /* EMIT OTF ENTER */
27061  /********************************/
27062 
27063  struct MALP_Trace_Event otf_event;
27064 
27065  uint64_t _begin = Timer_tsc ();
27066 
27069  {
27070 
27071  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27072  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27073  MALP_EVENT_MPI, _container.event.mpi_event.type );
27074  Event_Packer_push(&otf_event);
27075  }
27076 
27077  /********************************/
27078  /* ACTUAL FUNCTION CALL */
27079  /********************************/
27080 
27082  int ret = PMPI_Win_get_name( win, win_name, resultlen );
27084 
27085  /********************************/
27086  /* EMIT OTF END */
27087  /********************************/
27088 
27089  uint64_t _end = Timer_tsc();
27090  uint64_t _duration = _end - _begin;
27091 
27093  {
27095  {
27096 
27097  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27098  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27099  MALP_EVENT_MPI, _container.event.mpi_event.type );
27100 
27101 
27102  Event_Packer_push(&otf_event);
27103  }
27104 
27105  /********************************/
27106  /* EMIT MALP EVENT */
27107  /********************************/
27108 
27109  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27110 
27111  /* Submit event if MPI instrumented */
27112  Event_Packer_push(&_container);
27113  }
27114 
27115 
27116  return ret;
27117 }
27118 int MPI_Win_lock( int lock_type, int rank, int assert, MPI_Win win )
27119 {
27120 
27121  /* Virtualize MPI */
27122 
27123 
27124  /* Pre instrum */
27125  int _rank = Stream_desc_get()->mpi_rank;
27126 
27127  struct MALP_Trace_Event _container;
27128 
27129  /********************************/
27130  /* FILL MPI EVENT */
27131  /********************************/
27132 
27133  _container.event.mpi_event.type =
27134  T_MPI_ENUM(MPI_WIN_LOCK)
27135  ;
27136 
27137  /* Set default source & dest before override */
27138  _container.event.mpi_event.source = _rank;
27139  _container.event.mpi_event.dest = _rank;
27140 
27141 
27142 
27143 
27144 
27145 
27146 
27147 
27148  /* Fill in size informations if needed */
27149  int _size = 0;
27150  #if 0
27151 
27152  #endif
27153  _container.event.mpi_event.size = _size;
27154 
27155  /********************************/
27156  /* EMIT OTF ENTER */
27157  /********************************/
27158 
27159  struct MALP_Trace_Event otf_event;
27160 
27161  uint64_t _begin = Timer_tsc ();
27162 
27165  {
27166 
27167  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27168  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27169  MALP_EVENT_MPI, _container.event.mpi_event.type );
27170  Event_Packer_push(&otf_event);
27171  }
27172 
27173  /********************************/
27174  /* ACTUAL FUNCTION CALL */
27175  /********************************/
27176 
27178  int ret = PMPI_Win_lock( lock_type, rank, assert, win );
27180 
27181  /********************************/
27182  /* EMIT OTF END */
27183  /********************************/
27184 
27185  uint64_t _end = Timer_tsc();
27186  uint64_t _duration = _end - _begin;
27187 
27189  {
27191  {
27192 
27193  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27194  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27195  MALP_EVENT_MPI, _container.event.mpi_event.type );
27196 
27197 
27198  Event_Packer_push(&otf_event);
27199  }
27200 
27201  /********************************/
27202  /* EMIT MALP EVENT */
27203  /********************************/
27204 
27205  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27206 
27207  /* Submit event if MPI instrumented */
27208  Event_Packer_push(&_container);
27209  }
27210 
27211 
27212  return ret;
27213 }
27214 int MPI_Win_post( MPI_Group group, int assert, MPI_Win win )
27215 {
27216 
27217  /* Virtualize MPI */
27218 
27219 
27220  /* Pre instrum */
27221  int _rank = Stream_desc_get()->mpi_rank;
27222 
27223  struct MALP_Trace_Event _container;
27224 
27225  /********************************/
27226  /* FILL MPI EVENT */
27227  /********************************/
27228 
27229  _container.event.mpi_event.type =
27230  T_MPI_ENUM(MPI_WIN_POST)
27231  ;
27232 
27233  /* Set default source & dest before override */
27234  _container.event.mpi_event.source = _rank;
27235  _container.event.mpi_event.dest = _rank;
27236 
27237 
27238 
27239 
27240 
27241 
27242 
27243 
27244  /* Fill in size informations if needed */
27245  int _size = 0;
27246  #if 0
27247 
27248  #endif
27249  _container.event.mpi_event.size = _size;
27250 
27251  /********************************/
27252  /* EMIT OTF ENTER */
27253  /********************************/
27254 
27255  struct MALP_Trace_Event otf_event;
27256 
27257  uint64_t _begin = Timer_tsc ();
27258 
27261  {
27262 
27263  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27264  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27265  MALP_EVENT_MPI, _container.event.mpi_event.type );
27266  Event_Packer_push(&otf_event);
27267  }
27268 
27269  /********************************/
27270  /* ACTUAL FUNCTION CALL */
27271  /********************************/
27272 
27274  int ret = PMPI_Win_post( group, assert, win );
27276 
27277  /********************************/
27278  /* EMIT OTF END */
27279  /********************************/
27280 
27281  uint64_t _end = Timer_tsc();
27282  uint64_t _duration = _end - _begin;
27283 
27285  {
27287  {
27288 
27289  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27290  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27291  MALP_EVENT_MPI, _container.event.mpi_event.type );
27292 
27293 
27294  Event_Packer_push(&otf_event);
27295  }
27296 
27297  /********************************/
27298  /* EMIT MALP EVENT */
27299  /********************************/
27300 
27301  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27302 
27303  /* Submit event if MPI instrumented */
27304  Event_Packer_push(&_container);
27305  }
27306 
27307 
27308  return ret;
27309 }
27310 int MPI_Win_set_attr( MPI_Win win, int win_keyval, void * attribute_val )
27311 {
27312 
27313  /* Virtualize MPI */
27314 
27315 
27316  /* Pre instrum */
27317  int _rank = Stream_desc_get()->mpi_rank;
27318 
27319  struct MALP_Trace_Event _container;
27320 
27321  /********************************/
27322  /* FILL MPI EVENT */
27323  /********************************/
27324 
27325  _container.event.mpi_event.type =
27326  T_MPI_ENUM(MPI_WIN_SET_ATTR)
27327  ;
27328 
27329  /* Set default source & dest before override */
27330  _container.event.mpi_event.source = _rank;
27331  _container.event.mpi_event.dest = _rank;
27332 
27333 
27334 
27335 
27336 
27337 
27338 
27339 
27340  /* Fill in size informations if needed */
27341  int _size = 0;
27342  #if 0
27343 
27344  #endif
27345  _container.event.mpi_event.size = _size;
27346 
27347  /********************************/
27348  /* EMIT OTF ENTER */
27349  /********************************/
27350 
27351  struct MALP_Trace_Event otf_event;
27352 
27353  uint64_t _begin = Timer_tsc ();
27354 
27357  {
27358 
27359  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27360  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27361  MALP_EVENT_MPI, _container.event.mpi_event.type );
27362  Event_Packer_push(&otf_event);
27363  }
27364 
27365  /********************************/
27366  /* ACTUAL FUNCTION CALL */
27367  /********************************/
27368 
27370  int ret = PMPI_Win_set_attr( win, win_keyval, attribute_val );
27372 
27373  /********************************/
27374  /* EMIT OTF END */
27375  /********************************/
27376 
27377  uint64_t _end = Timer_tsc();
27378  uint64_t _duration = _end - _begin;
27379 
27381  {
27383  {
27384 
27385  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27386  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27387  MALP_EVENT_MPI, _container.event.mpi_event.type );
27388 
27389 
27390  Event_Packer_push(&otf_event);
27391  }
27392 
27393  /********************************/
27394  /* EMIT MALP EVENT */
27395  /********************************/
27396 
27397  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27398 
27399  /* Submit event if MPI instrumented */
27400  Event_Packer_push(&_container);
27401  }
27402 
27403 
27404  return ret;
27405 }
27406 int MPI_Win_set_errhandler( MPI_Win win, MPI_Errhandler errhandler )
27407 {
27408 
27409  /* Virtualize MPI */
27410 
27411 
27412  /* Pre instrum */
27413  int _rank = Stream_desc_get()->mpi_rank;
27414 
27415  struct MALP_Trace_Event _container;
27416 
27417  /********************************/
27418  /* FILL MPI EVENT */
27419  /********************************/
27420 
27421  _container.event.mpi_event.type =
27422  T_MPI_ENUM(MPI_WIN_SET_ERRHANDLER)
27423  ;
27424 
27425  /* Set default source & dest before override */
27426  _container.event.mpi_event.source = _rank;
27427  _container.event.mpi_event.dest = _rank;
27428 
27429 
27430 
27431 
27432 
27433 
27434 
27435 
27436  /* Fill in size informations if needed */
27437  int _size = 0;
27438  #if 0
27439 
27440  #endif
27441  _container.event.mpi_event.size = _size;
27442 
27443  /********************************/
27444  /* EMIT OTF ENTER */
27445  /********************************/
27446 
27447  struct MALP_Trace_Event otf_event;
27448 
27449  uint64_t _begin = Timer_tsc ();
27450 
27453  {
27454 
27455  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27456  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27457  MALP_EVENT_MPI, _container.event.mpi_event.type );
27458  Event_Packer_push(&otf_event);
27459  }
27460 
27461  /********************************/
27462  /* ACTUAL FUNCTION CALL */
27463  /********************************/
27464 
27466  int ret = PMPI_Win_set_errhandler( win, errhandler );
27468 
27469  /********************************/
27470  /* EMIT OTF END */
27471  /********************************/
27472 
27473  uint64_t _end = Timer_tsc();
27474  uint64_t _duration = _end - _begin;
27475 
27477  {
27479  {
27480 
27481  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27482  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27483  MALP_EVENT_MPI, _container.event.mpi_event.type );
27484 
27485 
27486  Event_Packer_push(&otf_event);
27487  }
27488 
27489  /********************************/
27490  /* EMIT MALP EVENT */
27491  /********************************/
27492 
27493  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27494 
27495  /* Submit event if MPI instrumented */
27496  Event_Packer_push(&_container);
27497  }
27498 
27499 
27500  return ret;
27501 }
27502 int MPI_Win_set_name( MPI_Win win, char * win_name )
27503 {
27504 
27505  /* Virtualize MPI */
27506 
27507 
27508  /* Pre instrum */
27509  int _rank = Stream_desc_get()->mpi_rank;
27510 
27511  struct MALP_Trace_Event _container;
27512 
27513  /********************************/
27514  /* FILL MPI EVENT */
27515  /********************************/
27516 
27517  _container.event.mpi_event.type =
27518  T_MPI_ENUM(MPI_WIN_SET_NAME)
27519  ;
27520 
27521  /* Set default source & dest before override */
27522  _container.event.mpi_event.source = _rank;
27523  _container.event.mpi_event.dest = _rank;
27524 
27525 
27526 
27527 
27528 
27529 
27530 
27531 
27532  /* Fill in size informations if needed */
27533  int _size = 0;
27534  #if 0
27535 
27536  #endif
27537  _container.event.mpi_event.size = _size;
27538 
27539  /********************************/
27540  /* EMIT OTF ENTER */
27541  /********************************/
27542 
27543  struct MALP_Trace_Event otf_event;
27544 
27545  uint64_t _begin = Timer_tsc ();
27546 
27549  {
27550 
27551  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27552  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27553  MALP_EVENT_MPI, _container.event.mpi_event.type );
27554  Event_Packer_push(&otf_event);
27555  }
27556 
27557  /********************************/
27558  /* ACTUAL FUNCTION CALL */
27559  /********************************/
27560 
27562  int ret = PMPI_Win_set_name( win, win_name );
27564 
27565  /********************************/
27566  /* EMIT OTF END */
27567  /********************************/
27568 
27569  uint64_t _end = Timer_tsc();
27570  uint64_t _duration = _end - _begin;
27571 
27573  {
27575  {
27576 
27577  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27578  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27579  MALP_EVENT_MPI, _container.event.mpi_event.type );
27580 
27581 
27582  Event_Packer_push(&otf_event);
27583  }
27584 
27585  /********************************/
27586  /* EMIT MALP EVENT */
27587  /********************************/
27588 
27589  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27590 
27591  /* Submit event if MPI instrumented */
27592  Event_Packer_push(&_container);
27593  }
27594 
27595 
27596  return ret;
27597 }
27598 int MPI_Win_start( MPI_Group group, int assert, MPI_Win win )
27599 {
27600 
27601  /* Virtualize MPI */
27602 
27603 
27604  /* Pre instrum */
27605  int _rank = Stream_desc_get()->mpi_rank;
27606 
27607  struct MALP_Trace_Event _container;
27608 
27609  /********************************/
27610  /* FILL MPI EVENT */
27611  /********************************/
27612 
27613  _container.event.mpi_event.type =
27614  T_MPI_ENUM(MPI_WIN_START)
27615  ;
27616 
27617  /* Set default source & dest before override */
27618  _container.event.mpi_event.source = _rank;
27619  _container.event.mpi_event.dest = _rank;
27620 
27621 
27622 
27623 
27624 
27625 
27626 
27627 
27628  /* Fill in size informations if needed */
27629  int _size = 0;
27630  #if 0
27631 
27632  #endif
27633  _container.event.mpi_event.size = _size;
27634 
27635  /********************************/
27636  /* EMIT OTF ENTER */
27637  /********************************/
27638 
27639  struct MALP_Trace_Event otf_event;
27640 
27641  uint64_t _begin = Timer_tsc ();
27642 
27645  {
27646 
27647  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27648  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27649  MALP_EVENT_MPI, _container.event.mpi_event.type );
27650  Event_Packer_push(&otf_event);
27651  }
27652 
27653  /********************************/
27654  /* ACTUAL FUNCTION CALL */
27655  /********************************/
27656 
27658  int ret = PMPI_Win_start( group, assert, win );
27660 
27661  /********************************/
27662  /* EMIT OTF END */
27663  /********************************/
27664 
27665  uint64_t _end = Timer_tsc();
27666  uint64_t _duration = _end - _begin;
27667 
27669  {
27671  {
27672 
27673  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27674  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27675  MALP_EVENT_MPI, _container.event.mpi_event.type );
27676 
27677 
27678  Event_Packer_push(&otf_event);
27679  }
27680 
27681  /********************************/
27682  /* EMIT MALP EVENT */
27683  /********************************/
27684 
27685  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27686 
27687  /* Submit event if MPI instrumented */
27688  Event_Packer_push(&_container);
27689  }
27690 
27691 
27692  return ret;
27693 }
27694 int MPI_Win_test( MPI_Win win, int * flag )
27695 {
27696 
27697  /* Virtualize MPI */
27698 
27699 
27700  /* Pre instrum */
27701  int _rank = Stream_desc_get()->mpi_rank;
27702 
27703  struct MALP_Trace_Event _container;
27704 
27705  /********************************/
27706  /* FILL MPI EVENT */
27707  /********************************/
27708 
27709  _container.event.mpi_event.type =
27710  T_MPI_ENUM(MPI_WIN_TEST)
27711  ;
27712 
27713  /* Set default source & dest before override */
27714  _container.event.mpi_event.source = _rank;
27715  _container.event.mpi_event.dest = _rank;
27716 
27717 
27718 
27719 
27720 
27721 
27722 
27723 
27724  /* Fill in size informations if needed */
27725  int _size = 0;
27726  #if 0
27727 
27728  #endif
27729  _container.event.mpi_event.size = _size;
27730 
27731  /********************************/
27732  /* EMIT OTF ENTER */
27733  /********************************/
27734 
27735  struct MALP_Trace_Event otf_event;
27736 
27737  uint64_t _begin = Timer_tsc ();
27738 
27741  {
27742 
27743  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27744  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27745  MALP_EVENT_MPI, _container.event.mpi_event.type );
27746  Event_Packer_push(&otf_event);
27747  }
27748 
27749  /********************************/
27750  /* ACTUAL FUNCTION CALL */
27751  /********************************/
27752 
27754  int ret = PMPI_Win_test( win, flag );
27756 
27757  /********************************/
27758  /* EMIT OTF END */
27759  /********************************/
27760 
27761  uint64_t _end = Timer_tsc();
27762  uint64_t _duration = _end - _begin;
27763 
27765  {
27767  {
27768 
27769  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27770  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27771  MALP_EVENT_MPI, _container.event.mpi_event.type );
27772 
27773 
27774  Event_Packer_push(&otf_event);
27775  }
27776 
27777  /********************************/
27778  /* EMIT MALP EVENT */
27779  /********************************/
27780 
27781  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27782 
27783  /* Submit event if MPI instrumented */
27784  Event_Packer_push(&_container);
27785  }
27786 
27787 
27788  return ret;
27789 }
27790 int MPI_Win_unlock( int rank, MPI_Win win )
27791 {
27792 
27793  /* Virtualize MPI */
27794 
27795 
27796  /* Pre instrum */
27797  int _rank = Stream_desc_get()->mpi_rank;
27798 
27799  struct MALP_Trace_Event _container;
27800 
27801  /********************************/
27802  /* FILL MPI EVENT */
27803  /********************************/
27804 
27805  _container.event.mpi_event.type =
27806  T_MPI_ENUM(MPI_WIN_UNLOCK)
27807  ;
27808 
27809  /* Set default source & dest before override */
27810  _container.event.mpi_event.source = _rank;
27811  _container.event.mpi_event.dest = _rank;
27812 
27813 
27814 
27815 
27816 
27817 
27818 
27819 
27820  /* Fill in size informations if needed */
27821  int _size = 0;
27822  #if 0
27823 
27824  #endif
27825  _container.event.mpi_event.size = _size;
27826 
27827  /********************************/
27828  /* EMIT OTF ENTER */
27829  /********************************/
27830 
27831  struct MALP_Trace_Event otf_event;
27832 
27833  uint64_t _begin = Timer_tsc ();
27834 
27837  {
27838 
27839  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27840  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27841  MALP_EVENT_MPI, _container.event.mpi_event.type );
27842  Event_Packer_push(&otf_event);
27843  }
27844 
27845  /********************************/
27846  /* ACTUAL FUNCTION CALL */
27847  /********************************/
27848 
27850  int ret = PMPI_Win_unlock( rank, win );
27852 
27853  /********************************/
27854  /* EMIT OTF END */
27855  /********************************/
27856 
27857  uint64_t _end = Timer_tsc();
27858  uint64_t _duration = _end - _begin;
27859 
27861  {
27863  {
27864 
27865  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27866  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27867  MALP_EVENT_MPI, _container.event.mpi_event.type );
27868 
27869 
27870  Event_Packer_push(&otf_event);
27871  }
27872 
27873  /********************************/
27874  /* EMIT MALP EVENT */
27875  /********************************/
27876 
27877  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27878 
27879  /* Submit event if MPI instrumented */
27880  Event_Packer_push(&_container);
27881  }
27882 
27883 
27884  return ret;
27885 }
27886 int MPI_Win_wait( MPI_Win win )
27887 {
27888 
27889  /* Virtualize MPI */
27890 
27891 
27892  /* Pre instrum */
27893  int _rank = Stream_desc_get()->mpi_rank;
27894 
27895  struct MALP_Trace_Event _container;
27896 
27897  /********************************/
27898  /* FILL MPI EVENT */
27899  /********************************/
27900 
27901  _container.event.mpi_event.type =
27902  T_MPI_ENUM(MPI_WIN_WAIT)
27903  ;
27904 
27905  /* Set default source & dest before override */
27906  _container.event.mpi_event.source = _rank;
27907  _container.event.mpi_event.dest = _rank;
27908 
27909 
27910 
27911 
27912 
27913 
27914 
27915 
27916  /* Fill in size informations if needed */
27917  int _size = 0;
27918  #if 0
27919 
27920  #endif
27921  _container.event.mpi_event.size = _size;
27922 
27923  /********************************/
27924  /* EMIT OTF ENTER */
27925  /********************************/
27926 
27927  struct MALP_Trace_Event otf_event;
27928 
27929  uint64_t _begin = Timer_tsc ();
27930 
27933  {
27934 
27935  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
27936  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
27937  MALP_EVENT_MPI, _container.event.mpi_event.type );
27938  Event_Packer_push(&otf_event);
27939  }
27940 
27941  /********************************/
27942  /* ACTUAL FUNCTION CALL */
27943  /********************************/
27944 
27946  int ret = PMPI_Win_wait( win );
27948 
27949  /********************************/
27950  /* EMIT OTF END */
27951  /********************************/
27952 
27953  uint64_t _end = Timer_tsc();
27954  uint64_t _duration = _end - _begin;
27955 
27957  {
27959  {
27960 
27961  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
27962  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
27963  MALP_EVENT_MPI, _container.event.mpi_event.type );
27964 
27965 
27966  Event_Packer_push(&otf_event);
27967  }
27968 
27969  /********************************/
27970  /* EMIT MALP EVENT */
27971  /********************************/
27972 
27973  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
27974 
27975  /* Submit event if MPI instrumented */
27976  Event_Packer_push(&_container);
27977  }
27978 
27979 
27980  return ret;
27981 }
27982 double MPI_Wtick( )
27983 {
27984 
27985  /* Virtualize MPI */
27986 
27987 
27988  /* Pre instrum */
27989  int _rank = Stream_desc_get()->mpi_rank;
27990 
27991  struct MALP_Trace_Event _container;
27992 
27993  /********************************/
27994  /* FILL MPI EVENT */
27995  /********************************/
27996 
27997  _container.event.mpi_event.type =
27998  T_MPI_ENUM(MPI_WTICK)
27999  ;
28000 
28001  /* Set default source & dest before override */
28002  _container.event.mpi_event.source = _rank;
28003  _container.event.mpi_event.dest = _rank;
28004 
28005 
28006 
28007 
28008 
28009 
28010 
28011 
28012  /* Fill in size informations if needed */
28013  int _size = 0;
28014  #if 0
28015 
28016  #endif
28017  _container.event.mpi_event.size = _size;
28018 
28019  /********************************/
28020  /* EMIT OTF ENTER */
28021  /********************************/
28022 
28023  struct MALP_Trace_Event otf_event;
28024 
28025  uint64_t _begin = Timer_tsc ();
28026 
28029  {
28030 
28031  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
28032  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
28033  MALP_EVENT_MPI, _container.event.mpi_event.type );
28034  Event_Packer_push(&otf_event);
28035  }
28036 
28037  /********************************/
28038  /* ACTUAL FUNCTION CALL */
28039  /********************************/
28040 
28042  double ret = PMPI_Wtick( );
28044 
28045  /********************************/
28046  /* EMIT OTF END */
28047  /********************************/
28048 
28049  uint64_t _end = Timer_tsc();
28050  uint64_t _duration = _end - _begin;
28051 
28053  {
28055  {
28056 
28057  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
28058  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
28059  MALP_EVENT_MPI, _container.event.mpi_event.type );
28060 
28061 
28062  Event_Packer_push(&otf_event);
28063  }
28064 
28065  /********************************/
28066  /* EMIT MALP EVENT */
28067  /********************************/
28068 
28069  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
28070 
28071  /* Submit event if MPI instrumented */
28072  Event_Packer_push(&_container);
28073  }
28074 
28075 
28076  return ret;
28077 }
28078 double MPI_Wtime( )
28079 {
28080 
28081  /* Virtualize MPI */
28082 
28083 
28084  /* Pre instrum */
28085  int _rank = Stream_desc_get()->mpi_rank;
28086 
28087  struct MALP_Trace_Event _container;
28088 
28089  /********************************/
28090  /* FILL MPI EVENT */
28091  /********************************/
28092 
28093  _container.event.mpi_event.type =
28094  T_MPI_ENUM(MPI_WTIME)
28095  ;
28096 
28097  /* Set default source & dest before override */
28098  _container.event.mpi_event.source = _rank;
28099  _container.event.mpi_event.dest = _rank;
28100 
28101 
28102 
28103 
28104 
28105 
28106 
28107 
28108  /* Fill in size informations if needed */
28109  int _size = 0;
28110  #if 0
28111 
28112  #endif
28113  _container.event.mpi_event.size = _size;
28114 
28115  /********************************/
28116  /* EMIT OTF ENTER */
28117  /********************************/
28118 
28119  struct MALP_Trace_Event otf_event;
28120 
28121  uint64_t _begin = Timer_tsc ();
28122 
28125  {
28126 
28127  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _begin, 0);
28128  OTF_Event_forge( &otf_event, OTF_EVENT_ENTER,
28129  MALP_EVENT_MPI, _container.event.mpi_event.type );
28130  Event_Packer_push(&otf_event);
28131  }
28132 
28133  /********************************/
28134  /* ACTUAL FUNCTION CALL */
28135  /********************************/
28136 
28138  double ret = PMPI_Wtime( );
28140 
28141  /********************************/
28142  /* EMIT OTF END */
28143  /********************************/
28144 
28145  uint64_t _end = Timer_tsc();
28146  uint64_t _duration = _end - _begin;
28147 
28149  {
28151  {
28152 
28153  MALP_Trace_Event_fill( &otf_event, MALP_EVENT_OTF, _end, _duration);
28154  OTF_Event_forge( &otf_event, OTF_EVENT_LEAVE,
28155  MALP_EVENT_MPI, _container.event.mpi_event.type );
28156 
28157 
28158  Event_Packer_push(&otf_event);
28159  }
28160 
28161  /********************************/
28162  /* EMIT MALP EVENT */
28163  /********************************/
28164 
28165  MALP_Trace_Event_fill( &_container, MALP_EVENT_MPI, _begin, _duration );
28166 
28167  /* Submit event if MPI instrumented */
28168  Event_Packer_push(&_container);
28169  }
28170 
28171 
28172  return ret;
28173 }
28174 
int MPI_Info_free(MPI_Info *info)
Definition: MPI_Inst.c:15694
int MPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group *newgroup)
Definition: MPI_Inst.c:14446
int MPI_Cancel(MPI_Request *request)
Definition: MPI_Inst.c:2158
int MPI_Type_create_darray(int size, int rank, int ndims, int gsize_array[], int distrib_array[], int darg_array[], int psize_array[], int order, MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:21934
int MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler errhandler)
Definition: MPI_Inst.c:5326
int MPI_Comm_spawn_multiple(int count, char **array_of_commands, char ***array_of_argv, int *array_of_maxprocs, MPI_Info *array_of_info, int root, MPI_Comm comm, MPI_Comm *intercomm, int *array_of_errcodes)
Definition: MPI_Inst.c:5710
int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
Definition: MPI_Inst.c:1678
int MPI_Type_get_extent(MPI_Datatype type, MPI_Aint *lb, MPI_Aint *extent)
Definition: MPI_Inst.c:23758
int MPI_Test_cancelled(MPI_Status *status, int *flag)
Definition: MPI_Inst.c:21358
int MPI_Comm_join(int fd, MPI_Comm *intercomm)
Definition: MPI_Inst.c:4846
int rank
The rank.
Definition: Event_Desc.h:90
uint64_t size
The size arg (if present on current MPI call)
Definition: MPI_Events.h:1239
int MPI_Op_create(MPI_User_function *function, int commute, MPI_Op *op)
Definition: MPI_Inst.c:17518
int MPI_File_iwrite_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request)
Definition: MPI_Inst.c:10222
int MPI_Intercomm_merge(MPI_Comm intercomm, int high, MPI_Comm *newintercomm)
Definition: MPI_Inst.c:16366
int MPI_Close_port(char *port_name)
Definition: MPI_Inst.c:3022
static struct Stream_Descriptor * Stream_desc_get()
Getter on the current Stream_Descriptor.
Definition: Stream_MGR.h:147
int MPI_Type_create_f90_real(int p, int r, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22222
int MPI_Open_port(MPI_Info info, char *port_name)
Definition: MPI_Inst.c:17614
int MPI_Error_class(int errorcode, int *errorclass)
Definition: MPI_Inst.c:6574
int MPI_Status_f2c(int *f_status, MPI_Status *c_status)
Definition: MPI_Inst.c:20782
int MPI_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype)
Definition: MPI_Inst.c:10702
int MPI_Comm_call_errhandler(MPI_Comm comm, int errorcode)
Definition: MPI_Inst.c:3310
int MPI_Status_set_cancelled(MPI_Status *status, int flag)
Definition: MPI_Inst.c:20878
int MPI_Isend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:16750
int MPI_File_read_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:9934
int MPI_File_write_at_all_end(MPI_File fh, void *buf, MPI_Status *status)
Definition: MPI_Inst.c:10990
int MPI_Test(MPI_Request *request, int *flag, MPI_Status *status)
Definition: MPI_Inst.c:21262
int MPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:19918
int MPI_Type_set_name(MPI_Datatype type, char *type_name)
Definition: MPI_Inst.c:24622
int MPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler)
Definition: MPI_Inst.c:6478
static int TA_Conf_get_key_bool(TA_Conf_key_t key)
Get a configuration parameter value of type bool.
Definition: MALP_Config.h:233
int MPI_Win_get_errhandler(MPI_Win win, MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:26830
int MPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)
Definition: MPI_Inst.c:15022
int MPI_Scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
Definition: MPI_Inst.c:19630
int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
Definition: MPI_Inst.c:1006
int MPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group *newgroup)
Definition: MPI_Inst.c:15118
int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)
Definition: MPI_Inst.c:814
int MPI_File_get_size(MPI_File fh, MPI_Offset *size)
Definition: MPI_Inst.c:7822
int MPI_Rsend(void *ibuf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)
Definition: MPI_Inst.c:19438
int MPI_File_write(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:9262
int MPI_Testall(int count, MPI_Request array_of_requests[], int *flag, MPI_Status array_of_statuses[])
Definition: MPI_Inst.c:21070
int MPI_Finalized(int *flag)
Definition: MPI_Inst.c:12238
int MPI_Type_hvector(int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:24142
int MPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win)
Definition: MPI_Inst.c:27118
int MPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype, int root, MPI_Comm comm)
Definition: MPI_Inst.c:12526
int MPI_Type_free_keyval(int *type_keyval)
Definition: MPI_Inst.c:23374
int MPI_Comm_free(MPI_Comm *comm)
Definition: MPI_Inst.c:4270
int MPI_Status_set_elements(MPI_Status *status, MPI_Datatype datatype, int count)
Definition: MPI_Inst.c:20974
int MPI_Unpack_external(char *datarep, void *inbuf, MPI_Aint insize, MPI_Aint *position, void *outbuf, int outcount, MPI_Datatype datatype)
Definition: MPI_Inst.c:25294
int MPI_Scatterv(void *sendbuf, int *sendcounts, int *displs, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
Definition: MPI_Inst.c:19822
#define SET_TAG(a)
Definition: MPI_Inst.c:39
int MPI_Request_free(MPI_Request *request)
Definition: MPI_Inst.c:19246
int MPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:6382
int MPI_Accumulate(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win)
Definition: MPI_Inst.c:142
int MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)
Definition: MPI_Inst.c:4366
int MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler)
Definition: MPI_Inst.c:7150
int MPI_Ssend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)
Definition: MPI_Inst.c:20398
int OTF_Event_forge(struct MALP_Trace_Event *event, OTF_Event_type enterleave, MALP_Trace_event_type type, uint64_t subtype)
int MPI_Comm_remote_group(MPI_Comm comm, MPI_Group *group)
Definition: MPI_Inst.c:5038
#define SET_SOURCE(a)
Definition: MPI_Inst.c:37
int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status *status)
Definition: MPI_Inst.c:18670
int MPI_Info_set(MPI_Info info, char *key, char *value)
Definition: MPI_Inst.c:16174
int MPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype, MPI_Comm comm)
Definition: MPI_Inst.c:718
int MPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:8590
int MPI_Comm_spawn(char *command, char **argv, int maxprocs, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *intercomm, int *array_of_errcodes)
Definition: MPI_Inst.c:5614
int MPI_Buffer_detach(void *buffer, int *size)
Definition: MPI_Inst.c:2062
int MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val)
Definition: MPI_Inst.c:5230
int MPI_Type_dup(MPI_Datatype type, MPI_Datatype *newtype)
Definition: MPI_Inst.c:23086
int MPI_Errhandler_create(MPI_Handler_function *function, MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:6190
int MPI_Type_ub(MPI_Datatype mtype, MPI_Aint *ub)
Definition: MPI_Inst.c:24910
int MPI_Type_delete_attr(MPI_Datatype type, int type_keyval)
Definition: MPI_Inst.c:22990
int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords)
Definition: MPI_Inst.c:2254
int MPI_File_write_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:8782
int MPI_Op_c2f(MPI_Op op)
Definition: MPI_Inst.c:17326
int MPI_Win_get_group(MPI_Win win, MPI_Group *group)
Definition: MPI_Inst.c:26926
int MPI_File_write_all_end(MPI_File fh, void *buf, MPI_Status *status)
Definition: MPI_Inst.c:11374
int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm)
Definition: MPI_Inst.c:5806
int MPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
Definition: MPI_Inst.c:19726
int MPI_Pack(void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, int outsize, int *position, MPI_Comm comm)
Definition: MPI_Inst.c:17998
int MPI_Comm_connect(char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm)
Definition: MPI_Inst.c:3502
int MPI_Win_post(MPI_Group group, int assert, MPI_Win win)
Definition: MPI_Inst.c:27214
int MPI_Request_get_status(MPI_Request request, int *flag, MPI_Status *status)
Definition: MPI_Inst.c:19342
int MPI_Win_create_keyval(MPI_Win_copy_attr_function *win_copy_attr_fn, MPI_Win_delete_attr_function *win_delete_attr_fn, int *win_keyval, void *extra_state)
Definition: MPI_Inst.c:26254
int MPI_Barrier(MPI_Comm comm)
Definition: MPI_Inst.c:1582
int MPI_Info_create(MPI_Info *info)
Definition: MPI_Inst.c:15406
int MPI_Info_get_valuelen(MPI_Info info, char *key, int *valuelen, int *flag)
Definition: MPI_Inst.c:16078
int MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval)
Definition: MPI_Inst.c:3886
int MPI_Cart_create(MPI_Comm old_comm, int ndims, int *dims, int *periods, int reorder, MPI_Comm *comm_cart)
Definition: MPI_Inst.c:2350
int MPI_Graph_neighbors(MPI_Comm comm, int rank, int maxneighbors, int *neighbors)
Definition: MPI_Inst.c:13582
int MPI_File_seek(MPI_File fh, MPI_Offset offset, int whence)
Definition: MPI_Inst.c:9646
int MPI_Win_call_errhandler(MPI_Win win, int errorcode)
Definition: MPI_Inst.c:25870
void Event_Packer_push(struct MALP_Trace_Event *event)
Sends an event.
Definition: Event_Pack.c:141
double MPI_Wtick()
Definition: MPI_Inst.c:27982
static void MALP_Trace_Event_fill(struct MALP_Trace_Event *event, MALP_Trace_event_type type, uint64_t timestamp, uint64_t duration)
Definition: Stream_MGR.h:186
int MPI_File_preallocate(MPI_File fh, MPI_Offset size)
Definition: MPI_Inst.c:7726
int MPI_Comm_remote_size(MPI_Comm comm, int *size)
Definition: MPI_Inst.c:5134
int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm)
Definition: MPI_Inst.c:3790
int MPI_Add_error_code(int errorclass, int *errorcode)
Definition: MPI_Inst.c:334
int MPI_Win_get_attr(MPI_Win win, int win_keyval, void *attribute_val, int *flag)
Definition: MPI_Inst.c:26734
int MPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, int dest, int sendtag, int source, int recvtag, MPI_Comm comm, MPI_Status *status)
Definition: MPI_Inst.c:20206
int MPI_File_write_all_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype)
Definition: MPI_Inst.c:11278
int MPI_Get_processor_name(char *name, int *resultlen)
Definition: MPI_Inst.c:13006
int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:16558
int MPI_File_set_view(MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype, char *datarep, MPI_Info info)
Definition: MPI_Inst.c:8302
int MPI_File_open(MPI_Comm comm, char *filename, int amode, MPI_Info info, MPI_File *fh)
Definition: MPI_Inst.c:7342
static void Stream_Infos_leave_mpi()
Indicates to the current Stream_Infos (if any) that we are leaving a MPI call.
Definition: Stream_MGR.h:166
int MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims, int *periods, int *coords)
Definition: MPI_Inst.c:2446
int MPI_Attr_delete(MPI_Comm comm, int keyval)
Definition: MPI_Inst.c:1294
int MPI_File_set_size(MPI_File fh, MPI_Offset size)
Definition: MPI_Inst.c:7630
int source
The source arg (if present on current MPI call)
Definition: MPI_Events.h:1236
#define SET_DATATYPE(a)
Definition: MPI_Inst.c:42
#define SET_DEST(a)
Definition: MPI_Inst.c:38
int MPI_Type_get_name(MPI_Datatype type, char *type_name, int *resultlen)
Definition: MPI_Inst.c:23854
int MPI_Alltoallv(void *sendbuf, int *sendcounts, int *sdispls, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *rdispls, MPI_Datatype recvtype, MPI_Comm comm)
Definition: MPI_Inst.c:1102
int MPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group *newgroup)
Definition: MPI_Inst.c:14638
double MPI_Wtime()
Definition: MPI_Inst.c:28078
int MPI_Start(MPI_Request *request)
Definition: MPI_Inst.c:20494
int MPI_Gather(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
Definition: MPI_Inst.c:12430
int MPI_Info_get_nkeys(MPI_Info info, int *nkeys)
Definition: MPI_Inst.c:15886
int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm)
Definition: MPI_Inst.c:4078
int MPI_Graph_create(MPI_Comm comm_old, int nnodes, int *index, int *edges, int reorder, MPI_Comm *comm_graph)
Definition: MPI_Inst.c:13198
int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function *comm_copy_attr_fn, MPI_Comm_delete_attr_function *comm_delete_attr_fn, int *comm_keyval, void *extra_state)
Definition: MPI_Inst.c:3694
int MPI_Type_create_f90_integer(int r, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22126
int MPI_Iprobe(int source, int tag, MPI_Comm comm, int *flag, MPI_Status *status)
Definition: MPI_Inst.c:16462
int MPI_Info_get_nthkey(MPI_Info info, int n, char *key)
Definition: MPI_Inst.c:15982
int MPI_Comm_size(MPI_Comm comm, int *size)
Definition: MPI_Inst.c:5518
int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset)
Definition: MPI_Inst.c:10606
int MPI_Win_free(MPI_Win *win)
Definition: MPI_Inst.c:26542
int MPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
Definition: MPI_Inst.c:18958
int MPI_File_get_atomicity(MPI_File fh, int *flag)
Definition: MPI_Inst.c:12046
int MPI_Comm_create_errhandler(MPI_Comm_errhandler_function *function, MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:3598
int MPI_Add_error_string(int errorcode, char *string)
Definition: MPI_Inst.c:430
int MPI_File_read_all_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype)
Definition: MPI_Inst.c:11086
int MPI_Cart_shift(MPI_Comm comm, int direction, int disp, int *rank_source, int *rank_dest)
Definition: MPI_Inst.c:2734
int MPI_Win_set_attr(MPI_Win win, int win_keyval, void *attribute_val)
Definition: MPI_Inst.c:27310
int MPI_File_sync(MPI_File fh)
Definition: MPI_Inst.c:12142
int MPI_Win_fence(int assert, MPI_Win win)
Definition: MPI_Inst.c:26446
int MPI_Group_rank(MPI_Group group, int *rank)
Definition: MPI_Inst.c:14830
int MPI_Get_address(void *location, MPI_Aint *address)
Definition: MPI_Inst.c:12622
int MPI_Graph_get(MPI_Comm comm, int maxindex, int maxedges, int *index, int *edges)
Definition: MPI_Inst.c:13294
Struct defining an event.
Definition: Event_Desc.h:82
int MPI_Keyval_create(MPI_Copy_function *copy_fn, MPI_Delete_function *delete_fn, int *keyval, void *extra_state)
Definition: MPI_Inst.c:17038
int MPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm bridge_comm, int remote_leader, int tag, MPI_Comm *newintercomm)
Definition: MPI_Inst.c:16270
int MPI_File_write_ordered(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:10414
int MPI_File_iread_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request)
Definition: MPI_Inst.c:10126
int MPI_Alltoallw(void *sendbuf, int *sendcounts, int *sdispls, MPI_Datatype *sendtypes, void *recvbuf, int *recvcounts, int *rdispls, MPI_Datatype *recvtypes, MPI_Comm comm)
Definition: MPI_Inst.c:1198
int MPI_File_get_position(MPI_File fh, MPI_Offset *offset)
Definition: MPI_Inst.c:9742
int MPI_Topo_test(MPI_Comm comm, int *status)
Definition: MPI_Inst.c:21550
int MPI_Type_extent(MPI_Datatype type, MPI_Aint *extent)
Definition: MPI_Inst.c:23182
int MPI_File_call_errhandler(MPI_File fh, int errorcode)
Definition: MPI_Inst.c:6958
int MPI_Abort(MPI_Comm comm, int errorcode)
Definition: MPI_Inst.c:46
int MPI_File_write_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:8686
int MPI_Comm_get_parent(MPI_Comm *parent)
Definition: MPI_Inst.c:4654
int MPI_File_read_ordered(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:10318
int MPI_Errhandler_c2f(MPI_Errhandler errhandler)
Definition: MPI_Inst.c:6094
int MPI_File_write_ordered_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype)
Definition: MPI_Inst.c:11662
int MPI_Reduce_local(void *inbuf, void *inoutbuf, int count, MPI_Datatype datatype, MPI_Op op)
Definition: MPI_Inst.c:18862
int MPI_Unpublish_name(char *service_name, MPI_Info info, char *port_name)
Definition: MPI_Inst.c:25198
#define COMP_SIZE(a)
Definition: MPI_Inst.c:43
int MPI_Info_dup(MPI_Info info, MPI_Info *newinfo)
Definition: MPI_Inst.c:15598
int MPI_Win_delete_attr(MPI_Win win, int win_keyval)
Definition: MPI_Inst.c:26350
uint64_t mpi_rank
mpi rank of the source of the stream
int MPI_Attr_get(MPI_Comm comm, int keyval, void *attribute_val, int *flag)
Definition: MPI_Inst.c:1390
int MPI_File_write_all(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:9358
int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
Definition: MPI_Inst.c:3406
int MPI_Get(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win)
Definition: MPI_Inst.c:12910
int MPI_Irsend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:16654
int MPI_Keyval_free(int *keyval)
Definition: MPI_Inst.c:17134
int MPI_Comm_rank(MPI_Comm comm, int *rank)
Definition: MPI_Inst.c:4942
int MPI_File_get_amode(MPI_File fh, int *amode)
Definition: MPI_Inst.c:8014
int MPI_Group_size(MPI_Group group, int *size)
Definition: MPI_Inst.c:14926
int MPI_Ssend_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:20302
int MPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
Definition: MPI_Inst.c:14062
int MPI_Put(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win)
Definition: MPI_Inst.c:18382
int MPI_Comm_accept(char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm)
Definition: MPI_Inst.c:3118
int MPI_Comm_free_keyval(int *comm_keyval)
Definition: MPI_Inst.c:4174
int MPI_Unpack(void *inbuf, int insize, int *position, void *outbuf, int outcount, MPI_Datatype datatype, MPI_Comm comm)
Definition: MPI_Inst.c:25102
int MPI_Publish_name(char *service_name, MPI_Info info, char *port_name)
Definition: MPI_Inst.c:18286
int MPI_Dims_create(int nnodes, int ndims, int *dims)
Definition: MPI_Inst.c:5998
int MPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group *newgroup)
Definition: MPI_Inst.c:14254
int MPI_Grequest_start(MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn, MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request)
Definition: MPI_Inst.c:13870
MALP_Trace_event_type type
The type of the event.
Definition: Event_Desc.h:85
int MPI_Type_lb(MPI_Datatype type, MPI_Aint *lb)
Definition: MPI_Inst.c:24334
int MPI_Info_delete(MPI_Info info, char *key)
Definition: MPI_Inst.c:15502
int MPI_Query_thread(int *provided)
Definition: MPI_Inst.c:18478
int MPI_File_read_ordered_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype)
Definition: MPI_Inst.c:11470
int MPI_Waitall(int count, MPI_Request *array_of_requests, MPI_Status *array_of_statuses)
Definition: MPI_Inst.c:25390
int MPI_Attr_put(MPI_Comm comm, int keyval, void *attribute_val)
Definition: MPI_Inst.c:1486
MPI_Event_type type
The MPI event type.
Definition: MPI_Events.h:1235
int MPI_File_close(MPI_File *fh)
Definition: MPI_Inst.c:7438
int MPI_Type_vector(int count, int blocklength, int stride, MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:25006
int MPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence)
Definition: MPI_Inst.c:10510
int MPI_Waitany(int count, MPI_Request *array_of_requests, int *index, MPI_Status *status)
Definition: MPI_Inst.c:25486
int MPI_Type_create_subarray(int ndims, int size_array[], int subsize_array[], int start_array[], int order, MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22798
int MPI_File_c2f(MPI_File file)
Definition: MPI_Inst.c:6862
int MPI_Win_free_keyval(int *win_keyval)
Definition: MPI_Inst.c:26638
int MPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
Definition: MPI_Inst.c:622
int MPI_Win_c2f(MPI_Win win)
Definition: MPI_Inst.c:25774
int MPI_Group_free(MPI_Group *group)
Definition: MPI_Inst.c:14350
int MPI_Grequest_complete(MPI_Request request)
Definition: MPI_Inst.c:13774
int MPI_Win_unlock(int rank, MPI_Win win)
Definition: MPI_Inst.c:27790
int MPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler)
Definition: MPI_Inst.c:27406
int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent)
Definition: MPI_Inst.c:11854
#define SET_COMM(a)
Definition: MPI_Inst.c:41
int MPI_Errhandler_free(MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:6286
int MPI_Is_thread_main(int *flag)
Definition: MPI_Inst.c:16942
int MPI_Type_get_envelope(MPI_Datatype type, int *num_integers, int *num_addresses, int *num_datatypes, int *combiner)
Definition: MPI_Inst.c:23662
int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:8494
int MPI_Graph_neighbors_count(MPI_Comm comm, int rank, int *nneighbors)
Definition: MPI_Inst.c:13486
MALP_Trace_event_t event
The event data.
Definition: Event_Desc.h:91
int MPI_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:21838
int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status)
Definition: MPI_Inst.c:11182
int MPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int *size)
Definition: MPI_Inst.c:18094
int MPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:18574
int MPI_File_iwrite_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request)
Definition: MPI_Inst.c:8974
int MPI_Type_match_size(int typeclass, int size, MPI_Datatype *type)
Definition: MPI_Inst.c:24430
int MPI_Group_c2f(MPI_Group group)
Definition: MPI_Inst.c:13966
int MPI_Send(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)
Definition: MPI_Inst.c:20014
int dest
The destination arg (if present on current MPI call)
Definition: MPI_Events.h:1237
int MPI_Lookup_name(char *service_name, MPI_Info info, char *port_name)
Definition: MPI_Inst.c:17230
int MPI_Info_c2f(MPI_Info info)
Definition: MPI_Inst.c:15310
int MPI_Testsome(int incount, MPI_Request array_of_requests[], int *outcount, int array_of_indices[], MPI_Status array_of_statuses[])
Definition: MPI_Inst.c:21454
#define MACRO_MPI_Comm(_c)
Macro used to wrap the MPI communicator.
Definition: VMPI_Wrap.h:32
int MPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group *newgroup)
Definition: MPI_Inst.c:14158
int MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler *erhandler)
Definition: MPI_Inst.c:4462
int MPI_Add_error_class(int *errorclass)
Definition: MPI_Inst.c:238
int MPI_Bsend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)
Definition: MPI_Inst.c:1774
int MPI_Win_start(MPI_Group group, int assert, MPI_Win win)
Definition: MPI_Inst.c:27598
int MPI_Address(void *location, MPI_Aint *address)
Definition: MPI_Inst.c:526
int MPI_File_read(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:9070
int MPI_Ibsend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:15214
int MPI_Type_struct(int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype array_of_types[], MPI_Datatype *newtype)
Definition: MPI_Inst.c:24814
int MPI_Type_get_attr(MPI_Datatype type, int type_keyval, void *attribute_val, int *flag)
Definition: MPI_Inst.c:23470
int MPI_File_get_group(MPI_File fh, MPI_Group *group)
Definition: MPI_Inst.c:7918
int MPI_Get_version(int *version, int *subversion)
Definition: MPI_Inst.c:13102
int MPI_File_get_errhandler(MPI_File file, MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:7246
int MPI_Type_create_hindexed(int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22318
int MPI_Issend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:16846
int MPI_Type_create_hvector(int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22414
int MPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status *status)
Definition: MPI_Inst.c:18190
int MPI_Cart_map(MPI_Comm comm, int ndims, int *dims, int *periods, int *newrank)
Definition: MPI_Inst.c:2542
int MPI_Testany(int count, MPI_Request array_of_requests[], int *index, int *flag, MPI_Status *status)
Definition: MPI_Inst.c:21166
int MPI_Waitsome(int incount, MPI_Request *array_of_requests, int *outcount, int *array_of_indices, MPI_Status *array_of_statuses)
Definition: MPI_Inst.c:25678
int MPI_Status_c2f(MPI_Status *c_status, int *f_status)
Definition: MPI_Inst.c:20686
int MPI_Graphdims_get(MPI_Comm comm, int *nnodes, int *nedges)
Definition: MPI_Inst.c:13678
int MPI_Type_c2f(MPI_Datatype datatype)
Definition: MPI_Inst.c:21646
#define SET_COUNT(a)
Definition: MPI_Inst.c:40
int MPI_Type_get_true_extent(MPI_Datatype datatype, MPI_Aint *true_lb, MPI_Aint *true_extent)
Definition: MPI_Inst.c:23950
int MPI_Comm_c2f(MPI_Comm comm)
Definition: MPI_Inst.c:3214
int MPI_Info_get(MPI_Info info, char *key, int valuelen, char *value, int *flag)
Definition: MPI_Inst.c:15790
struct MPI_Event mpi_event
See MPI_Event.
Definition: Event_Desc.h:73
int MPI_Comm_get_name(MPI_Comm comm, char *comm_name, int *resultlen)
Definition: MPI_Inst.c:4558
int MPI_File_get_byte_offset(MPI_File fh, MPI_Offset offset, MPI_Offset *disp)
Definition: MPI_Inst.c:9838
int MPI_File_iread(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request)
Definition: MPI_Inst.c:9454
int MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank)
Definition: MPI_Inst.c:2638
int MPI_File_get_view(MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep)
Definition: MPI_Inst.c:8398
int MPI_Comm_test_inter(MPI_Comm comm, int *flag)
Definition: MPI_Inst.c:5902
int MPI_Type_set_attr(MPI_Datatype type, int type_keyval, void *attr_val)
Definition: MPI_Inst.c:24526
static void Stream_Infos_enter_mpi()
Indicates to the current Stream_Infos (if any) that we are enterning a MPI call.
Definition: Stream_MGR.h:155
int MPI_Register_datarep(char *datarep, MPI_Datarep_conversion_function *read_conversion_fn, MPI_Datarep_conversion_function *write_conversion_fn, MPI_Datarep_extent_function *dtype_file_extent_fn, void *extra_state)
Definition: MPI_Inst.c:19054
int MPI_Graph_map(MPI_Comm comm, int nnodes, int *index, int *edges, int *newrank)
Definition: MPI_Inst.c:13390
int MPI_Type_create_resized(MPI_Datatype oldtype, MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22894
int MPI_Startall(int count, MPI_Request *array_of_requests)
Definition: MPI_Inst.c:20590
int MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *new_comm)
Definition: MPI_Inst.c:2830
Enter + Leave events for OTF2 compatibility.
Definition: Event_Desc.h:47
int MPI_Win_set_name(MPI_Win win, char *win_name)
Definition: MPI_Inst.c:27502
int MPI_Win_create_errhandler(MPI_Win_errhandler_function *function, MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:26158
int MPI_Get_elements(MPI_Status *status, MPI_Datatype datatype, int *count)
Definition: MPI_Inst.c:12814
int MPI_Type_create_struct(int count, int array_of_block_lengths[], MPI_Aint array_of_displacements[], MPI_Datatype array_of_types[], MPI_Datatype *newtype)
Definition: MPI_Inst.c:22702
int MPI_File_set_info(MPI_File fh, MPI_Info info)
Definition: MPI_Inst.c:8110
int MPI_Bsend_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:1870
int MPI_File_write_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:10030
int MPI_File_read_at_all_end(MPI_File fh, void *buf, MPI_Status *status)
Definition: MPI_Inst.c:10798
int MPI_Op_commutative(MPI_Op op, int *commute)
Definition: MPI_Inst.c:17422
int MPI_Win_test(MPI_Win win, int *flag)
Definition: MPI_Inst.c:27694
int MPI_Error_string(int errorcode, char *string, int *resultlen)
Definition: MPI_Inst.c:6670
int MPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype, int source, int recvtag, MPI_Comm comm, MPI_Status *status)
Definition: MPI_Inst.c:20110
int MPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
Definition: MPI_Inst.c:6766
int MPI_Get_count(MPI_Status *status, MPI_Datatype datatype, int *count)
Definition: MPI_Inst.c:12718
int MPI_Type_create_keyval(MPI_Type_copy_attr_function *type_copy_attr_fn, MPI_Type_delete_attr_function *type_delete_attr_fn, int *type_keyval, void *extra_state)
Definition: MPI_Inst.c:22510
int MPI_Win_complete(MPI_Win win)
Definition: MPI_Inst.c:25966
int MPI_Type_size(MPI_Datatype type, int *size)
Definition: MPI_Inst.c:24718
int MPI_Type_free(MPI_Datatype *type)
Definition: MPI_Inst.c:23278
int MPI_Win_create(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win)
Definition: MPI_Inst.c:26062
The event contains MPI informations.
Definition: Event_Desc.h:45
int MPI_Free_mem(void *base)
Definition: MPI_Inst.c:12334
int MPI_Wait(MPI_Request *request, MPI_Status *status)
Definition: MPI_Inst.c:25582
int MPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
Definition: MPI_Inst.c:910
int MPI_Type_commit(MPI_Datatype *type)
Definition: MPI_Inst.c:21742
int MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)
Definition: MPI_Inst.c:18766
int MPI_Type_create_f90_complex(int p, int r, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22030
int MPI_File_read_ordered_end(MPI_File fh, void *buf, MPI_Status *status)
Definition: MPI_Inst.c:11566
int MPI_Comm_group(MPI_Comm comm, MPI_Group *group)
Definition: MPI_Inst.c:4750
int MPI_File_write_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype)
Definition: MPI_Inst.c:10894
int MPI_Cartdim_get(MPI_Comm comm, int *ndims)
Definition: MPI_Inst.c:2926
int MPI_File_set_atomicity(MPI_File fh, int flag)
Definition: MPI_Inst.c:11950
int MPI_Comm_disconnect(MPI_Comm *comm)
Definition: MPI_Inst.c:3982
int MPI_File_create_errhandler(MPI_File_errhandler_function *function, MPI_Errhandler *errhandler)
Definition: MPI_Inst.c:7054
int MPI_Type_indexed(int count, int array_of_blocklengths[], int array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:24238
int MPI_Type_hindexed(int count, int array_of_blocklengths[], MPI_Aint array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:24046
int MPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group *newgroup)
Definition: MPI_Inst.c:14542
#define T_MPI_ENUM(a)
Definition: MPI_Events.h:26
int MPI_Win_get_name(MPI_Win win, char *win_name, int *resultlen)
Definition: MPI_Inst.c:27022
int MPI_Pack_external_size(char *datarep, int incount, MPI_Datatype datatype, MPI_Aint *size)
Definition: MPI_Inst.c:17902
int MPI_File_read_all(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
Definition: MPI_Inst.c:9166
int MPI_Rsend_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)
Definition: MPI_Inst.c:19534
int MPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], MPI_Group *newgroup)
Definition: MPI_Inst.c:14734
int MPI_File_write_ordered_end(MPI_File fh, void *buf, MPI_Status *status)
Definition: MPI_Inst.c:11758
int MPI_Comm_set_name(MPI_Comm comm, char *comm_name)
Definition: MPI_Inst.c:5422
int MPI_Type_get_contents(MPI_Datatype mtype, int max_integers, int max_addresses, int max_datatypes, int array_of_integers[], MPI_Aint array_of_addresses[], MPI_Datatype array_of_datatypes[])
Definition: MPI_Inst.c:23566
int MPI_Buffer_attach(void *buffer, int size)
Definition: MPI_Inst.c:1966
int MPI_File_iwrite(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Request *request)
Definition: MPI_Inst.c:9550
int MPI_Request_c2f(MPI_Request request)
Definition: MPI_Inst.c:19150
int MPI_File_get_info(MPI_File fh, MPI_Info *info_used)
Definition: MPI_Inst.c:8206
int MPI_File_delete(char *filename, MPI_Info info)
Definition: MPI_Inst.c:7534
int MPI_Win_wait(MPI_Win win)
Definition: MPI_Inst.c:27886
int MPI_Pack_external(char *datarep, void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, MPI_Aint outsize, MPI_Aint *position)
Definition: MPI_Inst.c:17806
int MPI_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Request *request)
Definition: MPI_Inst.c:8878
int MPI_Type_create_indexed_block(int count, int blocklength, int array_of_displacements[], MPI_Datatype oldtype, MPI_Datatype *newtype)
Definition: MPI_Inst.c:22606
int MPI_Op_free(MPI_Op *op)
Definition: MPI_Inst.c:17710