X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8f8b678e269538ddacde5cfc56a1f26b7daa4b91..bff0c1c16b4447b3503aa48d11b15243154ed51a:/src/smpi/smpi_replay.cpp

diff --git a/src/smpi/smpi_replay.cpp b/src/smpi/smpi_replay.cpp
index 7975f1c1aa..08e9998dad 100644
--- a/src/smpi/smpi_replay.cpp
+++ b/src/smpi/smpi_replay.cpp
@@ -15,29 +15,29 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_replay,smpi,"Trace Replay with SMPI");
 
 int communicator_size = 0;
 static int active_processes = 0;
-xbt_dict_t reqq = NULL;
+xbt_dict_t reqq = nullptr;
 
 MPI_Datatype MPI_DEFAULT_TYPE;
 MPI_Datatype MPI_CURRENT_TYPE;
 
 static int sendbuffer_size=0;
-char* sendbuffer=NULL;
+char* sendbuffer=nullptr;
 static int recvbuffer_size=0;
-char* recvbuffer=NULL;
+char* recvbuffer=nullptr;
 
 static void log_timed_action (const char *const *action, double clock){
   if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){
     char *name = xbt_str_join_array(action, " ");
     XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock);
-    free(name);
+    xbt_free(name);
   }
 }
 
 static xbt_dynar_t get_reqq_self()
 {
    char * key = bprintf("%d", smpi_process_index());
-   xbt_dynar_t dynar_mpi_request = (xbt_dynar_t) xbt_dict_get(reqq, key);
-   free(key);
+   xbt_dynar_t dynar_mpi_request = static_cast<xbt_dynar_t>(xbt_dict_get(reqq, key));
+   xbt_free(key);
  
    return dynar_mpi_request;
 }
@@ -46,7 +46,7 @@ static void set_reqq_self(xbt_dynar_t mpi_request)
 {
    char * key = bprintf("%d", smpi_process_index());
    xbt_dict_set(reqq, key, mpi_request, free);
-   free(key);
+   xbt_free(key);
 }
 
 //allocate a single buffer for all sends, growing it if needed
