src/mc/mcer_ignore.cpp

   1 /* Copyright (c) 2008-2015. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "internal_config.h"
   8 #include "mc_object_info.h"
   9 #include "mc/mc_private.h"
  10 #include "smpi/private.h"
  11 #include "mc/mc_snapshot.h"
  12 #include "mc/mc_ignore.h"
  13 #include "mc/mc_protocol.h"
  14 #include "mc/mc_client.h"
  15
  16 extern "C" {
  17
  18 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mcer_ignore, mc,
  19                                 "Logging specific to MC ignore mechanism");
  20
  21 // ***** Ignore heap chunks
  22
  23 extern xbt_dynar_t mc_heap_comparison_ignore;
  24
  25 void heap_ignore_region_free(mc_heap_ignore_region_t r)
  26 {
  27   xbt_free(r);
  28 }
  29
  30 void heap_ignore_region_free_voidp(void *r)
  31 {
  32   heap_ignore_region_free((mc_heap_ignore_region_t) * (void **) r);
  33 }
  34
  35
  36 void MC_heap_region_ignore_insert(mc_heap_ignore_region_t region)
  37 {
  38   if (mc_heap_comparison_ignore == NULL) {
  39     mc_heap_comparison_ignore =
  40         xbt_dynar_new(sizeof(mc_heap_ignore_region_t),
  41                       heap_ignore_region_free_voidp);
  42     xbt_dynar_push(mc_heap_comparison_ignore, &region);
  43     return;
  44   }
  45
  46   unsigned int cursor = 0;
  47   mc_heap_ignore_region_t current_region = NULL;
  48   int start = 0;
  49   int end = xbt_dynar_length(mc_heap_comparison_ignore) - 1;
  50
  51   // Find the position where we want to insert the mc_heap_ignore_region_t:
  52   while (start <= end) {
  53     cursor = (start + end) / 2;
  54     current_region =
  55         (mc_heap_ignore_region_t) xbt_dynar_get_as(mc_heap_comparison_ignore,
  56                                                    cursor,
  57                                                    mc_heap_ignore_region_t);
  58     if (current_region->address == region->address) {
  59       heap_ignore_region_free(region);
  60       return;
  61     } else if (current_region->address < region->address) {
  62       start = cursor + 1;
  63     } else {
  64       end = cursor - 1;
  65     }
  66   }
  67
  68   // Insert it mc_heap_ignore_region_t:
  69   if (current_region->address < region->address)
  70     xbt_dynar_insert_at(mc_heap_comparison_ignore, cursor + 1, &region);
  71   else
  72     xbt_dynar_insert_at(mc_heap_comparison_ignore, cursor, &region);
  73 }
  74
  75 void MC_heap_region_ignore_remove(void *address, size_t size)
  76 {
  77   unsigned int cursor = 0;
  78   int start = 0;
  79   int end = xbt_dynar_length(mc_heap_comparison_ignore) - 1;
  80   mc_heap_ignore_region_t region;
  81   int ignore_found = 0;
  82
  83   while (start <= end) {
  84     cursor = (start + end) / 2;
  85     region =
  86         (mc_heap_ignore_region_t) xbt_dynar_get_as(mc_heap_comparison_ignore,
  87                                                    cursor,
  88                                                    mc_heap_ignore_region_t);
  89     if (region->address == address) {
  90       ignore_found = 1;
  91       break;
  92     } else if (region->address < address) {
  93       start = cursor + 1;
  94     } else {
  95       if ((char *) region->address <= ((char *) address + size)) {
  96         ignore_found = 1;
  97         break;
  98       } else {
  99         end = cursor - 1;
 100       }
 101     }
 102   }
 103
 104   if (ignore_found == 1) {
 105     xbt_dynar_remove_at(mc_heap_comparison_ignore, cursor, NULL);
 106     MC_remove_ignore_heap(address, size);
 107   }
 108 }
 109
 110 // ***** Ignore global variables
 111
 112 void MCer_ignore_global_variable(const char *name)
 113 {
 114   mc_process_t process = &mc_model_checker->process();
 115   xbt_assert(process->object_infos, "MC subsystem not initialized");
 116
 117   size_t n = process->object_infos_size;
 118   for (size_t i=0; i!=n; ++i) {
 119     mc_object_info_t info = process->object_infos[i];
 120
 121     // Binary search:
 122     int start = 0;
 123     int end = xbt_dynar_length(info->global_variables) - 1;
 124     while (start <= end) {
 125       unsigned int cursor = (start + end) / 2;
 126       dw_variable_t current_var =
 127           (dw_variable_t) xbt_dynar_get_as(info->global_variables,
 128                                            cursor, dw_variable_t);
 129       if (strcmp(current_var->name, name) == 0) {
 130         xbt_dynar_remove_at(info->global_variables, cursor, NULL);
 131         start = 0;
 132         end = xbt_dynar_length(info->global_variables) - 1;
 133       } else if (strcmp(current_var->name, name) < 0) {
 134         start = cursor + 1;
 135       } else {
 136         end = cursor - 1;
 137       }
 138     }
 139   }
 140 }
 141
 142 // ***** Ignore local variables
 143
 144 static void mc_ignore_local_variable_in_scope(const char *var_name,
 145                                               const char *subprogram_name,
 146                                               dw_frame_t subprogram,
 147                                               dw_frame_t scope);
 148 static void MC_ignore_local_variable_in_object(const char *var_name,
 149                                                const char *subprogram_name,
 150                                                mc_object_info_t info);
 151
 152 void MC_ignore_local_variable(const char *var_name, const char *frame_name)
 153 {
 154   mc_process_t process = &mc_model_checker->process();
 155   if (strcmp(frame_name, "*") == 0)
 156     frame_name = NULL;
 157
 158   size_t n = process->object_infos_size;
 159   size_t i;
 160   for (i=0; i!=n; ++i) {
 161     MC_ignore_local_variable_in_object(var_name, frame_name, process->object_infos[i]);
 162   }
 163 }
 164
 165 static void MC_ignore_local_variable_in_object(const char *var_name,
 166                                                const char *subprogram_name,
 167                                                mc_object_info_t info)
 168 {
 169   xbt_dict_cursor_t cursor2;
 170   dw_frame_t frame;
 171   char *key;
 172   xbt_dict_foreach(info->subprograms, cursor2, key, frame) {
 173     mc_ignore_local_variable_in_scope(var_name, subprogram_name, frame, frame);
 174   }
 175 }
 176
 177 /** \brief Ignore a local variable in a scope
 178  *
 179  *  Ignore all instances of variables with a given name in
 180  *  any (possibly inlined) subprogram with a given namespaced
 181  *  name.
 182  *
 183  *  \param var_name        Name of the local variable (or parameter to ignore)
 184  *  \param subprogram_name Name of the subprogram fo ignore (NULL for any)
 185  *  \param subprogram      (possibly inlined) Subprogram of the scope
 186  *  \param scope           Current scope
 187  */
 188 static void mc_ignore_local_variable_in_scope(const char *var_name,
 189                                               const char *subprogram_name,
 190                                               dw_frame_t subprogram,
 191                                               dw_frame_t scope)
 192 {
 193   // Processing of direct variables:
 194
 195   // If the current subprogram matches the given name:
 196   if (!subprogram_name ||
 197       (subprogram->name && strcmp(subprogram_name, subprogram->name) == 0)) {
 198
 199     // Try to find the variable and remove it:
 200     int start = 0;
 201     int end = xbt_dynar_length(scope->variables) - 1;
 202
 203     // Dichotomic search:
 204     while (start <= end) {
 205       int cursor = (start + end) / 2;
 206       dw_variable_t current_var =
 207           (dw_variable_t) xbt_dynar_get_as(scope->variables, cursor,
 208                                            dw_variable_t);
 209
 210       int compare = strcmp(current_var->name, var_name);
 211       if (compare == 0) {
 212         // Variable found, remove it:
 213         xbt_dynar_remove_at(scope->variables, cursor, NULL);
 214
 215         // and start again:
 216         start = 0;
 217         end = xbt_dynar_length(scope->variables) - 1;
 218       } else if (compare < 0) {
 219         start = cursor + 1;
 220       } else {
 221         end = cursor - 1;
 222       }
 223     }
 224
 225   }
 226   // And recursive processing in nested scopes:
 227   unsigned cursor = 0;
 228   dw_frame_t nested_scope = NULL;
 229   xbt_dynar_foreach(scope->scopes, cursor, nested_scope) {
 230     // The new scope may be an inlined subroutine, in this case we want to use its
 231     // namespaced name in recursive calls:
 232     dw_frame_t nested_subprogram =
 233         nested_scope->tag ==
 234         DW_TAG_inlined_subroutine ? nested_scope : subprogram;
 235
 236     mc_ignore_local_variable_in_scope(var_name, subprogram_name,
 237                                       nested_subprogram, nested_scope);
 238   }
 239 }
 240
 241 extern xbt_dynar_t stacks_areas;
 242
 243 void MC_stack_area_add(stack_region_t stack_area)
 244 {
 245   if (stacks_areas == NULL)
 246     stacks_areas = xbt_dynar_new(sizeof(stack_region_t), NULL);
 247   xbt_dynar_push(stacks_areas, &stack_area);
 248 }
 249
 250 }