Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
sed -i -e 's/\t/ /g' [sources] Please people, stop using tabs
[simgrid.git] / src / smpi / smpi_replay.c
1 /* Copyright (c) 2009-2015. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #include "private.h"
8 #include <stdio.h>
9 #include <xbt.h>
10 #include <xbt/replay.h>
11
12 #define KEY_SIZE (sizeof(int) * 2 + 1)
13
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay,smpi,"Trace Replay with SMPI");
15
16 int communicator_size = 0;
17 static int active_processes = 0;
18 xbt_dict_t reqq = NULL;
19
20 MPI_Datatype MPI_DEFAULT_TYPE;
21 MPI_Datatype MPI_CURRENT_TYPE;
22
23 static int sendbuffer_size=0;
24 char* sendbuffer=NULL;
25 static int recvbuffer_size=0;
26 char* recvbuffer=NULL;
27
28 static void log_timed_action (const char *const *action, double clock){
29   if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){
30     char *name = xbt_str_join_array(action, " ");
31     XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock);
32     free(name);
33   }
34 }
35
36
37 static xbt_dynar_t get_reqq_self(){
38    char * key;
39    
40    int size = asprintf(&key, "%d", smpi_process_index());
41    if(size==-1)
42      xbt_die("could not allocate memory for asprintf");
43    xbt_dynar_t dynar_mpi_request = (xbt_dynar_t) xbt_dict_get(reqq, key);
44    free(key);
45  
46    return dynar_mpi_request;
47 }
48
49 static void set_reqq_self(xbt_dynar_t mpi_request){
50    char * key;
51    
52    int size = asprintf(&key, "%d", smpi_process_index());
53    if(size==-1)
54      xbt_die("could not allocate memory for asprintf");
55    xbt_dict_set(reqq, key, mpi_request, free);
56    free(key);
57 }
58
59
60 //allocate a single buffer for all sends, growing it if needed
61 void* smpi_get_tmp_sendbuffer(int size){
62   if (!smpi_process_get_replaying())
63   return xbt_malloc(size);
64   if (sendbuffer_size<size){
65     sendbuffer=xbt_realloc(sendbuffer,size);
66     sendbuffer_size=size;
67   }
68   return sendbuffer;
69 }
70 //allocate a single buffer for all recv
71 void* smpi_get_tmp_recvbuffer(int size){
72   if (!smpi_process_get_replaying())
73   return xbt_malloc(size);
74   if (recvbuffer_size<size){
75     recvbuffer=xbt_realloc(recvbuffer,size);
76     recvbuffer_size=size;
77   }
78   return recvbuffer;
79 }
80
81 void smpi_free_tmp_buffer(void* buf){
82   if (!smpi_process_get_replaying())
83     xbt_free(buf);
84 }
85
86 /* Helper function */
87 static double parse_double(const char *string)
88 {
89   double value;
90   char *endptr;
91   value = strtod(string, &endptr);
92   if (*endptr != '\0')
93     THROWF(unknown_error, 0, "%s is not a double", string);
94   return value;
95 }
96
97 static MPI_Datatype decode_datatype(const char *const action)
98 {
99 // Declared datatypes,
100
101   switch(atoi(action))
102   {
103     case 0:
104       MPI_CURRENT_TYPE=MPI_DOUBLE;
105       break;
106     case 1:
107       MPI_CURRENT_TYPE=MPI_INT;
108       break;
109     case 2:
110       MPI_CURRENT_TYPE=MPI_CHAR;
111       break;
112     case 3:
113       MPI_CURRENT_TYPE=MPI_SHORT;
114       break;
115     case 4:
116       MPI_CURRENT_TYPE=MPI_LONG;
117       break;
118     case 5:
119       MPI_CURRENT_TYPE=MPI_FLOAT;
120       break;
121     case 6:
122       MPI_CURRENT_TYPE=MPI_BYTE;
123       break;
124     default:
125       MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE;
126
127   }
128    return MPI_CURRENT_TYPE;
129 }
130
131
132 const char* encode_datatype(MPI_Datatype datatype, int* known)
133 {
134
135   //default type for output is set to MPI_BYTE
136   // MPI_DEFAULT_TYPE is not set for output, use directly MPI_BYTE
137   if(known)*known=1;
138   if (datatype==MPI_BYTE){
139       return "";
140   }
141   if(datatype==MPI_DOUBLE)
142       return "0";
143   if(datatype==MPI_INT)
144       return "1";
145   if(datatype==MPI_CHAR)
146       return "2";
147   if(datatype==MPI_SHORT)
148       return "3";
149   if(datatype==MPI_LONG)
150     return "4";
151   if(datatype==MPI_FLOAT)
152       return "5";
153   //tell that the datatype is not handled by replay, and that its size should be measured and replayed as size*MPI_BYTE
154   if(known)*known=0;
155   // default - not implemented.
156   // do not warn here as we pass in this function even for other trace formats
157   return "-1";
158 }
159
160 #define CHECK_ACTION_PARAMS(action, mandatory, optional) {\
161     int i=0;\
162     while(action[i]!=NULL)\
163      i++;\
164     if(i<mandatory+2)                                           \
165     THROWF(arg_error, 0, "%s replay failed.\n" \
166           "%d items were given on the line. First two should be process_id and action.  " \
167           "This action needs after them %d mandatory arguments, and accepts %d optional ones. \n" \
168           "Please contact the Simgrid team if support is needed", __FUNCTION__, i, mandatory, optional);\
169   }
170
171
172 static void action_init(const char *const *action)
173 {
174   XBT_DEBUG("Initialize the counters");
175   CHECK_ACTION_PARAMS(action, 0, 1);
176   if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype 
177   else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype
178
179   /* start a simulated timer */
180   smpi_process_simulated_start();
181   /*initialize the number of active processes */
182   active_processes = smpi_process_count();
183
184   if (!reqq) {
185     reqq = xbt_dict_new();
186   }
187
188   set_reqq_self(xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref));
189
190   /*
191     reqq=xbt_new0(xbt_dynar_t,active_processes);
192
193     for(i=0;i<active_processes;i++){
194       reqq[i]=xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref);
195     }
196   }
197   */
198 }
199
200 static void action_finalize(const char *const *action)
201 {
202 }
203
204 static void action_comm_size(const char *const *action)
205 {
206   double clock = smpi_process_simulated_elapsed();
207
208   communicator_size = parse_double(action[2]);
209   log_timed_action (action, clock);
210 }
211
212 static void action_comm_split(const char *const *action)
213 {
214   double clock = smpi_process_simulated_elapsed();
215
216   log_timed_action (action, clock);
217 }
218
219 static void action_comm_dup(const char *const *action)
220 {
221   double clock = smpi_process_simulated_elapsed();
222
223   log_timed_action (action, clock);
224 }
225
226 static void action_compute(const char *const *action)
227 {
228   CHECK_ACTION_PARAMS(action, 1, 0);
229   double clock = smpi_process_simulated_elapsed();
230   double flops= parse_double(action[2]);
231   int rank = smpi_process_index();
232   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
233   extra->type=TRACING_COMPUTING;
234   extra->comp_size=flops;
235   TRACE_smpi_computing_in(rank, extra);
236
237   smpi_execute_flops(flops);
238
239   TRACE_smpi_computing_out(rank);
240   log_timed_action (action, clock);
241 }
242
243 static void action_send(const char *const *action)
244 {
245   CHECK_ACTION_PARAMS(action, 2, 1);
246   int to = atoi(action[2]);
247   double size=parse_double(action[3]);
248   double clock = smpi_process_simulated_elapsed();
249
250   if(action[4]) {
251     MPI_CURRENT_TYPE=decode_datatype(action[4]);
252   } else {
253     MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
254   }
255
256   int rank = smpi_process_index();
257
258   int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to);
259   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
260   extra->type = TRACING_SEND;
261   extra->send_size = size;
262   extra->src = rank;
263   extra->dst = dst_traced;
264   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
265   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
266   if (!TRACE_smpi_view_internals()) {
267     TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE));
268   }
269
270   smpi_mpi_send(NULL, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD);
271
272   log_timed_action (action, clock);
273
274   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
275 }
276
277 static void action_Isend(const char *const *action)
278 {
279   CHECK_ACTION_PARAMS(action, 2, 1);
280   int to = atoi(action[2]);
281   double size=parse_double(action[3]);
282   double clock = smpi_process_simulated_elapsed();
283   MPI_Request request;
284
285   if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
286   else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
287
288   int rank = smpi_process_index();
289   int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to);
290   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
291   extra->type = TRACING_ISEND;
292   extra->send_size = size;
293   extra->src = rank;
294   extra->dst = dst_traced;
295   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
296   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
297   if (!TRACE_smpi_view_internals()) {
298     TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE));
299   }
300
301   request = smpi_mpi_isend(NULL, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD);
302
303   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
304   request->send = 1;
305
306   xbt_dynar_push(get_reqq_self(),&request);
307
308   log_timed_action (action, clock);
309 }
310
311 static void action_recv(const char *const *action) {
312   CHECK_ACTION_PARAMS(action, 2, 1);
313   int from = atoi(action[2]);
314   double size=parse_double(action[3]);
315   double clock = smpi_process_simulated_elapsed();
316   MPI_Status status;
317
318   if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
319   else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
320
321   int rank = smpi_process_index();
322   int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from);
323
324   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
325   extra->type = TRACING_RECV;
326   extra->send_size = size;
327   extra->src = src_traced;
328   extra->dst = rank;
329   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
330   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
331
332   //unknow size from the receiver pov
333   if(size==-1){
334       smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status);
335       size=status.count;
336   }
337
338   smpi_mpi_recv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
339
340   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
341   if (!TRACE_smpi_view_internals()) {
342     TRACE_smpi_recv(rank, src_traced, rank);
343   }
344
345   log_timed_action (action, clock);
346 }
347
348 static void action_Irecv(const char *const *action)
349 {
350   CHECK_ACTION_PARAMS(action, 2, 1);
351   int from = atoi(action[2]);
352   double size=parse_double(action[3]);
353   double clock = smpi_process_simulated_elapsed();
354   MPI_Request request;
355
356   if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
357   else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
358
359   int rank = smpi_process_index();
360   int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from);
361   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
362   extra->type = TRACING_IRECV;
363   extra->send_size = size;
364   extra->src = src_traced;
365   extra->dst = rank;
366   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
367   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
368   MPI_Status status;
369   //unknow size from the receiver pov
370   if(size==-1){
371       smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status);
372       size=status.count;
373   }
374
375   request = smpi_mpi_irecv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD);
376
377   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
378   request->recv = 1;
379   xbt_dynar_push(get_reqq_self(),&request);
380
381   log_timed_action (action, clock);
382 }
383
384 static void action_test(const char *const *action){
385   CHECK_ACTION_PARAMS(action, 0, 0);
386   double clock = smpi_process_simulated_elapsed();
387   MPI_Request request;
388   MPI_Status status;
389   int flag = TRUE;
390
391   request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request);
392   //if request is null here, this may mean that a previous test has succeeded 
393   //Different times in traced application and replayed version may lead to this 
394   //In this case, ignore the extra calls.
395   if(request){
396     int rank = smpi_process_index();
397     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
398     extra->type=TRACING_TEST;
399     TRACE_smpi_testing_in(rank, extra);
400
401     flag = smpi_mpi_test(&request, &status);
402
403     XBT_DEBUG("MPI_Test result: %d", flag);
404     /* push back request in dynar to be caught by a subsequent wait. if the test
405      * did succeed, the request is now NULL.
406      */
407     xbt_dynar_push_as(get_reqq_self(),MPI_Request, request);
408
409     TRACE_smpi_testing_out(rank);
410   }
411   log_timed_action (action, clock);
412 }
413
414 static void action_wait(const char *const *action){
415   CHECK_ACTION_PARAMS(action, 0, 0);
416   double clock = smpi_process_simulated_elapsed();
417   MPI_Request request;
418   MPI_Status status;
419
420   xbt_assert(xbt_dynar_length(get_reqq_self()),
421       "action wait not preceded by any irecv or isend: %s",
422       xbt_str_join_array(action," "));
423   request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request);
424
425   if (!request){
426     /* Assuming that the trace is well formed, this mean the comm might have
427      * been caught by a MPI_test. Then just return.
428      */
429     return;
430   }
431
432   int rank = request->comm != MPI_COMM_NULL
433       ? smpi_comm_rank(request->comm)
434       : -1;
435
436   MPI_Group group = smpi_comm_group(request->comm);
437   int src_traced = smpi_group_rank(group, request->src);
438   int dst_traced = smpi_group_rank(group, request->dst);
439   int is_wait_for_receive = request->recv;
440   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
441   extra->type = TRACING_WAIT;
442   TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
443
444   smpi_mpi_wait(&request, &status);
445
446   TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
447   if (is_wait_for_receive)
448     TRACE_smpi_recv(rank, src_traced, dst_traced);
449   log_timed_action (action, clock);
450 }
451
452 static void action_waitall(const char *const *action){
453   CHECK_ACTION_PARAMS(action, 0, 0);
454   double clock = smpi_process_simulated_elapsed();
455   int count_requests=0;
456   unsigned int i=0;
457
458   count_requests=xbt_dynar_length(get_reqq_self());
459
460   if (count_requests>0) {
461     MPI_Request requests[count_requests];
462     MPI_Status status[count_requests];
463
464     /*  The reqq is an array of dynars. Its index corresponds to the rank.
465      Thus each rank saves its own requests to the array request. */
466     xbt_dynar_foreach(get_reqq_self(),i,requests[i]); 
467
468    //save information from requests
469
470    xbt_dynar_t srcs = xbt_dynar_new(sizeof(int), NULL);
471    xbt_dynar_t dsts = xbt_dynar_new(sizeof(int), NULL);
472    xbt_dynar_t recvs = xbt_dynar_new(sizeof(int), NULL);
473    for (i = 0; i < count_requests; i++) {
474     if(requests[i]){
475       int *asrc = xbt_new(int, 1);
476       int *adst = xbt_new(int, 1);
477       int *arecv = xbt_new(int, 1);
478       *asrc = requests[i]->src;
479       *adst = requests[i]->dst;
480       *arecv = requests[i]->recv;
481       xbt_dynar_insert_at(srcs, i, asrc);
482       xbt_dynar_insert_at(dsts, i, adst);
483       xbt_dynar_insert_at(recvs, i, arecv);
484       xbt_free(asrc);
485       xbt_free(adst);
486       xbt_free(arecv);
487     }else {
488       int *t = xbt_new(int, 1);
489       xbt_dynar_insert_at(srcs, i, t);
490       xbt_dynar_insert_at(dsts, i, t);
491       xbt_dynar_insert_at(recvs, i, t);
492       xbt_free(t);
493     }
494    }
495    int rank_traced = smpi_process_index();
496    instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
497    extra->type = TRACING_WAITALL;
498    extra->send_size=count_requests;
499    TRACE_smpi_ptp_in(rank_traced, -1, -1, __FUNCTION__,extra);
500
501    smpi_mpi_waitall(count_requests, requests, status);
502
503    for (i = 0; i < count_requests; i++) {
504     int src_traced, dst_traced, is_wait_for_receive;
505     xbt_dynar_get_cpy(srcs, i, &src_traced);
506     xbt_dynar_get_cpy(dsts, i, &dst_traced);
507     xbt_dynar_get_cpy(recvs, i, &is_wait_for_receive);
508     if (is_wait_for_receive) {
509       TRACE_smpi_recv(rank_traced, src_traced, dst_traced);
510     }
511    }
512    TRACE_smpi_ptp_out(rank_traced, -1, -1, __FUNCTION__);
513    //clean-up of dynars
514    xbt_dynar_free(&srcs);
515    xbt_dynar_free(&dsts);
516    xbt_dynar_free(&recvs);
517
518    //TODO xbt_dynar_free_container(get_reqq_self());
519    set_reqq_self(xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref));
520   }
521   log_timed_action (action, clock);
522 }
523
524 static void action_barrier(const char *const *action){
525   double clock = smpi_process_simulated_elapsed();
526   int rank = smpi_process_index();
527   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
528   extra->type = TRACING_BARRIER;
529   TRACE_smpi_collective_in(rank, -1, __FUNCTION__, extra);
530
531   mpi_coll_barrier_fun(MPI_COMM_WORLD);
532
533   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
534   log_timed_action (action, clock);
535 }
536
537
538 static void action_bcast(const char *const *action)
539 {
540   CHECK_ACTION_PARAMS(action, 1, 2);
541   double size = parse_double(action[2]);
542   double clock = smpi_process_simulated_elapsed();
543   int root=0;
544   /*
545    * Initialize MPI_CURRENT_TYPE in order to decrease
546    * the number of the checks
547    * */
548   MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;  
549
550   if(action[3]) {
551     root= atoi(action[3]);
552     if(action[4]) {
553       MPI_CURRENT_TYPE=decode_datatype(action[4]);   
554     }
555   }
556
557   int rank = smpi_process_index();
558   int root_traced = smpi_group_index(smpi_comm_group(MPI_COMM_WORLD), root);
559
560   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
561   extra->type = TRACING_BCAST;
562   extra->send_size = size;
563   extra->root = root_traced;
564   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
565   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
566   void *sendbuf = smpi_get_tmp_sendbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE));
567
568   mpi_coll_bcast_fun(sendbuf, size, MPI_CURRENT_TYPE, root, MPI_COMM_WORLD);
569
570   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
571   log_timed_action (action, clock);
572 }
573
574 static void action_reduce(const char *const *action)
575 {
576   CHECK_ACTION_PARAMS(action, 2, 2);
577   double comm_size = parse_double(action[2]);
578   double comp_size = parse_double(action[3]);
579   double clock = smpi_process_simulated_elapsed();
580   int root=0;
581   MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
582
583   if(action[4]) {
584     root= atoi(action[4]);
585     if(action[5]) {
586       MPI_CURRENT_TYPE=decode_datatype(action[5]);
587     }
588   }
589   
590   
591
592   int rank = smpi_process_index();
593   int root_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), root);
594   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
595   extra->type = TRACING_REDUCE;
596   extra->send_size = comm_size;
597   extra->comp_size = comp_size;
598   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
599   extra->root = root_traced;
600
601   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra);
602
603   void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE));
604   void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE));
605    mpi_coll_reduce_fun(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, root, MPI_COMM_WORLD);
606    smpi_execute_flops(comp_size);
607
608   TRACE_smpi_collective_out(rank, root_traced, __FUNCTION__);
609   log_timed_action (action, clock);
610 }
611
612 static void action_allReduce(const char *const *action) {
613   CHECK_ACTION_PARAMS(action, 2, 1);
614   double comm_size = parse_double(action[2]);
615   double comp_size = parse_double(action[3]);
616
617   if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
618   else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
619
620   double clock = smpi_process_simulated_elapsed();
621   int rank = smpi_process_index();
622   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
623   extra->type = TRACING_ALLREDUCE;
624   extra->send_size = comm_size;
625   extra->comp_size = comp_size;
626   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
627   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
628
629   void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE));
630   void *sendbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE));
631   mpi_coll_allreduce_fun(sendbuf, recvbuf, comm_size, MPI_CURRENT_TYPE, MPI_OP_NULL, MPI_COMM_WORLD);
632   smpi_execute_flops(comp_size);
633
634   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
635   log_timed_action (action, clock);
636 }
637
638 static void action_allToAll(const char *const *action) {
639   CHECK_ACTION_PARAMS(action, 2, 2); //two mandatory (send and recv volumes)
640                                      //two optional (corresponding datatypes)
641   double clock = smpi_process_simulated_elapsed();
642   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
643   int send_size = parse_double(action[2]);
644   int recv_size = parse_double(action[3]);
645   MPI_Datatype MPI_CURRENT_TYPE2;
646
647   if(action[4] && action[5]) {
648     MPI_CURRENT_TYPE=decode_datatype(action[4]);
649     MPI_CURRENT_TYPE2=decode_datatype(action[5]);
650   }
651   else{
652     MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE;
653     MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE;
654   }
655
656   void *send = smpi_get_tmp_sendbuffer(send_size*comm_size* smpi_datatype_size(MPI_CURRENT_TYPE));
657   void *recv = smpi_get_tmp_recvbuffer(recv_size*comm_size* smpi_datatype_size(MPI_CURRENT_TYPE2));
658
659   int rank = smpi_process_index();
660   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
661   extra->type = TRACING_ALLTOALL;
662   extra->send_size = send_size;
663   extra->recv_size = recv_size;
664   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
665   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
666
667   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
668
669   mpi_coll_alltoall_fun(send, send_size, MPI_CURRENT_TYPE, recv, recv_size, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
670
671   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
672   log_timed_action (action, clock);
673 }
674
675
676 static void action_gather(const char *const *action) {
677   /*
678  The structure of the gather action for the rank 0 (total 4 processes) 
679  is the following:   
680  0 gather 68 68 0 0 0
681
682   where: 
683   1) 68 is the sendcounts
684   2) 68 is the recvcounts
685   3) 0 is the root node
686   4) 0 is the send datatype id, see decode_datatype()
687   5) 0 is the recv datatype id, see decode_datatype()
688   */
689   CHECK_ACTION_PARAMS(action, 2, 3);
690   double clock = smpi_process_simulated_elapsed();
691   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
692   int send_size = parse_double(action[2]);
693   int recv_size = parse_double(action[3]);
694   MPI_Datatype MPI_CURRENT_TYPE2;
695   if(action[4] && action[5]) {
696     MPI_CURRENT_TYPE=decode_datatype(action[5]);
697     MPI_CURRENT_TYPE2=decode_datatype(action[6]);
698   } else {
699     MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE;
700     MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE;
701   }
702   void *send = smpi_get_tmp_sendbuffer(send_size* smpi_datatype_size(MPI_CURRENT_TYPE));
703   void *recv = NULL;
704   int root=0;
705   if(action[4])
706     root=atoi(action[4]);
707   int rank = smpi_comm_rank(MPI_COMM_WORLD);
708
709   if(rank==root)
710     recv = smpi_get_tmp_recvbuffer(recv_size*comm_size* smpi_datatype_size(MPI_CURRENT_TYPE2));
711
712   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
713   extra->type = TRACING_GATHER;
714   extra->send_size = send_size;
715   extra->recv_size = recv_size;
716   extra->root = root;
717   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
718   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
719
720   TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra);
721
722   mpi_coll_gather_fun(send, send_size, MPI_CURRENT_TYPE,
723                 recv, recv_size, MPI_CURRENT_TYPE2,
724                 root, MPI_COMM_WORLD);
725
726   TRACE_smpi_collective_out(smpi_process_index(), -1, __FUNCTION__);
727   log_timed_action (action, clock);
728 }
729
730
731
732 static void action_gatherv(const char *const *action) {
733   /*
734  The structure of the gatherv action for the rank 0 (total 4 processes)
735  is the following:
736  0 gather 68 68 10 10 10 0 0 0
737
738   where:
739   1) 68 is the sendcount
740   2) 68 10 10 10 is the recvcounts
741   3) 0 is the root node
742   4) 0 is the send datatype id, see decode_datatype()
743   5) 0 is the recv datatype id, see decode_datatype()
744   */
745
746   double clock = smpi_process_simulated_elapsed();
747   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
748   CHECK_ACTION_PARAMS(action, comm_size+1, 2);
749   int send_size = parse_double(action[2]);
750   int *disps = xbt_new0(int, comm_size);
751   int *recvcounts = xbt_new0(int, comm_size);
752   int i=0,recv_sum=0;
753
754   MPI_Datatype MPI_CURRENT_TYPE2;
755   if(action[4+comm_size] && action[5+comm_size]) {
756     MPI_CURRENT_TYPE=decode_datatype(action[4+comm_size]);
757     MPI_CURRENT_TYPE2=decode_datatype(action[5+comm_size]);
758   } else {
759     MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE;
760     MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE;
761   }
762   void *send = smpi_get_tmp_sendbuffer(send_size* smpi_datatype_size(MPI_CURRENT_TYPE));
763   void *recv = NULL;
764   for(i=0;i<comm_size;i++) {
765     recvcounts[i] = atoi(action[i+3]);
766     recv_sum=recv_sum+recvcounts[i];
767     disps[i] = 0;
768   }
769
770   int root=atoi(action[3+comm_size]);
771   int rank = smpi_comm_rank(MPI_COMM_WORLD);;
772
773   if(rank==root)
774     recv = smpi_get_tmp_recvbuffer(recv_sum* smpi_datatype_size(MPI_CURRENT_TYPE2));
775
776   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
777   extra->type = TRACING_GATHERV;
778   extra->send_size = send_size;
779   extra->recvcounts= xbt_malloc(comm_size*sizeof(int));
780   for(i=0; i< comm_size; i++)//copy data to avoid bad free
781     extra->recvcounts[i] = recvcounts[i];
782   extra->root = root;
783   extra->num_processes = comm_size;
784   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
785   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
786
787   TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra);
788
789   smpi_mpi_gatherv(send, send_size, MPI_CURRENT_TYPE,
790                 recv, recvcounts, disps, MPI_CURRENT_TYPE2,
791                 root, MPI_COMM_WORLD);
792
793   TRACE_smpi_collective_out(smpi_process_index(), -1, __FUNCTION__);
794   log_timed_action (action, clock);
795   xbt_free(recvcounts);
796   xbt_free(disps);
797 }
798
799 static void action_reducescatter(const char *const *action) {
800
801     /*
802  The structure of the reducescatter action for the rank 0 (total 4 processes) 
803  is the following:   
804 0 reduceScatter 275427 275427 275427 204020 11346849 0
805
806   where: 
807   1) The first four values after the name of the action declare the recvcounts array
808   2) The value 11346849 is the amount of instructions
809   3) The last value corresponds to the datatype, see decode_datatype().
810
811   We analyze a MPI_Reduce_scatter call to one MPI_Reduce and one MPI_Scatterv.
812
813    */
814
815   double clock = smpi_process_simulated_elapsed();
816   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
817   CHECK_ACTION_PARAMS(action, comm_size+1, 1);
818   int comp_size = parse_double(action[2+comm_size]);
819   int *recvcounts = xbt_new0(int, comm_size);  
820   int *disps = xbt_new0(int, comm_size);  
821   int i=0;
822   int rank = smpi_process_index();
823   int size = 0;
824   if(action[3+comm_size])
825     MPI_CURRENT_TYPE=decode_datatype(action[3+comm_size]);
826   else
827     MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
828
829   for(i=0;i<comm_size;i++) {
830     recvcounts[i] = atoi(action[i+2]);
831     disps[i] = 0;
832     size+=recvcounts[i];
833   }
834
835   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
836   extra->type = TRACING_REDUCE_SCATTER;
837   extra->send_size = 0;
838   extra->recvcounts= xbt_malloc(comm_size*sizeof(int));
839   for(i=0; i< comm_size; i++)//copy data to avoid bad free
840     extra->recvcounts[i] = recvcounts[i];
841   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
842   extra->comp_size = comp_size;
843   extra->num_processes = comm_size;
844
845   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
846
847   void *sendbuf = smpi_get_tmp_sendbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE));
848   void *recvbuf = smpi_get_tmp_recvbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE));
849    
850    mpi_coll_reduce_scatter_fun(sendbuf, recvbuf, recvcounts, MPI_CURRENT_TYPE, MPI_OP_NULL,
851        MPI_COMM_WORLD);
852    smpi_execute_flops(comp_size);
853
854
855   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
856   xbt_free(recvcounts);
857   xbt_free(disps);
858   log_timed_action (action, clock);
859 }
860
861 static void action_allgather(const char *const *action) {
862   /*
863  The structure of the allgather action for the rank 0 (total 4 processes) 
864  is the following:   
865   0 allGather 275427 275427
866
867   where: 
868   1) 275427 is the sendcount
869   2) 275427 is the recvcount
870   3) No more values mean that the datatype for sent and receive buffer
871   is the default one, see decode_datatype().
872
873    */
874
875   double clock = smpi_process_simulated_elapsed();
876
877   CHECK_ACTION_PARAMS(action, 2, 2);
878   int sendcount=atoi(action[2]); 
879   int recvcount=atoi(action[3]); 
880
881   MPI_Datatype MPI_CURRENT_TYPE2;
882
883   if(action[4] && action[5]) {
884     MPI_CURRENT_TYPE = decode_datatype(action[4]);
885     MPI_CURRENT_TYPE2 = decode_datatype(action[5]);
886   } else {
887     MPI_CURRENT_TYPE = MPI_DEFAULT_TYPE;
888     MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE;    
889   }
890   void *sendbuf = smpi_get_tmp_sendbuffer(sendcount* smpi_datatype_size(MPI_CURRENT_TYPE));
891   void *recvbuf = smpi_get_tmp_recvbuffer(recvcount* smpi_datatype_size(MPI_CURRENT_TYPE2));
892
893   int rank = smpi_process_index();
894   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
895   extra->type = TRACING_ALLGATHER;
896   extra->send_size = sendcount;
897   extra->recv_size= recvcount;
898   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
899   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
900   extra->num_processes = smpi_comm_size(MPI_COMM_WORLD);
901
902   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
903
904   mpi_coll_allgather_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcount, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
905
906   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
907   log_timed_action (action, clock);
908 }
909
910 static void action_allgatherv(const char *const *action) {
911
912   /*
913  The structure of the allgatherv action for the rank 0 (total 4 processes) 
914  is the following:   
915 0 allGatherV 275427 275427 275427 275427 204020
916
917   where: 
918   1) 275427 is the sendcount
919   2) The next four elements declare the recvcounts array
920   3) No more values mean that the datatype for sent and receive buffer
921   is the default one, see decode_datatype().
922
923    */
924
925   double clock = smpi_process_simulated_elapsed();
926
927   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
928   CHECK_ACTION_PARAMS(action, comm_size+1, 2);
929   int i=0;
930   int sendcount=atoi(action[2]);
931   int *recvcounts = xbt_new0(int, comm_size);  
932   int *disps = xbt_new0(int, comm_size);  
933   int recv_sum=0;  
934   MPI_Datatype MPI_CURRENT_TYPE2;
935
936   if(action[3+comm_size] && action[4+comm_size]) {
937     MPI_CURRENT_TYPE = decode_datatype(action[3+comm_size]);
938     MPI_CURRENT_TYPE2 = decode_datatype(action[4+comm_size]);
939   } else {
940     MPI_CURRENT_TYPE = MPI_DEFAULT_TYPE;
941     MPI_CURRENT_TYPE2 = MPI_DEFAULT_TYPE;    
942   }
943   void *sendbuf = smpi_get_tmp_sendbuffer(sendcount* smpi_datatype_size(MPI_CURRENT_TYPE));
944
945   for(i=0;i<comm_size;i++) {
946     recvcounts[i] = atoi(action[i+3]);
947     recv_sum=recv_sum+recvcounts[i];
948   }
949   void *recvbuf = smpi_get_tmp_recvbuffer(recv_sum* smpi_datatype_size(MPI_CURRENT_TYPE2));
950
951   int rank = smpi_process_index();
952   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
953   extra->type = TRACING_ALLGATHERV;
954   extra->send_size = sendcount;
955   extra->recvcounts= xbt_malloc(comm_size*sizeof(int));
956   for(i=0; i< comm_size; i++)//copy data to avoid bad free
957     extra->recvcounts[i] = recvcounts[i];
958   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
959   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
960   extra->num_processes = comm_size;
961
962   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
963
964   mpi_coll_allgatherv_fun(sendbuf, sendcount, MPI_CURRENT_TYPE, recvbuf, recvcounts, disps, MPI_CURRENT_TYPE2, MPI_COMM_WORLD);
965
966   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
967   log_timed_action (action, clock);
968   xbt_free(recvcounts);
969   xbt_free(disps);
970 }
971
972 static void action_allToAllv(const char *const *action) {
973   /*
974  The structure of the allToAllV action for the rank 0 (total 4 processes) 
975  is the following:   
976   0 allToAllV 100 1 7 10 12 100 1 70 10 5
977
978   where: 
979   1) 100 is the size of the send buffer *sizeof(int),
980   2) 1 7 10 12 is the sendcounts array
981   3) 100*sizeof(int) is the size of the receiver buffer
982   4)  1 70 10 5 is the recvcounts array
983
984    */
985
986
987   double clock = smpi_process_simulated_elapsed();
988
989   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
990   CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2);
991   int send_buf_size=0,recv_buf_size=0,i=0;
992   int *sendcounts = xbt_new0(int, comm_size);  
993   int *recvcounts = xbt_new0(int, comm_size);  
994   int *senddisps = xbt_new0(int, comm_size);  
995   int *recvdisps = xbt_new0(int, comm_size);  
996
997   MPI_Datatype MPI_CURRENT_TYPE2;
998
999   send_buf_size=parse_double(action[2]);
1000   recv_buf_size=parse_double(action[3+comm_size]);
1001   if(action[4+2*comm_size] && action[5+2*comm_size]) {
1002     MPI_CURRENT_TYPE=decode_datatype(action[4+2*comm_size]);
1003     MPI_CURRENT_TYPE2=decode_datatype(action[5+2*comm_size]);
1004   }
1005   else{
1006     MPI_CURRENT_TYPE=MPI_DEFAULT_TYPE;
1007     MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE;
1008   }
1009
1010   void *sendbuf = smpi_get_tmp_sendbuffer(send_buf_size* smpi_datatype_size(MPI_CURRENT_TYPE));
1011   void *recvbuf  = smpi_get_tmp_recvbuffer(recv_buf_size* smpi_datatype_size(MPI_CURRENT_TYPE2));
1012
1013   for(i=0;i<comm_size;i++) {
1014     sendcounts[i] = atoi(action[i+3]);
1015     recvcounts[i] = atoi(action[i+4+comm_size]);
1016   }
1017
1018
1019   int rank = smpi_process_index();
1020   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1021   extra->type = TRACING_ALLTOALLV;
1022   extra->recvcounts= xbt_malloc(comm_size*sizeof(int));
1023   extra->sendcounts= xbt_malloc(comm_size*sizeof(int));
1024   extra->num_processes = comm_size;
1025
1026   for(i=0; i< comm_size; i++){//copy data to avoid bad free
1027     extra->send_size += sendcounts[i];
1028     extra->sendcounts[i] = sendcounts[i];
1029     extra->recv_size += recvcounts[i];
1030     extra->recvcounts[i] = recvcounts[i];
1031   }
1032   extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
1033   extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
1034
1035   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
1036
1037   mpi_coll_alltoallv_fun(sendbuf, sendcounts, senddisps, MPI_CURRENT_TYPE,
1038                                recvbuf, recvcounts, recvdisps, MPI_CURRENT_TYPE,
1039                                MPI_COMM_WORLD);
1040
1041   TRACE_smpi_collective_out(rank, -1, __FUNCTION__);
1042   log_timed_action (action, clock);
1043   xbt_free(sendcounts);
1044   xbt_free(recvcounts);
1045   xbt_free(senddisps);
1046   xbt_free(recvdisps);
1047 }
1048
1049 void smpi_replay_run(int *argc, char***argv){
1050   /* First initializes everything */
1051   smpi_process_init(argc, argv);
1052   smpi_process_mark_as_initialized();
1053   smpi_process_set_replaying(1);
1054
1055   int rank = smpi_process_index();
1056   TRACE_smpi_init(rank);
1057   TRACE_smpi_computing_init(rank);
1058   instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
1059   extra->type = TRACING_INIT;
1060   char *operation =bprintf("%s_init",__FUNCTION__);
1061   TRACE_smpi_collective_in(rank, -1, operation, extra);
1062   TRACE_smpi_collective_out(rank, -1, operation);
1063   free(operation);
1064
1065   if (!_xbt_replay_action_init()) {
1066     xbt_replay_action_register("init",       action_init);
1067     xbt_replay_action_register("finalize",   action_finalize);
1068     xbt_replay_action_register("comm_size",  action_comm_size);
1069     xbt_replay_action_register("comm_split", action_comm_split);
1070     xbt_replay_action_register("comm_dup",   action_comm_dup);
1071     xbt_replay_action_register("send",       action_send);
1072     xbt_replay_action_register("Isend",      action_Isend);
1073     xbt_replay_action_register("recv",       action_recv);
1074     xbt_replay_action_register("Irecv",      action_Irecv);
1075     xbt_replay_action_register("test",       action_test);
1076     xbt_replay_action_register("wait",       action_wait);
1077     xbt_replay_action_register("waitAll",    action_waitall);
1078     xbt_replay_action_register("barrier",    action_barrier);
1079     xbt_replay_action_register("bcast",      action_bcast);
1080     xbt_replay_action_register("reduce",     action_reduce);
1081     xbt_replay_action_register("allReduce",  action_allReduce);
1082     xbt_replay_action_register("allToAll",   action_allToAll);
1083     xbt_replay_action_register("allToAllV",  action_allToAllv);
1084     xbt_replay_action_register("gather",  action_gather);
1085     xbt_replay_action_register("gatherV",  action_gatherv);
1086     xbt_replay_action_register("allGather",  action_allgather);
1087     xbt_replay_action_register("allGatherV",  action_allgatherv);
1088     xbt_replay_action_register("reduceScatter",  action_reducescatter);
1089     xbt_replay_action_register("compute",    action_compute);
1090   }
1091   
1092   //if we have a delayed start, sleep here.
1093   if(*argc>2){
1094     char *endptr;
1095     double value = strtod((*argv)[2], &endptr);
1096     if (*endptr != '\0')
1097       THROWF(unknown_error, 0, "%s is not a double", (*argv)[2]);
1098     XBT_VERB("Delayed start for instance - Sleeping for %f flops ",value );
1099     smpi_execute_flops(value);
1100   } else {
1101     //UGLY: force a context switch to be sure that all MSG_processes begin initialization
1102     XBT_DEBUG("Force context switch by smpi_execute_flops  - Sleeping for 0.0 flops ");
1103     smpi_execute_flops(0.0);
1104   }
1105   
1106   /* Actually run the replay */
1107   xbt_replay_action_runner(*argc, *argv);
1108
1109   /* and now, finalize everything */
1110   double sim_time= 1.;
1111   /* One active process will stop. Decrease the counter*/
1112   XBT_DEBUG("There are %lu elements in reqq[*]",
1113             xbt_dynar_length(get_reqq_self()));
1114   if (!xbt_dynar_is_empty(get_reqq_self())){
1115     int count_requests=xbt_dynar_length(get_reqq_self());
1116     MPI_Request requests[count_requests];
1117     MPI_Status status[count_requests];
1118     unsigned int i;
1119
1120     xbt_dynar_foreach(get_reqq_self(),i,requests[i]);
1121     smpi_mpi_waitall(count_requests, requests, status);
1122     active_processes--;
1123   } else {
1124     active_processes--;
1125   }
1126
1127   if(!active_processes){
1128     /* Last process alive speaking */
1129     /* end the simulated timer */
1130     sim_time = smpi_process_simulated_elapsed();
1131   }
1132   
1133
1134   //TODO xbt_dynar_free_container(get_reqq_self()));
1135
1136   if(!active_processes){
1137     XBT_INFO("Simulation time %f", sim_time);
1138     _xbt_replay_action_exit();
1139     xbt_free(sendbuffer);
1140     xbt_free(recvbuffer);
1141     //xbt_free(reqq);
1142     xbt_dict_free(&reqq); //not need, data have been freed ???
1143     reqq = NULL;
1144   }
1145   
1146   instr_extra_data extra_fin = xbt_new0(s_instr_extra_data_t,1);
1147   extra_fin->type = TRACING_FINALIZE;
1148   operation =bprintf("%s_finalize",__FUNCTION__);
1149   TRACE_smpi_collective_in(rank, -1, operation, extra_fin);
1150
1151   smpi_process_finalize();
1152
1153   TRACE_smpi_collective_out(rank, -1, operation);
1154   TRACE_smpi_finalize(smpi_process_index());
1155   smpi_process_destroy();
1156   free(operation);
1157 }