Logo AND Algorithmique Numérique Distribuée

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