Logo AND Algorithmique Numérique Distribuée
Public GIT Repository
projects / simgrid.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
cut some more includes
[simgrid.git] / src / mc / compare.cpp
diff --git a/src/mc/compare.cpp b/src/mc/compare.cpp
index e672746..bdc2339 100644 (file)
--- a/src/mc/compare.cpp
+++ b/src/mc/compare.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2008-2016. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2008-2017. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -13,8 +13,8 @@
 #include <utility>
 #include <unordered_set>
 
 #include <utility>
 #include <unordered_set>
 
-#include <xbt/sysdep.h>
-#include <xbt/dynar.h>
+#include "xbt/dynar.h"
+#include "xbt/sysdep.h"
 #include <xbt/mmalloc.h>
 
 #include <mc/mc.h>
 #include <xbt/mmalloc.h>
 
 #include <mc/mc.h>
@@ -23,14 +23,12 @@
 #include "src/internal_config.h"
 
 #include "src/xbt/mmalloc/mmprivate.h"
 #include "src/internal_config.h"
 
 #include "src/xbt/mmalloc/mmprivate.h"
-#include "src/xbt/ex_interface.h"
 
 #if HAVE_SMPI
 #include "src/smpi/private.h"
 #endif
 
 #include "src/mc/mc_forward.hpp"
 
 #if HAVE_SMPI
 #include "src/smpi/private.h"
 #endif
 
 #include "src/mc/mc_forward.hpp"
-#include "src/mc/mc_safety.h"
 #include "src/mc/mc_private.h"
 #include "src/mc/mc_smx.h"
 #include "src/mc/mc_dwarf.hpp"
 #include "src/mc/mc_private.h"
 #include "src/mc/mc_smx.h"
 #include "src/mc/mc_dwarf.hpp"