@@ -124,7 +124,8 @@ const char* encode_datatype(MPI_Datatype datatype, int* known)
 {
   //default type for output is set to MPI_BYTE
   // MPI_DEFAULT_TYPE is not set for output, use directly MPI_BYTE
-  if(known)*known=1;
+  if(known!=nullptr)
+    *known=1;
   if (datatype==MPI_BYTE){
       return "";
   }
@@ -141,7 +142,8 @@ const char* encode_datatype(MPI_Datatype datatype, int* known)
   if(datatype==MPI_FLOAT)
       return "5";
   //tell that the datatype is not handled by replay, and that its size should be measured and replayed as size*MPI_BYTE
-  if(known)*known=0;
+  if(known!=nullptr)
+    *known=0;
   // default - not implemented.
   // do not warn here as we pass in this function even for other trace formats
   return "-1";
@@ -149,7 +151,7 @@ const char* encode_datatype(MPI_Datatype datatype, int* known)
 
 #define CHECK_ACTION_PARAMS(action, mandatory, optional) {\
     int i=0;\
-    while(action[i]!=NULL)\
+    while(action[i]!=nullptr)\
      i++;\
     if(i<mandatory+2)                                           \
     THROWF(arg_error, 0, "%s replay failed.\n" \
@@ -161,8 +163,9 @@ const char* encode_datatype(MPI_Datatype datatype, int* known)
 static void action_init(const char *const *action)
 {
   XBT_DEBUG("Initialize the counters");
-  CHECK_ACTION_PARAMS(action, 0, 1);
-  if(action[2]) MPI_DEFAULT_TYPE= MPI_DOUBLE; // default MPE dataype 
+  CHECK_ACTION_PARAMS(action, 0, 1)
+  if(action[2]) 
+    MPI_DEFAULT_TYPE=MPI_DOUBLE; // default MPE dataype 
   else MPI_DEFAULT_TYPE= MPI_BYTE; // default TAU datatype
 
   /* start a simulated timer */
@@ -170,7 +173,7 @@ static void action_init(const char *const *action)
   /*initialize the number of active processes */
   active_processes = smpi_process_count();
 
-  if (!reqq) {
+  if (reqq==nullptr) {
     reqq = xbt_dict_new();
   }
 
@@ -179,6 +182,7 @@ static void action_init(const char *const *action)
 
 static void action_finalize(const char *const *action)
 {
+  /* do nothing */
 }
 
 static void action_comm_size(const char *const *action)
@@ -205,7 +209,7 @@ static void action_comm_dup(const char *const *action)
 
 static void action_compute(const char *const *action)
 {
-  CHECK_ACTION_PARAMS(action, 1, 0);
+  CHECK_ACTION_PARAMS(action, 1, 0)
   double clock = smpi_process_simulated_elapsed();
   double flops= parse_double(action[2]);
   int rank = smpi_process_index();
@@ -222,16 +226,15 @@ static void action_compute(const char *const *action)
 
 static void action_send(const char *const *action)
 {
-  CHECK_ACTION_PARAMS(action, 2, 1);
+  CHECK_ACTION_PARAMS(action, 2, 1)
   int to = atoi(action[2]);
   double size=parse_double(action[3]);
   double clock = smpi_process_simulated_elapsed();
 
-  if(action[4]) {
+  if(action[4])
     MPI_CURRENT_TYPE=decode_datatype(action[4]);
-  } else {
+  else
     MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
-  }
 
   int rank = smpi_process_index();
 
@@ -241,13 +244,13 @@ static void action_send(const char *const *action)
   extra->send_size = size;
   extra->src = rank;
   extra->dst = dst_traced;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
   if (!TRACE_smpi_view_internals()) {
     TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE));
   }
 
-  smpi_mpi_send(NULL, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD);
+  smpi_mpi_send(nullptr, size, MPI_CURRENT_TYPE, to , 0, MPI_COMM_WORLD);
 
   log_timed_action (action, clock);
 
@@ -256,14 +259,16 @@ static void action_send(const char *const *action)
 
 static void action_Isend(const char *const *action)
 {
-  CHECK_ACTION_PARAMS(action, 2, 1);
+  CHECK_ACTION_PARAMS(action, 2, 1)
   int to = atoi(action[2]);
   double size=parse_double(action[3]);
   double clock = smpi_process_simulated_elapsed();
   MPI_Request request;
 
-  if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
-  else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
+  if(action[4]) 
+    MPI_CURRENT_TYPE=decode_datatype(action[4]);
+  else 
+    MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
 
   int rank = smpi_process_index();
   int dst_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), to);
@@ -272,13 +277,13 @@ static void action_Isend(const char *const *action)
   extra->send_size = size;
   extra->src = rank;
   extra->dst = dst_traced;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   TRACE_smpi_ptp_in(rank, rank, dst_traced, __FUNCTION__, extra);
   if (!TRACE_smpi_view_internals()) {
     TRACE_smpi_send(rank, rank, dst_traced, size*smpi_datatype_size(MPI_CURRENT_TYPE));
   }
 
-  request = smpi_mpi_isend(NULL, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD);
+  request = smpi_mpi_isend(nullptr, size, MPI_CURRENT_TYPE, to, 0,MPI_COMM_WORLD);
 
   TRACE_smpi_ptp_out(rank, rank, dst_traced, __FUNCTION__);
   request->send = 1;
@@ -289,14 +294,16 @@ static void action_Isend(const char *const *action)
 }
 
 static void action_recv(const char *const *action) {
-  CHECK_ACTION_PARAMS(action, 2, 1);
+  CHECK_ACTION_PARAMS(action, 2, 1)
   int from = atoi(action[2]);
   double size=parse_double(action[3]);
   double clock = smpi_process_simulated_elapsed();
   MPI_Status status;
 
-  if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
-  else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
+  if(action[4]) 
+    MPI_CURRENT_TYPE=decode_datatype(action[4]);
+  else 
+    MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
 
   int rank = smpi_process_index();
   int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from);
@@ -306,16 +313,16 @@ static void action_recv(const char *const *action) {
   extra->send_size = size;
   extra->src = src_traced;
   extra->dst = rank;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
 
   //unknow size from the receiver pov
-  if(size==-1){
+  if(size<=0.0){
       smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status);
       size=status.count;
   }
 
-  smpi_mpi_recv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
+  smpi_mpi_recv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD, &status);
 
   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
   if (!TRACE_smpi_view_internals()) {
@@ -327,14 +334,16 @@ static void action_recv(const char *const *action) {
 
 static void action_Irecv(const char *const *action)
 {
-  CHECK_ACTION_PARAMS(action, 2, 1);
+  CHECK_ACTION_PARAMS(action, 2, 1)
   int from = atoi(action[2]);
   double size=parse_double(action[3]);
   double clock = smpi_process_simulated_elapsed();
   MPI_Request request;
 
-  if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
-  else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
+  if(action[4]) 
+    MPI_CURRENT_TYPE=decode_datatype(action[4]);
+  else 
+    MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
 
   int rank = smpi_process_index();
   int src_traced = smpi_group_rank(smpi_comm_group(MPI_COMM_WORLD), from);
@@ -343,16 +352,16 @@ static void action_Irecv(const char *const *action)
   extra->send_size = size;
   extra->src = src_traced;
   extra->dst = rank;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   TRACE_smpi_ptp_in(rank, src_traced, rank, __FUNCTION__, extra);
   MPI_Status status;
   //unknow size from the receiver pov
-  if(size==-1){
+  if(size<=0.0){
       smpi_mpi_probe(from, 0, MPI_COMM_WORLD, &status);
       size=status.count;
   }
 
-  request = smpi_mpi_irecv(NULL, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD);
+  request = smpi_mpi_irecv(nullptr, size, MPI_CURRENT_TYPE, from, 0, MPI_COMM_WORLD);
 
   TRACE_smpi_ptp_out(rank, src_traced, rank, __FUNCTION__);
   request->recv = 1;
@@ -362,7 +371,7 @@ static void action_Irecv(const char *const *action)
 }
 
 static void action_test(const char *const *action){
-  CHECK_ACTION_PARAMS(action, 0, 0);
+  CHECK_ACTION_PARAMS(action, 0, 0)
   double clock = smpi_process_simulated_elapsed();
   MPI_Request request;
   MPI_Status status;
@@ -372,7 +381,7 @@ static void action_test(const char *const *action){
   //if request is null here, this may mean that a previous test has succeeded 
   //Different times in traced application and replayed version may lead to this 
   //In this case, ignore the extra calls.
-  if(request){
+  if(request!=nullptr){
     int rank = smpi_process_index();
     instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
     extra->type=TRACING_TEST;
@@ -381,7 +390,7 @@ static void action_test(const char *const *action){
     flag = smpi_mpi_test(&request, &status);
 
     XBT_DEBUG("MPI_Test result: %d", flag);
-    /* push back request in dynar to be caught by a subsequent wait. if the test did succeed, the request is now NULL.*/
+    /* push back request in dynar to be caught by a subsequent wait. if the test did succeed, the request is now nullptr.*/
     xbt_dynar_push_as(get_reqq_self(),MPI_Request, request);
 
     TRACE_smpi_testing_out(rank);
@@ -390,7 +399,7 @@ static void action_test(const char *const *action){
 }
 
 static void action_wait(const char *const *action){
-  CHECK_ACTION_PARAMS(action, 0, 0);
+  CHECK_ACTION_PARAMS(action, 0, 0)
   double clock = smpi_process_simulated_elapsed();
   MPI_Request request;
   MPI_Status status;
@@ -400,7 +409,7 @@ static void action_wait(const char *const *action){
       xbt_str_join_array(action," "));
   request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request);
 
-  if (!request){
+  if (request==nullptr){
     /* Assume that the trace is well formed, meaning the comm might have been caught by a MPI_test. Then just return.*/
     return;
   }
@@ -424,7 +433,7 @@ static void action_wait(const char *const *action){
 }
 
 static void action_waitall(const char *const *action){
-  CHECK_ACTION_PARAMS(action, 0, 0);
+  CHECK_ACTION_PARAMS(action, 0, 0)
   double clock = smpi_process_simulated_elapsed();
   int count_requests=0;
   unsigned int i=0;
@@ -440,10 +449,10 @@ static void action_waitall(const char *const *action){
     xbt_dynar_foreach(get_reqq_self(),i,requests[i]); 
 
    //save information from requests
-   xbt_dynar_t srcs = xbt_dynar_new(sizeof(int), NULL);
-   xbt_dynar_t dsts = xbt_dynar_new(sizeof(int), NULL);
-   xbt_dynar_t recvs = xbt_dynar_new(sizeof(int), NULL);
-   for (i = 0; (int)i < count_requests; i++) {
+   xbt_dynar_t srcs = xbt_dynar_new(sizeof(int), nullptr);
+   xbt_dynar_t dsts = xbt_dynar_new(sizeof(int), nullptr);
+   xbt_dynar_t recvs = xbt_dynar_new(sizeof(int), nullptr);
+   for (i = 0; static_cast<int>(i) < count_requests; i++) {
     if(requests[i]){
       int *asrc = xbt_new(int, 1);
       int *adst = xbt_new(int, 1);
@@ -473,7 +482,7 @@ static void action_waitall(const char *const *action){
 
    smpi_mpi_waitall(count_requests, requests, status);
 
-   for (i = 0; (int)i < count_requests; i++) {
+   for (i = 0; static_cast<int>(i) < count_requests; i++) {
     int src_traced, dst_traced, is_wait_for_receive;
     xbt_dynar_get_cpy(srcs, i, &src_traced);
     xbt_dynar_get_cpy(dsts, i, &dst_traced);
@@ -487,8 +496,6 @@ static void action_waitall(const char *const *action){
    xbt_dynar_free(&srcs);
    xbt_dynar_free(&dsts);
    xbt_dynar_free(&recvs);
-
-   //TODO xbt_dynar_free_container(get_reqq_self());
    set_reqq_self(xbt_dynar_new(sizeof(MPI_Request),&xbt_free_ref));
   }
   log_timed_action (action, clock);
@@ -509,7 +516,7 @@ static void action_barrier(const char *const *action){
 
 static void action_bcast(const char *const *action)
 {
-  CHECK_ACTION_PARAMS(action, 1, 2);
+  CHECK_ACTION_PARAMS(action, 1, 2)
   double size = parse_double(action[2]);
   double clock = smpi_process_simulated_elapsed();
   int root=0;
@@ -530,7 +537,7 @@ static void action_bcast(const char *const *action)
   extra->type = TRACING_BCAST;
   extra->send_size = size;
   extra->root = root_traced;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__, extra);
   void *sendbuf = smpi_get_tmp_sendbuffer(size* smpi_datatype_size(MPI_CURRENT_TYPE));
 
@@ -542,7 +549,7 @@ static void action_bcast(const char *const *action)
 
 static void action_reduce(const char *const *action)
 {
-  CHECK_ACTION_PARAMS(action, 2, 2);
+  CHECK_ACTION_PARAMS(action, 2, 2)
   double comm_size = parse_double(action[2]);
   double comp_size = parse_double(action[3]);
   double clock = smpi_process_simulated_elapsed();
@@ -562,7 +569,7 @@ static void action_reduce(const char *const *action)
   extra->type = TRACING_REDUCE;
   extra->send_size = comm_size;
   extra->comp_size = comp_size;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->root = root_traced;
 
   TRACE_smpi_collective_in(rank, root_traced, __FUNCTION__,extra);
@@ -577,12 +584,14 @@ static void action_reduce(const char *const *action)
 }
 
 static void action_allReduce(const char *const *action) {
-  CHECK_ACTION_PARAMS(action, 2, 1);
+  CHECK_ACTION_PARAMS(action, 2, 1)
   double comm_size = parse_double(action[2]);
   double comp_size = parse_double(action[3]);
 
-  if(action[4]) MPI_CURRENT_TYPE=decode_datatype(action[4]);
-  else MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
+  if(action[4])
+    MPI_CURRENT_TYPE=decode_datatype(action[4]);
+  else
+    MPI_CURRENT_TYPE= MPI_DEFAULT_TYPE;
 
   double clock = smpi_process_simulated_elapsed();
   int rank = smpi_process_index();
@@ -590,7 +599,7 @@ static void action_allReduce(const char *const *action) {
   extra->type = TRACING_ALLREDUCE;
   extra->send_size = comm_size;
   extra->comp_size = comp_size;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
 
   void *recvbuf = smpi_get_tmp_sendbuffer(comm_size* smpi_datatype_size(MPI_CURRENT_TYPE));
@@ -603,7 +612,7 @@ static void action_allReduce(const char *const *action) {
 }
 
 static void action_allToAll(const char *const *action) {
-  CHECK_ACTION_PARAMS(action, 2, 2); //two mandatory (send and recv volumes)
+  CHECK_ACTION_PARAMS(action, 2, 2) //two mandatory (send and recv volumes)
                                      //two optional (corresponding datatypes)
   double clock = smpi_process_simulated_elapsed();
   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
@@ -628,8 +637,8 @@ static void action_allToAll(const char *const *action) {
   extra->type = TRACING_ALLTOALL;
   extra->send_size = send_size;
   extra->recv_size = recv_size;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
-  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
+  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
 
@@ -650,7 +659,7 @@ static void action_gather(const char *const *action) {
   4) 0 is the send datatype id, see decode_datatype()
   5) 0 is the recv datatype id, see decode_datatype()
   */
-  CHECK_ACTION_PARAMS(action, 2, 3);
+  CHECK_ACTION_PARAMS(action, 2, 3)
   double clock = smpi_process_simulated_elapsed();
   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
   int send_size = parse_double(action[2]);
@@ -664,7 +673,7 @@ static void action_gather(const char *const *action) {
     MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE;
   }
   void *send = smpi_get_tmp_sendbuffer(send_size* smpi_datatype_size(MPI_CURRENT_TYPE));
-  void *recv = NULL;
+  void *recv = nullptr;
   int root=0;
   if(action[4])
     root=atoi(action[4]);
@@ -678,8 +687,8 @@ static void action_gather(const char *const *action) {
   extra->send_size = send_size;
   extra->recv_size = recv_size;
   extra->root = root;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
-  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
+  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra);
 
@@ -703,7 +712,7 @@ static void action_gatherv(const char *const *action) {
 
   double clock = smpi_process_simulated_elapsed();
   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
-  CHECK_ACTION_PARAMS(action, comm_size+1, 2);
+  CHECK_ACTION_PARAMS(action, comm_size+1, 2)
   int send_size = parse_double(action[2]);
   int *disps = xbt_new0(int, comm_size);
   int *recvcounts = xbt_new0(int, comm_size);
@@ -718,7 +727,7 @@ static void action_gatherv(const char *const *action) {
     MPI_CURRENT_TYPE2=MPI_DEFAULT_TYPE;
   }
   void *send = smpi_get_tmp_sendbuffer(send_size* smpi_datatype_size(MPI_CURRENT_TYPE));
-  void *recv = NULL;
+  void *recv = nullptr;
   for(i=0;i<comm_size;i++) {
     recvcounts[i] = atoi(action[i+3]);
     recv_sum=recv_sum+recvcounts[i];
@@ -726,7 +735,7 @@ static void action_gatherv(const char *const *action) {
   }
 
   int root=atoi(action[3+comm_size]);
-  int rank = smpi_comm_rank(MPI_COMM_WORLD);;
+  int rank = smpi_comm_rank(MPI_COMM_WORLD);
 
   if(rank==root)
     recv = smpi_get_tmp_recvbuffer(recv_sum* smpi_datatype_size(MPI_CURRENT_TYPE2));
@@ -739,8 +748,8 @@ static void action_gatherv(const char *const *action) {
     extra->recvcounts[i] = recvcounts[i];
   extra->root = root;
   extra->num_processes = comm_size;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
-  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
+  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   TRACE_smpi_collective_in(smpi_process_index(), root, __FUNCTION__, extra);
 
@@ -764,7 +773,7 @@ static void action_reducescatter(const char *const *action) {
   We analyze a MPI_Reduce_scatter call to one MPI_Reduce and one MPI_Scatterv. */
   double clock = smpi_process_simulated_elapsed();
   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
-  CHECK_ACTION_PARAMS(action, comm_size+1, 1);
+  CHECK_ACTION_PARAMS(action, comm_size+1, 1)
   int comp_size = parse_double(action[2+comm_size]);
   int *recvcounts = xbt_new0(int, comm_size);  
   int *disps = xbt_new0(int, comm_size);  
@@ -788,7 +797,7 @@ static void action_reducescatter(const char *const *action) {
   extra->recvcounts= xbt_new(int, comm_size);
   for(i=0; i< comm_size; i++)//copy data to avoid bad free
     extra->recvcounts[i] = recvcounts[i];
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
   extra->comp_size = comp_size;
   extra->num_processes = comm_size;
 
@@ -816,7 +825,7 @@ static void action_allgather(const char *const *action) {
   3) No more values mean that the datatype for sent and receive buffer is the default one, see decode_datatype().  */
   double clock = smpi_process_simulated_elapsed();
 
-  CHECK_ACTION_PARAMS(action, 2, 2);
+  CHECK_ACTION_PARAMS(action, 2, 2)
   int sendcount=atoi(action[2]); 
   int recvcount=atoi(action[3]); 
 
@@ -837,8 +846,8 @@ static void action_allgather(const char *const *action) {
   extra->type = TRACING_ALLGATHER;
   extra->send_size = sendcount;
   extra->recv_size= recvcount;
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
-  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
+  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
   extra->num_processes = smpi_comm_size(MPI_COMM_WORLD);
 
   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
@@ -861,7 +870,7 @@ static void action_allgatherv(const char *const *action) {
   double clock = smpi_process_simulated_elapsed();
 
   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
-  CHECK_ACTION_PARAMS(action, comm_size+1, 2);
+  CHECK_ACTION_PARAMS(action, comm_size+1, 2)
   int i=0;
   int sendcount=atoi(action[2]);
   int *recvcounts = xbt_new0(int, comm_size);  
@@ -891,8 +900,8 @@ static void action_allgatherv(const char *const *action) {
   extra->recvcounts= xbt_new(int, comm_size);
   for(i=0; i< comm_size; i++)//copy data to avoid bad free
     extra->recvcounts[i] = recvcounts[i];
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
-  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
+  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
   extra->num_processes = comm_size;
 
   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
@@ -918,7 +927,7 @@ static void action_allToAllv(const char *const *action) {
   double clock = smpi_process_simulated_elapsed();
 
   int comm_size = smpi_comm_size(MPI_COMM_WORLD);
-  CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2);
+  CHECK_ACTION_PARAMS(action, 2*comm_size+2, 2)
   int send_buf_size=0,recv_buf_size=0,i=0;
   int *sendcounts = xbt_new0(int, comm_size);  
   int *recvcounts = xbt_new0(int, comm_size);  
@@ -959,8 +968,8 @@ static void action_allToAllv(const char *const *action) {
     extra->recv_size += recvcounts[i];
     extra->recvcounts[i] = recvcounts[i];
   }
-  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, NULL);
-  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, NULL);
+  extra->datatype1 = encode_datatype(MPI_CURRENT_TYPE, nullptr);
+  extra->datatype2 = encode_datatype(MPI_CURRENT_TYPE2, nullptr);
 
   TRACE_smpi_collective_in(rank, -1, __FUNCTION__,extra);
 
@@ -989,9 +998,9 @@ void smpi_replay_run(int *argc, char***argv){
   char *operation =bprintf("%s_init",__FUNCTION__);
   TRACE_smpi_collective_in(rank, -1, operation, extra);
   TRACE_smpi_collective_out(rank, -1, operation);
-  free(operation);
+  xbt_free(operation);
 
-  if (!_xbt_replay_action_init()) {
+  if (_xbt_replay_action_init()==0) {
     xbt_replay_action_register("init",       action_init);
     xbt_replay_action_register("finalize",   action_finalize);
     xbt_replay_action_register("comm_size",  action_comm_size);
@@ -1039,7 +1048,7 @@ void smpi_replay_run(int *argc, char***argv){
   double sim_time= 1.;
   /* One active process will stop. Decrease the counter*/
   XBT_DEBUG("There are %lu elements in reqq[*]", xbt_dynar_length(get_reqq_self()));
-  if (!xbt_dynar_is_empty(get_reqq_self())){
+  if (xbt_dynar_is_empty(get_reqq_self())==0){
     int count_requests=xbt_dynar_length(get_reqq_self());
     MPI_Request requests[count_requests];
     MPI_Status status[count_requests];
@@ -1052,22 +1061,16 @@ void smpi_replay_run(int *argc, char***argv){
     active_processes--;
   }
 
-  if(!active_processes){
+  if(active_processes==0){
     /* Last process alive speaking */
     /* end the simulated timer */
     sim_time = smpi_process_simulated_elapsed();
-  }
-
-  //TODO xbt_dynar_free_container(get_reqq_self()));
-
-  if(!active_processes){
     XBT_INFO("Simulation time %f", sim_time);
     _xbt_replay_action_exit();
     xbt_free(sendbuffer);
     xbt_free(recvbuffer);
-    //xbt_free(reqq);
     xbt_dict_free(&reqq); //not need, data have been freed ???
-    reqq = NULL;
+    reqq = nullptr;
   }
 
   instr_extra_data extra_fin = xbt_new0(s_instr_extra_data_t,1);
@@ -1080,5 +1083,5 @@ void smpi_replay_run(int *argc, char***argv){
   TRACE_smpi_collective_out(rank, -1, operation);
   TRACE_smpi_finalize(smpi_process_index());
   smpi_process_destroy();
-  free(operation);
+  xbt_free(operation);
 }