Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
model-checker : use new variable _sg_mc_liveness instead of _sg_mc_property_file
[simgrid.git] / src / mc / mc_compare.c
1 /* Copyright (c) 2012-2014. 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 <inttypes.h>
8
9 #include "mc_private.h"
10
11 #include "xbt/mmalloc.h"
12 #include "xbt/mmalloc/mmprivate.h"
13
14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_compare, mc,
15                                 "Logging specific to mc_compare");
16
17 typedef struct s_pointers_pair {
18   void *p1;
19   void *p2;
20 } s_pointers_pair_t, *pointers_pair_t;
21
22 __thread xbt_dynar_t compared_pointers;
23
24 /************************** Free functions ****************************/
25 /********************************************************************/
26
27 static void stack_region_free(stack_region_t s)
28 {
29   if (s) {
30     xbt_free(s->process_name);
31     xbt_free(s);
32   }
33 }
34
35 static void stack_region_free_voidp(void *s)
36 {
37   stack_region_free((stack_region_t) * (void **) s);
38 }
39
40 static void pointers_pair_free(pointers_pair_t p)
41 {
42   xbt_free(p);
43 }
44
45 static void pointers_pair_free_voidp(void *p)
46 {
47   pointers_pair_free((pointers_pair_t) * (void **) p);
48 }
49
50 /************************** Snapshot comparison *******************************/
51 /******************************************************************************/
52
53 /** \brief Try to add a pair a compared pointers to the set of compared pointers
54  *
55  *  \result !=0 if the pointers were added (they were not in the set),
56  *      0 otherwise (they were already in the set)
57  */
58 static int add_compared_pointers(void *p1, void *p2)
59 {
60
61   pointers_pair_t new_pair = xbt_new0(s_pointers_pair_t, 1);
62   new_pair->p1 = p1;
63   new_pair->p2 = p2;
64
65   if (xbt_dynar_is_empty(compared_pointers)) {
66     xbt_dynar_push(compared_pointers, &new_pair);
67     return 1;
68   }
69
70   unsigned int cursor = 0;
71   int start = 0;
72   int end = xbt_dynar_length(compared_pointers) - 1;
73   pointers_pair_t pair = NULL;
74
75   pointers_pair_t *p =
76       (pointers_pair_t *) xbt_dynar_get_ptr(compared_pointers, 0);
77
78   while (start <= end) {
79     cursor = (start + end) / 2;
80     pair = p[cursor];
81     if (pair->p1 < p1) {
82       start = cursor + 1;
83     } else if (pair->p1 > p1) {
84       end = cursor - 1;
85     } else if (pair->p2 < p2) {
86       start = cursor + 1;
87     } else if (pair->p2 > p2) {
88       end = cursor - 1;
89     } else {
90       pointers_pair_free(new_pair);
91       return 0;
92     }
93   }
94
95   if (pair->p1 < p1)
96     xbt_dynar_insert_at(compared_pointers, cursor + 1, &new_pair);
97   else if (pair->p1 > p1)
98     xbt_dynar_insert_at(compared_pointers, cursor, &new_pair);
99   else if (pair->p2 < p2)
100     xbt_dynar_insert_at(compared_pointers, cursor + 1, &new_pair);
101   else if (pair->p2 > p2)
102     xbt_dynar_insert_at(compared_pointers, cursor, &new_pair);
103   else
104     xbt_die("Unrecheable");
105
106   return 1;
107 }
108
109 static int compare_areas_with_type(void *area1, void *area2,
110                                    mc_snapshot_t snapshot1,
111                                    mc_snapshot_t snapshot2, dw_type_t type,
112                                    int region_size, int region_type,
113                                    void *start_data, int pointer_level)
114 {
115
116   unsigned int cursor = 0;
117   dw_type_t member, subtype, subsubtype;
118   int elm_size, i, res;
119   void *addr_pointed1, *addr_pointed2;
120
121   switch (type->type) {
122   case DW_TAG_unspecified_type:
123     return 1;
124
125   case DW_TAG_base_type:
126   case DW_TAG_enumeration_type:
127   case DW_TAG_union_type:
128     return (memcmp(area1, area2, type->byte_size) != 0);
129     break;
130   case DW_TAG_typedef:
131   case DW_TAG_volatile_type:
132   case DW_TAG_const_type:
133     return compare_areas_with_type(area1, area2, snapshot1, snapshot2,
134                                    type->subtype, region_size, region_type,
135                                    start_data, pointer_level);
136     break;
137   case DW_TAG_array_type:
138     subtype = type->subtype;
139     switch (subtype->type) {
140     case DW_TAG_unspecified_type:
141       return 1;
142
143     case DW_TAG_base_type:
144     case DW_TAG_enumeration_type:
145     case DW_TAG_pointer_type:
146     case DW_TAG_reference_type:
147     case DW_TAG_rvalue_reference_type:
148     case DW_TAG_structure_type:
149     case DW_TAG_class_type:
150     case DW_TAG_union_type:
151       if (subtype->full_type)
152         subtype = subtype->full_type;
153       elm_size = subtype->byte_size;
154       break;
155     case DW_TAG_const_type:
156     case DW_TAG_typedef:
157     case DW_TAG_volatile_type:
158       subsubtype = subtype->subtype;
159       if (subsubtype->full_type)
160         subsubtype = subsubtype->full_type;
161       elm_size = subsubtype->byte_size;
162       break;
163     default:
164       return 0;
165       break;
166     }
167     for (i = 0; i < type->element_count; i++) {
168       res =
169           compare_areas_with_type((char *) area1 + (i * elm_size),
170                                   (char *) area2 + (i * elm_size), snapshot1,
171                                   snapshot2, type->subtype, region_size,
172                                   region_type, start_data, pointer_level);
173       if (res == 1)
174         return res;
175     }
176     break;
177   case DW_TAG_pointer_type:
178   case DW_TAG_reference_type:
179   case DW_TAG_rvalue_reference_type:
180
181     addr_pointed1 = *((void **) (area1));
182     addr_pointed2 = *((void **) (area2));
183
184     if (type->subtype && type->subtype->type == DW_TAG_subroutine_type) {
185       return (addr_pointed1 != addr_pointed2);
186     } else {
187
188       if (addr_pointed1 == NULL && addr_pointed2 == NULL)
189         return 0;
190       if (!add_compared_pointers(addr_pointed1, addr_pointed2))
191         return 0;
192
193       pointer_level++;
194
195       // Some cases are not handled here:
196       // * the pointers lead to different areas (one to the heap, the other to the RW segment ...);
197       // * a pointer leads to the read-only segment of the current object;
198       // * a pointer lead to a different ELF object.
199
200       if (addr_pointed1 > std_heap
201           && addr_pointed1 < mc_snapshot_get_heap_end(snapshot1)) {
202         if (!
203             (addr_pointed2 > std_heap
204              && addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)))
205           return 1;
206         // The pointers are both in the heap:
207         return compare_heap_area(addr_pointed1, addr_pointed2, snapshot1,
208                                  snapshot2, NULL, type->subtype, pointer_level);
209       }
210       // The pointers are both in the current object R/W segment:
211       else if (addr_pointed1 > start_data
212                && (char *) addr_pointed1 <= (char *) start_data + region_size) {
213         if (!
214             (addr_pointed2 > start_data
215              && (char *) addr_pointed2 <= (char *) start_data + region_size))
216           return 1;
217         if (type->dw_type_id == NULL)
218           return (addr_pointed1 != addr_pointed2);
219         else {
220           void *translated_addr_pointer1 =
221               mc_translate_address((uintptr_t) addr_pointed1, snapshot1);
222           void *translated_addr_pointer2 =
223               mc_translate_address((uintptr_t) addr_pointed2, snapshot2);
224           return compare_areas_with_type(translated_addr_pointer1,
225                                          translated_addr_pointer2, snapshot1,
226                                          snapshot2, type->subtype, region_size,
227                                          region_type, start_data,
228                                          pointer_level);
229         }
230       }
231
232       else {
233         return (addr_pointed1 != addr_pointed2);
234       }
235     }
236     break;
237   case DW_TAG_structure_type:
238   case DW_TAG_class_type:
239     xbt_dynar_foreach(type->members, cursor, member) {
240       void *member1 =
241           mc_member_snapshot_resolve(area1, type, member, snapshot1);
242       void *member2 =
243           mc_member_snapshot_resolve(area2, type, member, snapshot2);
244       res =
245           compare_areas_with_type(member1, member2, snapshot1, snapshot2,
246                                   member->subtype, region_size, region_type,
247                                   start_data, pointer_level);
248       if (res == 1)
249         return res;
250     }
251     break;
252   case DW_TAG_subroutine_type:
253     return -1;
254     break;
255   default:
256     XBT_VERB("Unknown case : %d", type->type);
257     break;
258   }
259
260   return 0;
261 }
262
263 static int compare_global_variables(int region_type, mc_mem_region_t r1,
264                                     mc_mem_region_t r2, mc_snapshot_t snapshot1,
265                                     mc_snapshot_t snapshot2)
266 {
267
268   if (!compared_pointers) {
269     compared_pointers =
270         xbt_dynar_new(sizeof(pointers_pair_t), pointers_pair_free_voidp);
271   } else {
272     xbt_dynar_reset(compared_pointers);
273   }
274
275   xbt_dynar_t variables;
276   int res;
277   unsigned int cursor = 0;
278   dw_variable_t current_var;
279   size_t offset;
280   void *start_data;
281   void *start_data_binary = mc_binary_info->start_rw;
282   void *start_data_libsimgrid = mc_libsimgrid_info->start_rw;
283
284   mc_object_info_t object_info = NULL;
285   if (region_type == 2) {
286     object_info = mc_binary_info;
287     start_data = start_data_binary;
288   } else {
289     object_info = mc_libsimgrid_info;
290     start_data = start_data_libsimgrid;
291   }
292   variables = object_info->global_variables;
293
294   xbt_dynar_foreach(variables, cursor, current_var) {
295
296     // If the variable is not in this object, skip it:
297     // We do not expect to find a pointer to something which is not reachable
298     // by the global variables.
299     if ((char *) current_var->address < (char *) object_info->start_rw
300         || (char *) current_var->address > (char *) object_info->end_rw)
301       continue;
302
303     offset = (char *) current_var->address - (char *) object_info->start_rw;
304
305     dw_type_t bvariable_type = current_var->type;
306     res =
307         compare_areas_with_type((char *) r1->data + offset,
308                                 (char *) r2->data + offset, snapshot1,
309                                 snapshot2, bvariable_type, r1->size,
310                                 region_type, start_data, 0);
311     if (res == 1) {
312       XBT_VERB("Global variable %s (%p - %p) is different between snapshots",
313                current_var->name, (char *) r1->data + offset,
314                (char *) r2->data + offset);
315       xbt_dynar_free(&compared_pointers);
316       compared_pointers = NULL;
317       return 1;
318     }
319
320   }
321
322   xbt_dynar_free(&compared_pointers);
323   compared_pointers = NULL;
324
325   return 0;
326
327 }
328
329 static int compare_local_variables(mc_snapshot_t snapshot1,
330                                    mc_snapshot_t snapshot2,
331                                    mc_snapshot_stack_t stack1,
332                                    mc_snapshot_stack_t stack2, void *heap1,
333                                    void *heap2)
334 {
335   void *start_data_binary = mc_binary_info->start_rw;
336   void *start_data_libsimgrid = mc_libsimgrid_info->start_rw;
337
338   if (!compared_pointers) {
339     compared_pointers =
340         xbt_dynar_new(sizeof(pointers_pair_t), pointers_pair_free_voidp);
341   } else {
342     xbt_dynar_reset(compared_pointers);
343   }
344
345   if (xbt_dynar_length(stack1->local_variables) !=
346       xbt_dynar_length(stack2->local_variables)) {
347     XBT_VERB("Different number of local variables");
348     xbt_dynar_free(&compared_pointers);
349     compared_pointers = NULL;
350     return 1;
351   } else {
352     unsigned int cursor = 0;
353     local_variable_t current_var1, current_var2;
354     int offset1, offset2, res;
355     while (cursor < xbt_dynar_length(stack1->local_variables)) {
356       current_var1 =
357           (local_variable_t) xbt_dynar_get_as(stack1->local_variables, cursor,
358                                               local_variable_t);
359       current_var2 =
360           (local_variable_t) xbt_dynar_get_as(stack2->local_variables, cursor,
361                                               local_variable_t);
362       if (strcmp(current_var1->name, current_var2->name) != 0
363           || current_var1->subprogram != current_var1->subprogram
364           || current_var1->ip != current_var2->ip) {
365         xbt_dynar_free(&compared_pointers);
366         // TODO, fix current_varX->subprogram->name to include name if DW_TAG_inlined_subprogram
367         XBT_VERB
368             ("Different name of variable (%s - %s) or frame (%s - %s) or ip (%lu - %lu)",
369              current_var1->name, current_var2->name,
370              current_var1->subprogram->name, current_var2->subprogram->name,
371              current_var1->ip, current_var2->ip);
372         return 1;
373       }
374       offset1 = (char *) current_var1->address - (char *) std_heap;
375       offset2 = (char *) current_var2->address - (char *) std_heap;
376       // TODO, fix current_varX->subprogram->name to include name if DW_TAG_inlined_subprogram
377
378       if (current_var1->region == 1) {
379         dw_type_t subtype = current_var1->type;
380         res =
381             compare_areas_with_type((char *) heap1 + offset1,
382                                     (char *) heap2 + offset2, snapshot1,
383                                     snapshot2, subtype, 0, 1,
384                                     start_data_libsimgrid, 0);
385       } else {
386         dw_type_t subtype = current_var2->type;
387         res =
388             compare_areas_with_type((char *) heap1 + offset1,
389                                     (char *) heap2 + offset2, snapshot1,
390                                     snapshot2, subtype, 0, 2, start_data_binary,
391                                     0);
392       }
393       if (res == 1) {
394         // TODO, fix current_varX->subprogram->name to include name if DW_TAG_inlined_subprogram
395         XBT_VERB
396             ("Local variable %s (%p - %p) in frame %s  is different between snapshots",
397              current_var1->name, (char *) heap1 + offset1,
398              (char *) heap2 + offset2, current_var1->subprogram->name);
399         xbt_dynar_free(&compared_pointers);
400         compared_pointers = NULL;
401         return res;
402       }
403       cursor++;
404     }
405     xbt_dynar_free(&compared_pointers);
406     compared_pointers = NULL;
407     return 0;
408   }
409 }
410
411 int snapshot_compare(void *state1, void *state2)
412 {
413
414   mc_snapshot_t s1, s2;
415   int num1, num2;
416
417   if (_sg_mc_liveness) {        /* Liveness MC */
418     s1 = ((mc_visited_pair_t) state1)->graph_state->system_state;
419     s2 = ((mc_visited_pair_t) state2)->graph_state->system_state;
420     num1 = ((mc_visited_pair_t) state1)->num;
421     num2 = ((mc_visited_pair_t) state2)->num;
422   } else {                      /* Safety or comm determinism MC */
423     s1 = ((mc_visited_state_t) state1)->system_state;
424     s2 = ((mc_visited_state_t) state2)->system_state;
425     num1 = ((mc_visited_state_t) state1)->num;
426     num2 = ((mc_visited_state_t) state2)->num;
427   }
428
429   int errors = 0;
430   int res_init;
431
432   xbt_os_timer_t global_timer = xbt_os_timer_new();
433   xbt_os_timer_t timer = xbt_os_timer_new();
434
435   xbt_os_walltimer_start(global_timer);
436
437 #ifdef MC_DEBUG
438   xbt_os_walltimer_start(timer);
439 #endif
440
441   int hash_result = 0;
442   if (_sg_mc_hash) {
443     hash_result = (s1->hash != s2->hash);
444     if (hash_result) {
445       XBT_VERB("(%d - %d) Different hash : 0x%" PRIx64 "--0x%" PRIx64, num1,
446                num2, s1->hash, s2->hash);
447 #ifndef MC_DEBUG
448       return 1;
449 #endif
450     } else {
451       XBT_VERB("(%d - %d) Same hash : 0x%" PRIx64, num1, num2, s1->hash);
452     }
453   }
454
455   /* Compare enabled processes */
456   unsigned int cursor;
457   int pid;
458   xbt_dynar_foreach(s1->enabled_processes, cursor, pid){
459     if(!xbt_dynar_member(s2->enabled_processes, &pid))
460       XBT_VERB("(%d - %d) Different enabled processes", num1, num2);
461   }
462
463   int i = 0;
464   size_t size_used1, size_used2;
465   int is_diff = 0;
466
467   /* Compare size of stacks */
468   while (i < xbt_dynar_length(s1->stacks)) {
469     size_used1 = s1->stack_sizes[i];
470     size_used2 = s2->stack_sizes[i];
471     if (size_used1 != size_used2) {
472 #ifdef MC_DEBUG
473       if (is_diff == 0) {
474         xbt_os_walltimer_stop(timer);
475         mc_comp_times->stacks_sizes_comparison_time =
476             xbt_os_timer_elapsed(timer);
477       }
478       XBT_DEBUG("(%d - %d) Different size used in stacks : %zu - %zu", num1,
479                 num2, size_used1, size_used2);
480       errors++;
481       is_diff = 1;
482 #else
483 #ifdef MC_VERBOSE
484       XBT_VERB("(%d - %d) Different size used in stacks : %zu - %zu", num1,
485                num2, size_used1, size_used2);
486 #endif
487
488       xbt_os_walltimer_stop(timer);
489       xbt_os_timer_free(timer);
490       xbt_os_walltimer_stop(global_timer);
491       mc_snapshot_comparison_time = xbt_os_timer_elapsed(global_timer);
492       xbt_os_timer_free(global_timer);
493
494       return 1;
495 #endif
496     }
497     i++;
498   }
499
500 #ifdef MC_DEBUG
501   if (is_diff == 0)
502     xbt_os_walltimer_stop(timer);
503   xbt_os_walltimer_start(timer);
504 #endif
505
506   /* Init heap information used in heap comparison algorithm */
507   res_init =
508       init_heap_information((xbt_mheap_t) s1->regions[0]->data,
509                             (xbt_mheap_t) s2->regions[0]->data, s1->to_ignore,
510                             s2->to_ignore);
511   if (res_init == -1) {
512 #ifdef MC_DEBUG
513     XBT_DEBUG("(%d - %d) Different heap information", num1, num2);
514     errors++;
515 #else
516 #ifdef MC_VERBOSE
517     XBT_VERB("(%d - %d) Different heap information", num1, num2);
518 #endif
519
520     xbt_os_walltimer_stop(global_timer);
521     mc_snapshot_comparison_time = xbt_os_timer_elapsed(global_timer);
522     xbt_os_timer_free(global_timer);
523
524     return 1;
525 #endif
526   }
527 #ifdef MC_DEBUG
528   xbt_os_walltimer_start(timer);
529 #endif
530
531   /* Stacks comparison */
532   cursor = 0;
533   int diff_local = 0;
534 #ifdef MC_DEBUG
535   is_diff = 0;
536 #endif
537   mc_snapshot_stack_t stack1, stack2;
538
539   while (cursor < xbt_dynar_length(s1->stacks)) {
540     stack1 =
541         (mc_snapshot_stack_t) xbt_dynar_get_as(s1->stacks, cursor,
542                                                mc_snapshot_stack_t);
543     stack2 =
544         (mc_snapshot_stack_t) xbt_dynar_get_as(s2->stacks, cursor,
545                                                mc_snapshot_stack_t);
546     diff_local =
547         compare_local_variables(s1, s2, stack1, stack2, s1->regions[0]->data,
548                                 s2->regions[0]->data);
549     if (diff_local > 0) {
550 #ifdef MC_DEBUG
551       if (is_diff == 0) {
552         xbt_os_walltimer_stop(timer);
553         mc_comp_times->stacks_comparison_time = xbt_os_timer_elapsed(timer);
554       }
555       XBT_DEBUG("(%d - %d) Different local variables between stacks %d", num1,
556                 num2, cursor + 1);
557       errors++;
558       is_diff = 1;
559 #else
560
561 #ifdef MC_VERBOSE
562       XBT_VERB("(%d - %d) Different local variables between stacks %d", num1,
563                num2, cursor + 1);
564 #endif
565
566       reset_heap_information();
567       xbt_os_walltimer_stop(timer);
568       xbt_os_timer_free(timer);
569       xbt_os_walltimer_stop(global_timer);
570       mc_snapshot_comparison_time = xbt_os_timer_elapsed(global_timer);
571       xbt_os_timer_free(global_timer);
572
573       return 1;
574 #endif
575     }
576     cursor++;
577   }
578
579
580
581   const char *names[3] = { "?", "libsimgrid", "binary" };
582 #ifdef MC_DEBUG
583   double *times[3] = {
584     NULL,
585     &mc_comp_times->libsimgrid_global_variables_comparison_time,
586     &mc_comp_times->binary_global_variables_comparison_time
587   };
588 #endif
589
590   int k = 0;
591   for (k = 2; k != 0; --k) {
592 #ifdef MC_DEBUG
593     if (is_diff == 0)
594       xbt_os_walltimer_stop(timer);
595     xbt_os_walltimer_start(timer);
596 #endif
597
598     /* Compare global variables */
599     is_diff =
600         compare_global_variables(k, s1->regions[k], s2->regions[k], s1, s2);
601     if (is_diff != 0) {
602 #ifdef MC_DEBUG
603       xbt_os_walltimer_stop(timer);
604       *times[k] = xbt_os_timer_elapsed(timer);
605       XBT_DEBUG("(%d - %d) Different global variables in %s", num1, num2,
606                 names[k]);
607       errors++;
608 #else
609 #ifdef MC_VERBOSE
610       XBT_VERB("(%d - %d) Different global variables in %s", num1, num2,
611                names[k]);
612 #endif
613
614       reset_heap_information();
615       xbt_os_walltimer_stop(timer);
616       xbt_os_timer_free(timer);
617       xbt_os_walltimer_stop(global_timer);
618       mc_snapshot_comparison_time = xbt_os_timer_elapsed(global_timer);
619       xbt_os_timer_free(global_timer);
620
621       return 1;
622 #endif
623     }
624   }
625
626 #ifdef MC_DEBUG
627   xbt_os_walltimer_start(timer);
628 #endif
629
630   /* Compare heap */
631   if (mmalloc_compare_heap(s1, s2, (xbt_mheap_t) s1->regions[0]->data,
632                            (xbt_mheap_t) s2->regions[0]->data) > 0) {
633
634 #ifdef MC_DEBUG
635     xbt_os_walltimer_stop(timer);
636     mc_comp_times->heap_comparison_time = xbt_os_timer_elapsed(timer);
637     XBT_DEBUG("(%d - %d) Different heap (mmalloc_compare)", num1, num2);
638     errors++;
639 #else
640
641 #ifdef MC_VERBOSE
642     XBT_VERB("(%d - %d) Different heap (mmalloc_compare)", num1, num2);
643 #endif
644
645     reset_heap_information();
646     xbt_os_walltimer_stop(timer);
647     xbt_os_timer_free(timer);
648     xbt_os_walltimer_stop(global_timer);
649     mc_snapshot_comparison_time = xbt_os_timer_elapsed(global_timer);
650     xbt_os_timer_free(global_timer);
651
652     return 1;
653 #endif
654   } else {
655 #ifdef MC_DEBUG
656     xbt_os_walltimer_stop(timer);
657 #endif
658   }
659
660   reset_heap_information();
661
662   xbt_os_walltimer_stop(timer);
663   xbt_os_timer_free(timer);
664
665 #ifdef MC_VERBOSE
666   xbt_os_walltimer_stop(global_timer);
667   mc_snapshot_comparison_time = xbt_os_timer_elapsed(global_timer);
668 #endif
669
670   xbt_os_timer_free(global_timer);
671
672 #ifdef MC_DEBUG
673   print_comparison_times();
674 #endif
675
676 #ifdef MC_VERBOSE
677   if (errors || hash_result)
678     XBT_VERB("(%d - %d) Difference found", num1, num2);
679   else
680     XBT_VERB("(%d - %d) No difference found", num1, num2);
681 #endif
682
683 #if defined(MC_DEBUG) && defined(MC_VERBOSE)
684   if (_sg_mc_hash) {
685     // * false positive SHOULD be avoided.
686     // * There MUST not be any false negative.
687
688     XBT_VERB("(%d - %d) State equality hash test is %s %s", num1, num2,
689              (hash_result != 0) == (errors != 0) ? "true" : "false",
690              !hash_result ? "positive" : "negative");
691   }
692 #endif
693
694   return errors > 0 || hash_result;
695
696 }
697
698 /***************************** Statistics *****************************/
699 /*******************************************************************/
700
701 void print_comparison_times()
702 {
703   XBT_DEBUG("*** Comparison times ***");
704   XBT_DEBUG("- Nb processes : %f", mc_comp_times->nb_processes_comparison_time);
705   XBT_DEBUG("- Nb bytes used : %f", mc_comp_times->bytes_used_comparison_time);
706   XBT_DEBUG("- Stacks sizes : %f", mc_comp_times->stacks_sizes_comparison_time);
707   XBT_DEBUG("- Binary global variables : %f",
708             mc_comp_times->binary_global_variables_comparison_time);
709   XBT_DEBUG("- Libsimgrid global variables : %f",
710             mc_comp_times->libsimgrid_global_variables_comparison_time);
711   XBT_DEBUG("- Heap : %f", mc_comp_times->heap_comparison_time);
712   XBT_DEBUG("- Stacks : %f", mc_comp_times->stacks_comparison_time);
713 }
714
715 /**************************** MC snapshot compare simcall **************************/
716 /***********************************************************************************/
717
718 int SIMIX_pre_mc_compare_snapshots(smx_simcall_t simcall,
719                                    mc_snapshot_t s1, mc_snapshot_t s2)
720 {
721   return snapshot_compare(s1, s2);
722 }
723
724 int MC_compare_snapshots(void *s1, void *s2)
725 {
726
727   return simcall_mc_compare_snapshots(s1, s2);
728
729 }