@@ -42,8 +40,7 @@
 #include "src/mc/mc_dwarf.hpp"
 #include "src/mc/Type.hpp"
 
 #include "src/mc/mc_dwarf.hpp"
 #include "src/mc/Type.hpp"
 
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_compare, xbt,
-                                "Logging specific to mc_compare in mc");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_compare, xbt, "Logging specific to mc_compare in mc");
 
 namespace simgrid {
 namespace mc {
 
 namespace simgrid {
 namespace mc {
@@ -116,8 +113,7 @@ struct ProcessComparisonState {
   std::vector<simgrid::mc::Type*> types;
   std::size_t heapsize = 0;
 
   std::vector<simgrid::mc::Type*> types;
   std::size_t heapsize = 0;
 
-  void initHeapInformation(xbt_mheap_t heap,
-                          std::vector<simgrid::mc::IgnoredHeapRegion>* i);
+  void initHeapInformation(xbt_mheap_t heap, std::vector<simgrid::mc::IgnoredHeapRegion>* i);
 };
 
 namespace {
 };
 
 namespace {
@@ -194,7 +190,6 @@ struct StateComparator {
 
   /** Check whether two blocks are known to be matching
    *
 
   /** Check whether two blocks are known to be matching
    *
-   *  @param state  State used
    *  @param b1     Block of state 1
    *  @param b2     Block of state 2
    *  @return       if the blocks are known to be matching
    *  @param b1     Block of state 1
    *  @param b2     Block of state 2
    *  @return       if the blocks are known to be matching
@@ -207,7 +202,6 @@ struct StateComparator {
 
   /** Check whether two fragments are known to be matching
    *
 
   /** Check whether two fragments are known to be matching
    *
-   *  @param state  State used
    *  @param b1     Block of state 1
    *  @param f1     Fragment of state 1
    *  @param b2     Block of state 2
    *  @param b1     Block of state 1
    *  @param f1     Fragment of state 1
    *  @param b2     Block of state 2
@@ -275,15 +269,11 @@ void StateComparator::match_equals(HeapLocationPairs* list)
 {
   for (auto const& pair : *list) {
     if (pair[0].fragment != -1) {
 {
   for (auto const& pair : *list) {
     if (pair[0].fragment != -1) {
-      this->equals_to1_(pair[0].block, pair[0].fragment) =
-          simgrid::mc::HeapArea(pair[1].block, pair[1].fragment);
-      this->equals_to2_(pair[1].block, pair[1].fragment) =
-          simgrid::mc::HeapArea(pair[0].block, pair[0].fragment);
+      this->equals_to1_(pair[0].block, pair[0].fragment) = simgrid::mc::HeapArea(pair[1].block, pair[1].fragment);
+      this->equals_to2_(pair[1].block, pair[1].fragment) = simgrid::mc::HeapArea(pair[0].block, pair[0].fragment);
     } else {
     } else {
-      this->equals_to1_(pair[0].block, 0) =
-          simgrid::mc::HeapArea(pair[1].block, pair[1].fragment);
-      this->equals_to2_(pair[1].block, 0) =
-          simgrid::mc::HeapArea(pair[0].block, pair[0].fragment);
+      this->equals_to1_(pair[0].block, 0) = simgrid::mc::HeapArea(pair[1].block, pair[1].fragment);
+      this->equals_to2_(pair[1].block, 0) = simgrid::mc::HeapArea(pair[0].block, pair[0].fragment);
     }
   }
 }
     }
   }
 }
@@ -291,8 +281,8 @@ void StateComparator::match_equals(HeapLocationPairs* list)
 void ProcessComparisonState::initHeapInformation(xbt_mheap_t heap,
                         std::vector<simgrid::mc::IgnoredHeapRegion>* i)
 {
 void ProcessComparisonState::initHeapInformation(xbt_mheap_t heap,
                         std::vector<simgrid::mc::IgnoredHeapRegion>* i)
 {
-  auto heaplimit = ((struct mdesc *) heap)->heaplimit;
-  this->heapsize = ((struct mdesc *) heap)->heapsize;
+  auto heaplimit  = heap->heaplimit;
+  this->heapsize  = heap->heapsize;
   this->to_ignore = i;
   this->equals_to.assign(heaplimit * MAX_FRAGMENT_PER_BLOCK, HeapArea());
   this->types.assign(heaplimit * MAX_FRAGMENT_PER_BLOCK, nullptr);
   this->to_ignore = i;
   this->equals_to.assign(heaplimit * MAX_FRAGMENT_PER_BLOCK, HeapArea());
   this->types.assign(heaplimit * MAX_FRAGMENT_PER_BLOCK, nullptr);
@@ -302,13 +292,9 @@ int StateComparator::initHeapInformation(xbt_mheap_t heap1, xbt_mheap_t heap2,
                           std::vector<simgrid::mc::IgnoredHeapRegion>* i1,
                           std::vector<simgrid::mc::IgnoredHeapRegion>* i2)
 {
                           std::vector<simgrid::mc::IgnoredHeapRegion>* i1,
                           std::vector<simgrid::mc::IgnoredHeapRegion>* i2)
 {
-  if ((((struct mdesc *) heap1)->heaplimit !=
-       ((struct mdesc *) heap2)->heaplimit)
-      ||
-      ((((struct mdesc *) heap1)->heapsize !=
-        ((struct mdesc *) heap2)->heapsize)))
+  if ((heap1->heaplimit != heap2->heaplimit) || (heap1->heapsize != heap2->heapsize))
     return -1;
     return -1;
-  this->heaplimit = ((struct mdesc *) heap1)->heaplimit;
+  this->heaplimit     = heap1->heaplimit;
   this->std_heap_copy = *mc_model_checker->process().get_heap();
   this->processStates[0].initHeapInformation(heap1, i1);
   this->processStates[1].initHeapInformation(heap2, i2);
   this->std_heap_copy = *mc_model_checker->process().get_heap();
   this->processStates[0].initHeapInformation(heap1, i1);
   this->processStates[1].initHeapInformation(heap2, i2);
@@ -332,17 +318,25 @@ int mmalloc_compare_heap(
   simgrid::mc::Process* process = &mc_model_checker->process();
 
   /* Start comparison */
   simgrid::mc::Process* process = &mc_model_checker->process();
 
   /* Start comparison */
-  size_t i1, i2, j1, j2, k;
-  void *addr_block1, *addr_block2, *addr_frag1, *addr_frag2;
-  int nb_diff1 = 0, nb_diff2 = 0;
-
-  int equal, res_compare = 0;
+  size_t i1;
+  size_t i2;
+  size_t j1;
+  size_t j2;
+  size_t k;
+  void* addr_block1;
+  void* addr_block2;
+  void* addr_frag1;
+  void* addr_frag2;
+  int nb_diff1 = 0;
+  int nb_diff2 = 0;
+  int equal;
+  int res_compare = 0;
 
   /* Check busy blocks */
 
   /* Check busy blocks */
-
   i1 = 1;
 
   i1 = 1;
 
-  malloc_info heapinfo_temp1, heapinfo_temp2;
+  malloc_info heapinfo_temp1;
+  malloc_info heapinfo_temp2;
   malloc_info heapinfo_temp2b;
 
   mc_mem_region_t heap_region1 = MC_get_heap_region(snapshot1);
   malloc_info heapinfo_temp2b;
 
   mc_mem_region_t heap_region1 = MC_get_heap_region(snapshot1);
@@ -372,9 +366,7 @@ int mmalloc_compare_heap(
       abort();
     }
 
       abort();
     }
 
-    addr_block1 =
-        ((void *) (((ADDR2UINT(i1)) - 1) * BLOCKSIZE +
-                   (char *) state.std_heap_copy.heapbase));
+    addr_block1 = ((void*)(((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase));
 
     if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED) {       /* Large block */
 
 
     if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED) {       /* Large block */
 
@@ -392,18 +384,16 @@ int mmalloc_compare_heap(
         continue;
       }
 
         continue;
       }
 
-      i2 = 1;
-      equal = 0;
+      i2          = 1;
+      equal       = 0;
       res_compare = 0;
 
       /* Try first to associate to same block in the other heap */
       if (heapinfo2->type == heapinfo1->type
         && state.equals_to2_(i1, 0).valid == 0) {
       res_compare = 0;
 
       /* Try first to associate to same block in the other heap */
       if (heapinfo2->type == heapinfo1->type
         && state.equals_to2_(i1, 0).valid == 0) {
-        addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE +
-                       (char *) state.std_heap_copy.heapbase;
-        res_compare = compare_heap_area(state, simgrid::mc::ProcessIndexMissing,
-            addr_block1, addr_block2, snapshot1, snapshot2,
-            nullptr, nullptr, 0);
+        addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
+        res_compare = compare_heap_area(state, simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1,
+                                        snapshot2, nullptr, nullptr, 0);
         if (res_compare != 1) {
           for (k = 1; k < heapinfo2->busy_block.size; k++)
             state.equals_to2_(i1 + k, 0) = HeapArea(i1, -1);
         if (res_compare != 1) {
           for (k = 1; k < heapinfo2->busy_block.size; k++)
             state.equals_to2_(i1 + k, 0) = HeapArea(i1, -1);
@@ -414,10 +404,9 @@ int mmalloc_compare_heap(
         }
       }
 
         }
       }
 
-      while (i2 < state.heaplimit && !equal) {
+      while (i2 < state.heaplimit && not equal) {
 
 
-        addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE +
-                       (char *) state.std_heap_copy.heapbase;
+        addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
 
         if (i2 == i1) {
           i2++;
 
         if (i2 == i1) {
           i2++;
@@ -450,12 +439,10 @@ int mmalloc_compare_heap(
         }
 
         i2++;
         }
 
         i2++;
-
       }
 
       }
 
-      if (!equal) {
-        XBT_DEBUG("Block %zu not found (size_used = %zu, addr = %p)", i1,
-                  heapinfo1->busy_block.busy_size, addr_block1);
+      if (not equal) {
+        XBT_DEBUG("Block %zu not found (size_used = %zu, addr = %p)", i1, heapinfo1->busy_block.busy_size, addr_block1);
         i1 = state.heaplimit + 1;
         nb_diff1++;
         //i1++;
         i1 = state.heaplimit + 1;
         nb_diff1++;
         //i1++;
@@ -471,30 +458,25 @@ int mmalloc_compare_heap(
         if (state.equals_to1_(i1, j1).valid)
           continue;
 
         if (state.equals_to1_(i1, j1).valid)
           continue;
 
-        addr_frag1 =
-            (void *) ((char *) addr_block1 + (j1 << heapinfo1->type));
+        addr_frag1 = (void*)((char*)addr_block1 + (j1 << heapinfo1->type));
 
         i2 = 1;
         equal = 0;
 
         /* Try first to associate to same fragment in the other heap */
 
         i2 = 1;
         equal = 0;
 
         /* Try first to associate to same fragment in the other heap */
-        if (heapinfo2->type == heapinfo1->type
-            && !state.equals_to2_(i1, j1).valid) {
+        if (heapinfo2->type == heapinfo1->type && not state.equals_to2_(i1, j1).valid) {
           addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE +
                          (char *) state.std_heap_copy.heapbase;
           addr_frag2 =
               (void *) ((char *) addr_block2 +
                         (j1 << heapinfo2->type));
           addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE +
                          (char *) state.std_heap_copy.heapbase;
           addr_frag2 =
               (void *) ((char *) addr_block2 +
                         (j1 << heapinfo2->type));
-          res_compare = compare_heap_area(state, simgrid::mc::ProcessIndexMissing,
-              addr_frag1, addr_frag2, snapshot1, snapshot2,
-              nullptr, nullptr, 0);
+          res_compare = compare_heap_area(state, simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot1,
+                                          snapshot2, nullptr, nullptr, 0);
           if (res_compare != 1)
             equal = 1;
         }
 
           if (res_compare != 1)
             equal = 1;
         }
 
-
-
-        while (i2 < state.heaplimit && !equal) {
+        while (i2 < state.heaplimit && not equal) {
 
           const malloc_info* heapinfo2b = (const malloc_info*) MC_region_read(
             heap_region2, &heapinfo_temp2b, &heapinfos2[i2],
 
           const malloc_info* heapinfo2b = (const malloc_info*) MC_region_read(
             heap_region2, &heapinfo_temp2b, &heapinfos2[i2],
@@ -512,7 +494,7 @@ int mmalloc_compare_heap(
           }
 
           if (heapinfo2b->type < 0) {
           }
 
           if (heapinfo2b->type < 0) {
-            fprintf(stderr, "Unkown mmalloc block type.\n");
+            fprintf(stderr, "Unknown mmalloc block type.\n");
             abort();
           }
 
             abort();
           }
 
@@ -525,84 +507,65 @@ int mmalloc_compare_heap(
             if (state.equals_to2_(i2, j2).valid)
               continue;
 
             if (state.equals_to2_(i2, j2).valid)
               continue;
 
-            addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE +
-                           (char *) state.std_heap_copy.heapbase;
-            addr_frag2 =
-                (void *) ((char *) addr_block2 +
-                          (j2 << heapinfo2b->type));
+            addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
+            addr_frag2  = (void*)((char*)addr_block2 + (j2 << heapinfo2b->type));
 
 
-            res_compare = compare_heap_area(
-                state, simgrid::mc::ProcessIndexMissing,
-                addr_frag1, addr_frag2, snapshot2, snapshot2,
-                nullptr, nullptr, 0);
+            res_compare = compare_heap_area(state, simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot2,
+                                            snapshot2, nullptr, nullptr, 0);
             if (res_compare != 1) {
               equal = 1;
               break;
             }
             if (res_compare != 1) {
               equal = 1;
               break;
             }
-
           }
 
           i2++;
           }
 
           i2++;
-
         }
 
         }
 
-        if (!equal) {
-          XBT_DEBUG
-              ("Block %zu, fragment %zu not found (size_used = %zd, address = %p)\n",
-               i1, j1, heapinfo1->busy_frag.frag_size[j1],
-               addr_frag1);
+        if (not equal) {
+          XBT_DEBUG("Block %zu, fragment %zu not found (size_used = %zd, address = %p)\n", i1, j1,
+                    heapinfo1->busy_frag.frag_size[j1], addr_frag1);
           i2 = state.heaplimit + 1;
           i1 = state.heaplimit + 1;
           nb_diff1++;
           break;
         }
           i2 = state.heaplimit + 1;
           i1 = state.heaplimit + 1;
           nb_diff1++;
           break;
         }
-
       }
 
       i1++;
       }
 
       i1++;
-
     }
     }
-
   }
 
   /* All blocks/fragments are equal to another block/fragment ? */
   }
 
   /* All blocks/fragments are equal to another block/fragment ? */
-  size_t i = 1, j = 0;
+  size_t i = 1;
+  size_t j = 0;
 
   for(i = 1; i < state.heaplimit; i++) {
     const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(
       heap_region1, &heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info));
 
 
   for(i = 1; i < state.heaplimit; i++) {
     const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(
       heap_region1, &heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info));
 
-    if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED
-        && i1 == state.heaplimit
-        && heapinfo1->busy_block.busy_size > 0
-        && !state.equals_to1_(i, 0).valid) {
-      XBT_DEBUG("Block %zu not found (size used = %zu)", i,
-                heapinfo1->busy_block.busy_size);
+    if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED && i1 == state.heaplimit && heapinfo1->busy_block.busy_size > 0 &&
+        not state.equals_to1_(i, 0).valid) {
+      XBT_DEBUG("Block %zu not found (size used = %zu)", i, heapinfo1->busy_block.busy_size);
       nb_diff1++;
     }
 
     if (heapinfo1->type <= 0)
       continue;
     for (j = 0; j < (size_t) (BLOCKSIZE >> heapinfo1->type); j++)
       nb_diff1++;
     }
 
     if (heapinfo1->type <= 0)
       continue;
     for (j = 0; j < (size_t) (BLOCKSIZE >> heapinfo1->type); j++)
-      if (i1 == state.heaplimit
-          && heapinfo1->busy_frag.frag_size[j] > 0
-          && !state.equals_to1_(i, j).valid) {
-        XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)",
-          i, j, heapinfo1->busy_frag.frag_size[j]);
+      if (i1 == state.heaplimit && heapinfo1->busy_frag.frag_size[j] > 0 && not state.equals_to1_(i, j).valid) {
+        XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)", i, j, heapinfo1->busy_frag.frag_size[j]);
         nb_diff1++;
       }
   }
 
   if (i1 == state.heaplimit)
         nb_diff1++;
       }
   }
 
   if (i1 == state.heaplimit)
-    XBT_DEBUG("Number of blocks/fragments not found in heap1 : %d", nb_diff1);
+    XBT_DEBUG("Number of blocks/fragments not found in heap1: %d", nb_diff1);
 
   for (i=1; i < state.heaplimit; i++) {
     const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(
       heap_region2, &heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info));
 
   for (i=1; i < state.heaplimit; i++) {
     const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(
       heap_region2, &heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info));
-    if (heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED
-        && i1 == state.heaplimit
-        && heapinfo2->busy_block.busy_size > 0
-        && !state.equals_to2_(i, 0).valid) {
+    if (heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED && i1 == state.heaplimit && heapinfo2->busy_block.busy_size > 0 &&
+        not state.equals_to2_(i, 0).valid) {
       XBT_DEBUG("Block %zu not found (size used = %zu)", i,
                 heapinfo2->busy_block.busy_size);
       nb_diff2++;
       XBT_DEBUG("Block %zu not found (size used = %zu)", i,
                 heapinfo2->busy_block.busy_size);
       nb_diff2++;
@@ -612,9 +575,7 @@ int mmalloc_compare_heap(
       continue;
 
     for (j = 0; j < (size_t) (BLOCKSIZE >> heapinfo2->type); j++)
       continue;
 
     for (j = 0; j < (size_t) (BLOCKSIZE >> heapinfo2->type); j++)
-      if (i1 == state.heaplimit
-          && heapinfo2->busy_frag.frag_size[j] > 0
-          && !state.equals_to2_(i, j).valid) {
+      if (i1 == state.heaplimit && heapinfo2->busy_frag.frag_size[j] > 0 && not state.equals_to2_(i, j).valid) {
         XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)",
           i, j, heapinfo2->busy_frag.frag_size[j]);
         nb_diff2++;
         XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)",
           i, j, heapinfo2->busy_frag.frag_size[j]);
         nb_diff2++;
@@ -623,7 +584,7 @@ int mmalloc_compare_heap(
   }
 
   if (i1 == state.heaplimit)
   }
 
   if (i1 == state.heaplimit)
-    XBT_DEBUG("Number of blocks/fragments not found in heap2 : %d", nb_diff2);
+    XBT_DEBUG("Number of blocks/fragments not found in heap2: %d", nb_diff2);
 
   return nb_diff1 > 0 || nb_diff2 > 0;
 }
 
   return nb_diff1 > 0 || nb_diff2 > 0;
 }
@@ -717,7 +678,7 @@ static int compare_heap_area_without_type(
  * @param snapshot1      Snapshot of state 1
  * @param snapshot2      Snapshot of state 2
  * @param previous
  * @param snapshot1      Snapshot of state 1
  * @param snapshot2      Snapshot of state 2
  * @param previous
- * @param type_id
+ * @param type
  * @param area_size      either a byte_size or an elements_count (?)
  * @param check_ignore
  * @param pointer_level
  * @param area_size      either a byte_size or an elements_count (?)
  * @param check_ignore
  * @param pointer_level
@@ -755,9 +716,12 @@ top:
       return 0;
   }
 
       return 0;
   }
 
-  simgrid::mc::Type *subtype, *subsubtype;
-  int res, elm_size;
-  const void *addr_pointed1, *addr_pointed2;
+  simgrid::mc::Type* subtype;
+  simgrid::mc::Type* subsubtype;
+  int res;
+  int elm_size;
+  const void* addr_pointed1;
+  const void* addr_pointed2;
 
   mc_mem_region_t heap_region1 = MC_get_heap_region(snapshot1);
   mc_mem_region_t heap_region2 = MC_get_heap_region(snapshot2);
 
   mc_mem_region_t heap_region1 = MC_get_heap_region(snapshot1);
   mc_mem_region_t heap_region2 = MC_get_heap_region(snapshot2);
@@ -767,7 +731,7 @@ top:
     return 1;
 
   case DW_TAG_base_type:
     return 1;
 
   case DW_TAG_base_type:
-    if (!type->name.empty() && type->name == "char") {        /* String, hence random (arbitrary ?) size */
+    if (not type->name.empty() && type->name == "char") { /* String, hence random (arbitrary ?) size */
       if (real_area1 == real_area2)
         return -1;
       else
       if (real_area1 == real_area2)
         return -1;
       else
@@ -921,7 +885,6 @@ top:
     return compare_heap_area_without_type(state, process_index, real_area1, real_area2,
                                           snapshot1, snapshot2, previous,
                                           type->byte_size, check_ignore);
     return compare_heap_area_without_type(state, process_index, real_area1, real_area2,
                                           snapshot1, snapshot2, previous,
                                           type->byte_size, check_ignore);
-    return 0;
 
   default:
     return 0;
 
   default:
     return 0;
@@ -936,7 +899,7 @@ top:
  *
  * TODO, handle subfields ((*p).bar.foo, (*p)[5].bar…)
  *
  *
  * TODO, handle subfields ((*p).bar.foo, (*p)[5].bar…)
  *
- * @param  type_id            DWARF type ID of the root address
+ * @param  type               DWARF type ID of the root address
  * @param  area_size
  * @return                    DWARF type ID for given offset
  */
  * @param  area_size
  * @return                    DWARF type ID for given offset
  */
@@ -968,16 +931,15 @@ static simgrid::mc::Type* get_offset_type(void *real_base_address, simgrid::mc::
         if (member.offset() == offset)
           return member.type;
       } else {
         if (member.offset() == offset)
           return member.type;
       } else {
-        void *real_member = simgrid::dwarf::resolve_member(
-          real_base_address, type, &member, snapshot, process_index);
-        if ((char*) real_member - (char *) real_base_address == offset)
+        void* real_member = simgrid::dwarf::resolve_member(real_base_address, type, &member, snapshot, process_index);
+        if ((char*)real_member - (char*)real_base_address == offset)
           return member.type;
       }
     }
     return nullptr;
 
   default:
           return member.type;
       }
     }
     return nullptr;
 
   default:
-    /* FIXME : other cases ? */
+    /* FIXME: other cases ? */
     return nullptr;
 
   }
     return nullptr;
 
   }
@@ -1005,25 +967,33 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
   simgrid::mc::Process* process = &mc_model_checker->process();
 
   int res_compare;
   simgrid::mc::Process* process = &mc_model_checker->process();
 
   int res_compare;
-  ssize_t block1, frag1, block2, frag2;
+  ssize_t block1;
+  ssize_t frag1;
+  ssize_t block2;
+  ssize_t frag2;
   ssize_t size;
   int check_ignore = 0;
 
   ssize_t size;
   int check_ignore = 0;
 
-  void *real_addr_block1, *real_addr_block2, *real_addr_frag1, *real_addr_frag2;
+  void* real_addr_block1;
+  void* real_addr_block2;
+  void* real_addr_frag1;
+  void* real_addr_frag2;
   int type_size = -1;
   int type_size = -1;
-  int offset1 = 0, offset2 = 0;
-  int new_size1 = -1, new_size2 = -1;
-  simgrid::mc::Type *new_type1 = nullptr, *new_type2 = nullptr;
+  int offset1   = 0;
+  int offset2   = 0;
+  int new_size1 = -1;
+  int new_size2 = -1;
+
+  simgrid::mc::Type* new_type1 = nullptr;
+  simgrid::mc::Type* new_type2 = nullptr;
 
   bool match_pairs = false;
 
   // This is the address of std_heap->heapinfo in the application process:
   void* heapinfo_address = &((xbt_mheap_t) process->heap_address)->heapinfo;
 
 
   bool match_pairs = false;
 
   // This is the address of std_heap->heapinfo in the application process:
   void* heapinfo_address = &((xbt_mheap_t) process->heap_address)->heapinfo;
 
-  const malloc_info* heapinfos1 = snapshot1->read(
-    remote((const malloc_info**)heapinfo_address), process_index);
-  const malloc_info* heapinfos2 = snapshot2->read(
-    remote((const malloc_info**)heapinfo_address), process_index);
+  const malloc_info* heapinfos1 = snapshot1->read(remote((const malloc_info**)heapinfo_address), process_index);
+  const malloc_info* heapinfos2 = snapshot2->read(remote((const malloc_info**)heapinfo_address), process_index);
 
   malloc_info heapinfo_temp1, heapinfo_temp2;
 
 
   malloc_info heapinfo_temp1, heapinfo_temp2;
 
@@ -1034,38 +1004,29 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
   }
 
   // Get block number:
   }
 
   // Get block number:
-  block1 =
-      ((char *) area1 -
-       (char *) state.std_heap_copy.heapbase) / BLOCKSIZE + 1;
-  block2 =
-      ((char *) area2 -
-       (char *) state.std_heap_copy.heapbase) / BLOCKSIZE + 1;
+  block1 = ((char*)area1 - (char*)state.std_heap_copy.heapbase) / BLOCKSIZE + 1;
+  block2 = ((char*)area2 - (char*)state.std_heap_copy.heapbase) / BLOCKSIZE + 1;
 
   // If either block is a stack block:
   if (is_block_stack((int) block1) && is_block_stack((int) block2)) {
 
   // If either block is a stack block:
   if (is_block_stack((int) block1) && is_block_stack((int) block2)) {
-    previous->insert(simgrid::mc::makeHeapLocationPair(
-      block1, -1, block2, -1));
+    previous->insert(simgrid::mc::makeHeapLocationPair(block1, -1, block2, -1));
     if (match_pairs)
       state.match_equals(previous);
     return 0;
   }
 
   // If either block is not in the expected area of memory:
     if (match_pairs)
       state.match_equals(previous);
     return 0;
   }
 
   // If either block is not in the expected area of memory:
-  if (((char *) area1 < (char *) state.std_heap_copy.heapbase)
-      || (block1 > (ssize_t) state.processStates[0].heapsize) || (block1 < 1)
-      || ((char *) area2 < (char *) state.std_heap_copy.heapbase)
-      || (block2 > (ssize_t) state.processStates[1].heapsize) || (block2 < 1)) {
+  if (((char*)area1 < (char*)state.std_heap_copy.heapbase) || (block1 > (ssize_t)state.processStates[0].heapsize) ||
+      (block1 < 1) || ((char*)area2 < (char*)state.std_heap_copy.heapbase) ||
+      (block2 > (ssize_t)state.processStates[1].heapsize) || (block2 < 1)) {
     return 1;
   }
 
   // Process address of the block:
     return 1;
   }
 
   // Process address of the block:
-  real_addr_block1 = (ADDR2UINT(block1) - 1) * BLOCKSIZE +
-                 (char *) state.std_heap_copy.heapbase;
-  real_addr_block2 = (ADDR2UINT(block2) - 1) * BLOCKSIZE +
-                 (char *) state.std_heap_copy.heapbase;
+  real_addr_block1 = (ADDR2UINT(block1) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
+  real_addr_block2 = (ADDR2UINT(block2) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
 
   if (type) {
 
   if (type) {
-
     if (type->full_type)
       type = type->full_type;
 
     if (type->full_type)
       type = type->full_type;
 
@@ -1074,9 +1035,8 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
       type = type->subtype;
 
     // Find type_size:
       type = type->subtype;
 
     // Find type_size:
-    if (type->type == DW_TAG_pointer_type
-        || (type->type == DW_TAG_base_type && !type->name.empty()
-            && type->name == "char"))
+    if (type->type == DW_TAG_pointer_type ||
+        (type->type == DW_TAG_base_type && not type->name.empty() && type->name == "char"))
       type_size = -1;
     else
       type_size = type->byte_size;
       type_size = -1;
     else
       type_size = type->byte_size;
@@ -1099,18 +1059,15 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
     return 0;
   }
 
     return 0;
   }
 
-  if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED
-    && heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED) {
+  if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED && heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED) {
     /* Complete block */
 
     // TODO, lookup variable type from block type as done for fragmented blocks
 
     /* Complete block */
 
     // TODO, lookup variable type from block type as done for fragmented blocks
 
-    offset1 = (char *) area1 - (char *) real_addr_block1;
-    offset2 = (char *) area2 - (char *) real_addr_block2;
+    offset1 = (char*)area1 - (char*)real_addr_block1;
+    offset2 = (char*)area2 - (char*)real_addr_block2;
 
 
-    if (state.equals_to1_(block1, 0).valid
-        && state.equals_to2_(block2, 0).valid
-        && state.blocksEqual(block1, block2)) {
+    if (state.equals_to1_(block1, 0).valid && state.equals_to2_(block2, 0).valid && state.blocksEqual(block1, block2)) {
       if (match_pairs)
         state.match_equals(previous);
       return 0;
       if (match_pairs)
         state.match_equals(previous);
       return 0;
@@ -1131,8 +1088,7 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
     if (heapinfo1->busy_block.busy_size != heapinfo2->busy_block.busy_size)
       return 1;
 
     if (heapinfo1->busy_block.busy_size != heapinfo2->busy_block.busy_size)
       return 1;
 
-    if (!previous->insert(simgrid::mc::makeHeapLocationPair(
-        block1, -1, block2, -1)).second) {
+    if (not previous->insert(simgrid::mc::makeHeapLocationPair(block1, -1, block2, -1)).second) {
       if (match_pairs)
         state.match_equals(previous);
       return 0;
       if (match_pairs)
         state.match_equals(previous);
       return 0;
@@ -1163,23 +1119,16 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
   } else if ((heapinfo1->type > 0) && (heapinfo2->type > 0)) {      /* Fragmented block */
 
     // Fragment number:
   } else if ((heapinfo1->type > 0) && (heapinfo2->type > 0)) {      /* Fragmented block */
 
     // Fragment number:
-    frag1 =
-        ((uintptr_t) (ADDR2UINT(area1) % (BLOCKSIZE))) >> heapinfo1->type;
-    frag2 =
-        ((uintptr_t) (ADDR2UINT(area2) % (BLOCKSIZE))) >> heapinfo2->type;
+    frag1 = ((uintptr_t)(ADDR2UINT(area1) % (BLOCKSIZE))) >> heapinfo1->type;
+    frag2 = ((uintptr_t)(ADDR2UINT(area2) % (BLOCKSIZE))) >> heapinfo2->type;
 
     // Process address of the fragment:
 
     // Process address of the fragment:
-    real_addr_frag1 =
-        (void *) ((char *) real_addr_block1 +
-                  (frag1 << heapinfo1->type));
-    real_addr_frag2 =
-        (void *) ((char *) real_addr_block2 +
-                  (frag2 << heapinfo2->type));
+    real_addr_frag1 = (void*)((char*)real_addr_block1 + (frag1 << heapinfo1->type));
+    real_addr_frag2 = (void*)((char*)real_addr_block2 + (frag2 << heapinfo2->type));
 
     // Check the size of the fragments against the size of the type:
     if (type_size != -1) {
 
     // Check the size of the fragments against the size of the type:
     if (type_size != -1) {
-      if (heapinfo1->busy_frag.frag_size[frag1] == -1
-          || heapinfo2->busy_frag.frag_size[frag2] == -1) {
+      if (heapinfo1->busy_frag.frag_size[frag1] == -1 || heapinfo2->busy_frag.frag_size[frag2] == -1) {
         if (match_pairs)
           state.match_equals(previous);
         return -1;
         if (match_pairs)
           state.match_equals(previous);
         return -1;
@@ -1194,8 +1143,7 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
     }
 
     // Check if the blocks are already matched together:
     }
 
     // Check if the blocks are already matched together:
-    if (state.equals_to1_(block1, frag1).valid
-        && state.equals_to2_(block2, frag2).valid) {
+    if (state.equals_to1_(block1, frag1).valid && state.equals_to2_(block2, frag2).valid) {
       if (offset1==offset2 && state.fragmentsEqual(block1, frag1, block2, frag2)) {
         if (match_pairs)
           state.match_equals(previous);
       if (offset1==offset2 && state.fragmentsEqual(block1, frag1, block2, frag2)) {
         if (match_pairs)
           state.match_equals(previous);
@@ -1203,8 +1151,7 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
       }
     }
     // Compare the size of both fragments:
       }
     }
     // Compare the size of both fragments:
-    if (heapinfo1->busy_frag.frag_size[frag1] !=
-        heapinfo2->busy_frag.frag_size[frag2]) {
+    if (heapinfo1->busy_frag.frag_size[frag1] != heapinfo2->busy_frag.frag_size[frag2]) {
       if (type_size == -1) {
         if (match_pairs)
           state.match_equals(previous);
       if (type_size == -1) {
         if (match_pairs)
           state.match_equals(previous);
@@ -1229,34 +1176,26 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
       new_type2 = type;
     }
     // Type inference from the block type.
       new_type2 = type;
     }
     // Type inference from the block type.
-    else if (state.types1_(block1, frag1) != nullptr
-             || state.types2_(block2, frag2) != nullptr) {
+    else if (state.types1_(block1, frag1) != nullptr || state.types2_(block2, frag2) != nullptr) {
 
 
-      offset1 = (char *) area1 - (char *) real_addr_frag1;
-      offset2 = (char *) area2 - (char *) real_addr_frag2;
+      offset1 = (char*)area1 - (char*)real_addr_frag1;
+      offset2 = (char*)area2 - (char*)real_addr_frag2;
 
 
-      if (state.types1_(block1, frag1) != nullptr
-          && state.types2_(block2, frag2) != nullptr) {
+      if (state.types1_(block1, frag1) != nullptr && state.types2_(block2, frag2) != nullptr) {
         new_type1 =
         new_type1 =
-            get_offset_type(real_addr_frag1, state.types1_(block1, frag1),
-                            offset1, size, snapshot1, process_index);
+            get_offset_type(real_addr_frag1, state.types1_(block1, frag1), offset1, size, snapshot1, process_index);
         new_type2 =
         new_type2 =
-            get_offset_type(real_addr_frag2, state.types2_(block2, frag2),
-                            offset1, size, snapshot2, process_index);
+            get_offset_type(real_addr_frag2, state.types2_(block2, frag2), offset1, size, snapshot2, process_index);
       } else if (state.types1_(block1, frag1) != nullptr) {
         new_type1 =
       } else if (state.types1_(block1, frag1) != nullptr) {
         new_type1 =
-            get_offset_type(real_addr_frag1, state.types1_(block1, frag1),
-                            offset1, size, snapshot1, process_index);
+            get_offset_type(real_addr_frag1, state.types1_(block1, frag1), offset1, size, snapshot1, process_index);
         new_type2 =
         new_type2 =
-            get_offset_type(real_addr_frag2, state.types1_(block1, frag1),
-                            offset2, size, snapshot2, process_index);
+            get_offset_type(real_addr_frag2, state.types1_(block1, frag1), offset2, size, snapshot2, process_index);
       } else if (state.types2_(block2, frag2) != nullptr) {
         new_type1 =
       } else if (state.types2_(block2, frag2) != nullptr) {
         new_type1 =
-            get_offset_type(real_addr_frag1, state.types2_(block2, frag2),
-                            offset1, size, snapshot1, process_index);
+            get_offset_type(real_addr_frag1, state.types2_(block2, frag2), offset1, size, snapshot1, process_index);
         new_type2 =
         new_type2 =
-            get_offset_type(real_addr_frag2, state.types2_(block2, frag2),
-                            offset2, size, snapshot2, process_index);
+            get_offset_type(real_addr_frag2, state.types2_(block2, frag2), offset2, size, snapshot2, process_index);
       } else {
         if (match_pairs)
           state.match_equals(previous);
       } else {
         if (match_pairs)
           state.match_equals(previous);
@@ -1287,13 +1226,12 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
       size = new_size1;
     }
 
       size = new_size1;
     }
 
-    if (offset1 == 0 && offset2 == 0
-      && !previous->insert(simgrid::mc::makeHeapLocationPair(
-        block1, frag1, block2, frag2)).second) {
-        if (match_pairs)
-          state.match_equals(previous);
-        return 0;
-      }
+    if (offset1 == 0 && offset2 == 0 &&
+        not previous->insert(simgrid::mc::makeHeapLocationPair(block1, frag1, block2, frag2)).second) {
+      if (match_pairs)
+        state.match_equals(previous);
+      return 0;
+    }
 
     if (size <= 0) {
       if (match_pairs)
 
     if (size <= 0) {
       if (match_pairs)
@@ -1301,9 +1239,8 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
       return 0;
     }
 
       return 0;
     }
 
-    if ((heapinfo1->busy_frag.ignore[frag1] > 0)
-        && (heapinfo2->busy_frag.ignore[frag2] ==
-            heapinfo1->busy_frag.ignore[frag1]))
+    if ((heapinfo1->busy_frag.ignore[frag1] > 0) &&
+        (heapinfo2->busy_frag.ignore[frag2] == heapinfo1->busy_frag.ignore[frag1]))
       check_ignore = heapinfo1->busy_frag.ignore[frag1];
 
   } else
       check_ignore = heapinfo1->busy_frag.ignore[frag1];
 
   } else
@@ -1312,14 +1249,11 @@ int compare_heap_area(simgrid::mc::StateComparator& state, int process_index,
 
   /* Start comparison */
   if (type)
 
   /* Start comparison */
   if (type)
-    res_compare =
-        compare_heap_area_with_type(state, process_index, area1, area2, snapshot1, snapshot2,
-                                    previous, type, size, check_ignore,
-                                    pointer_level);
+    res_compare = compare_heap_area_with_type(state, process_index, area1, area2, snapshot1, snapshot2, previous, type,
+                                              size, check_ignore, pointer_level);
   else
   else
-    res_compare =
-        compare_heap_area_without_type(state, process_index, area1, area2, snapshot1, snapshot2,
-                                       previous, size, check_ignore);
+    res_compare = compare_heap_area_without_type(state, process_index, area1, area2, snapshot1, snapshot2, previous,
+                                                 size, check_ignore);
 
   if (res_compare == 1)
     return res_compare;
 
   if (res_compare == 1)
     return res_compare;
@@ -1345,7 +1279,9 @@ static int compare_areas_with_type(simgrid::mc::StateComparator& state,
 
   simgrid::mc::Type* subtype;
   simgrid::mc::Type* subsubtype;
 
   simgrid::mc::Type* subtype;
   simgrid::mc::Type* subsubtype;
-  int elm_size, i, res;
+  int elm_size;
+  int i;
+  int res;
 
   top:
   switch (type->type) {
 
   top:
   switch (type->type) {
@@ -1355,11 +1291,7 @@ static int compare_areas_with_type(simgrid::mc::StateComparator& state,
   case DW_TAG_base_type:
   case DW_TAG_enumeration_type:
   case DW_TAG_union_type:
   case DW_TAG_base_type:
   case DW_TAG_enumeration_type:
   case DW_TAG_union_type:
-  {
-    return MC_snapshot_region_memcmp(
-      real_area1, region1, real_area2, region2,
-      type->byte_size) != 0;
-  }
+    return MC_snapshot_region_memcmp(real_area1, region1, real_area2, region2, type->byte_size) != 0;
   case DW_TAG_typedef:
   case DW_TAG_volatile_type:
   case DW_TAG_const_type:
   case DW_TAG_typedef:
   case DW_TAG_volatile_type:
   case DW_TAG_const_type:
@@ -1419,8 +1351,7 @@ static int compare_areas_with_type(simgrid::mc::StateComparator& state,
       return 0;
     if (addr_pointed1 == nullptr || addr_pointed2 == nullptr)
       return 1;
       return 0;
     if (addr_pointed1 == nullptr || addr_pointed2 == nullptr)
       return 1;
-    if (!state.compared_pointers.insert(
-        std::make_pair(addr_pointed1, addr_pointed2)).second)
+    if (not state.compared_pointers.insert(std::make_pair(addr_pointed1, addr_pointed2)).second)
       return 0;
 
     pointer_level++;
       return 0;
 
     pointer_level++;
@@ -1444,9 +1375,9 @@ static int compare_areas_with_type(simgrid::mc::StateComparator& state,
 
       // The pointers are both in the current object R/W segment:
       else if (region1->contain(simgrid::mc::remote(addr_pointed1))) {
 
       // The pointers are both in the current object R/W segment:
       else if (region1->contain(simgrid::mc::remote(addr_pointed1))) {
-        if (!region2->contain(simgrid::mc::remote(addr_pointed2)))
+        if (not region2->contain(simgrid::mc::remote(addr_pointed2)))
           return 1;
           return 1;
-        if (!type->type_id)
+        if (not type->type_id)
           return (addr_pointed1 != addr_pointed2);
         else
           return compare_areas_with_type(state, process_index,
           return (addr_pointed1 != addr_pointed2);
         else
           return compare_areas_with_type(state, process_index,
@@ -1485,7 +1416,7 @@ static int compare_areas_with_type(simgrid::mc::StateComparator& state,
     return -1;
     break;
   default:
     return -1;
     break;
   default:
-    XBT_VERB("Unknown case : %d", type->type);
+    XBT_VERB("Unknown case: %d", type->type);
     break;
   }
 
     break;
   }
 
@@ -1513,12 +1444,12 @@ static int compare_global_variables(
 
     // Compare the global variables separately for each simulates process:
     for (size_t process_index = 0; process_index < process_count; process_index++) {
 
     // Compare the global variables separately for each simulates process:
     for (size_t process_index = 0; process_index < process_count; process_index++) {
-      int is_diff = compare_global_variables(state,
-        object_info, process_index,
-        &r1->privatized_data()[process_index],
-        &r2->privatized_data()[process_index],
-        snapshot1, snapshot2);
-      if (is_diff) return 1;
+      if (compare_global_variables(state,
+          object_info, process_index,
+          &r1->privatized_data()[process_index],
+          &r2->privatized_data()[process_index],
+          snapshot1, snapshot2))
+        return 1;
     }
     return 0;
   }
     }
     return 0;
   }
@@ -1630,51 +1561,45 @@ int snapshot_compare(int num1, simgrid::mc::Snapshot* s1, int num2, simgrid::mc:
   simgrid::mc::Process* process = &mc_model_checker->process();
 
   int errors = 0;
   simgrid::mc::Process* process = &mc_model_checker->process();
 
   int errors = 0;
-  int res_init;
 
   int hash_result = 0;
   if (_sg_mc_hash) {
     hash_result = (s1->hash != s2->hash);
     if (hash_result) {
 
   int hash_result = 0;
   if (_sg_mc_hash) {
     hash_result = (s1->hash != s2->hash);
     if (hash_result) {
-      XBT_VERB("(%d - %d) Different hash : 0x%" PRIx64 "--0x%" PRIx64, num1,
-               num2, s1->hash, s2->hash);
+      XBT_VERB("(%d - %d) Different hash: 0x%" PRIx64 "--0x%" PRIx64, num1, num2, s1->hash, s2->hash);
 #ifndef MC_DEBUG
       return 1;
 #endif
     } else
 #ifndef MC_DEBUG
       return 1;
 #endif
     } else
-      XBT_VERB("(%d - %d) Same hash : 0x%" PRIx64, num1, num2, s1->hash);
+      XBT_VERB("(%d - %d) Same hash: 0x%" PRIx64, num1, num2, s1->hash);
   }
 
   /* Compare enabled processes */
   if (s1->enabled_processes != s2->enabled_processes) {
   }
 
   /* Compare enabled processes */
   if (s1->enabled_processes != s2->enabled_processes) {
-      XBT_VERB("(%d - %d) Different enabled processes", num1, num2);
-      // return 1; ??
+    XBT_VERB("(%d - %d) Different amount of enabled processes", num1, num2);
+    return 1;
   }
 
   }
 
-  unsigned long i = 0;
-  size_t size_used1, size_used2;
-  int is_diff = 0;
-
   /* Compare size of stacks */
   /* Compare size of stacks */
-  while (i < s1->stacks.size()) {
-    size_used1 = s1->stack_sizes[i];
-    size_used2 = s2->stack_sizes[i];
+  int is_diff = 0;
+  for (unsigned long i = 0; i < s1->stacks.size(); i++) {
+    size_t size_used1 = s1->stack_sizes[i];
+    size_t size_used2 = s2->stack_sizes[i];
     if (size_used1 != size_used2) {
 #ifdef MC_DEBUG
     if (size_used1 != size_used2) {
 #ifdef MC_DEBUG
-      XBT_DEBUG("(%d - %d) Different size used in stacks : %zu - %zu", num1,
-                num2, size_used1, size_used2);
+      XBT_DEBUG("(%d - %d) Different size used in stacks: %zu - %zu", num1, num2, size_used1, size_used2);
       errors++;
       is_diff = 1;
 #else
 #ifdef MC_VERBOSE
       errors++;
       is_diff = 1;
 #else
 #ifdef MC_VERBOSE
-      XBT_VERB("(%d - %d) Different size used in stacks : %zu - %zu", num1,
-               num2, size_used1, size_used2);
+      XBT_VERB("(%d - %d) Different size used in stacks: %zu - %zu", num1, num2, size_used1, size_used2);
 #endif
       return 1;
 #endif
     }
 #endif
       return 1;
 #endif
     }
-    i++;
   }
   }
+  if (is_diff) // do not proceed if there is any stacks that don't match
+    return 1;
 
   /* Init heap information used in heap comparison algorithm */
   xbt_mheap_t heap1 = (xbt_mheap_t)s1->read_bytes(
 
   /* Init heap information used in heap comparison algorithm */
   xbt_mheap_t heap1 = (xbt_mheap_t)s1->read_bytes(
@@ -1685,8 +1610,7 @@ int snapshot_compare(int num1, simgrid::mc::Snapshot* s1, int num2, simgrid::mc:
     alloca(sizeof(struct mdesc)), sizeof(struct mdesc),
     remote(process->heap_address),
     simgrid::mc::ProcessIndexMissing, simgrid::mc::ReadOptions::lazy());
     alloca(sizeof(struct mdesc)), sizeof(struct mdesc),
     remote(process->heap_address),
     simgrid::mc::ProcessIndexMissing, simgrid::mc::ReadOptions::lazy());
-  res_init = state_comparator->initHeapInformation(
-    heap1, heap2, &s1->to_ignore, &s2->to_ignore);
+  int res_init = state_comparator->initHeapInformation(heap1, heap2, &s1->to_ignore, &s2->to_ignore);
 
   if (res_init == -1) {
 #ifdef MC_DEBUG
 
   if (res_init == -1) {
 #ifdef MC_DEBUG
@@ -1702,15 +1626,10 @@ int snapshot_compare(int num1, simgrid::mc::Snapshot* s1, int num2, simgrid::mc:
   }
 
   /* Stacks comparison */
   }
 
   /* Stacks comparison */
-  unsigned cursor = 0;
   int diff_local = 0;
   int diff_local = 0;
-#ifdef MC_DEBUG
-  is_diff = 0;
-#endif
-  mc_snapshot_stack_t stack1, stack2;
-  while (cursor < s1->stacks.size()) {
-    stack1 = &s1->stacks[cursor];
-    stack2 = &s2->stacks[cursor];
+  for (unsigned int cursor = 0; cursor < s1->stacks.size(); cursor++) {
+    mc_snapshot_stack_t stack1 = &s1->stacks[cursor];
+    mc_snapshot_stack_t stack2 = &s2->stacks[cursor];
 
     if (stack1->process_index != stack2->process_index) {
       diff_local = 1;
 
     if (stack1->process_index != stack2->process_index) {
       diff_local = 1;
@@ -1735,7 +1654,6 @@ int snapshot_compare(int num1, simgrid::mc::Snapshot* s1, int num2, simgrid::mc:
       return 1;
 #endif
     }
       return 1;
 #endif
     }
-    cursor++;
   }
 
   size_t regions_count = s1->snapshot_regions.size();
   }
 
   size_t regions_count = s1->snapshot_regions.size();
@@ -1757,12 +1675,9 @@ int snapshot_compare(int num1, simgrid::mc::Snapshot* s1, int num2, simgrid::mc:
     std::string const& name = region1->object_info()->file_name;
 
     /* Compare global variables */
     std::string const& name = region1->object_info()->file_name;
 
     /* Compare global variables */
-    is_diff =
-      compare_global_variables(*state_comparator,
-        region1->object_info(), simgrid::mc::ProcessIndexDisabled,
-        region1, region2, s1, s2);
+    if (compare_global_variables(*state_comparator, region1->object_info(), simgrid::mc::ProcessIndexDisabled, region1,
+                                 region2, s1, s2)) {
 
 
-    if (is_diff != 0) {
 #ifdef MC_DEBUG
       XBT_DEBUG("(%d - %d) Different global variables in %s",
         num1, num2, name.c_str());
 #ifdef MC_DEBUG
       XBT_DEBUG("(%d - %d) Different global variables in %s",
         num1, num2, name.c_str());
@@ -1789,7 +1704,6 @@ int snapshot_compare(int num1, simgrid::mc::Snapshot* s1, int num2, simgrid::mc:
 #ifdef MC_VERBOSE
     XBT_VERB("(%d - %d) Different heap (mmalloc_compare)", num1, num2);
 #endif
 #ifdef MC_VERBOSE
     XBT_VERB("(%d - %d) Different heap (mmalloc_compare)", num1, num2);
 #endif
-
     return 1;
 #endif
   }
     return 1;
 #endif
   }
@@ -1807,8 +1721,7 @@ int snapshot_compare(int num1, simgrid::mc::Snapshot* s1, int num2, simgrid::mc:
     // * There MUST not be any false negative.
 
     XBT_VERB("(%d - %d) State equality hash test is %s %s", num1, num2,
     // * There MUST not be any false negative.
 
     XBT_VERB("(%d - %d) State equality hash test is %s %s", num1, num2,
-             (hash_result != 0) == (errors != 0) ? "true" : "false",
-             !hash_result ? "positive" : "negative");
+             (hash_result != 0) == (errors != 0) ? "true" : "false", not hash_result ? "positive" : "negative");
   }
 #endif
 
   }
 #endif
 
Clone of SimGrid repository with local patches