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.empty(), "MC subsystem not initialized");
 116
 117   for (std::shared_ptr<s_mc_object_info_t> const& info : process->object_infos) {
 118
 119     // Binary search:
 120     int start = 0;
 121     int end = xbt_dynar_length(info->global_variables) - 1;
 122     while (start <= end) {
 123       unsigned int cursor = (start + end) / 2;
 124       mc_variable_t current_var =
 125           (mc_variable_t) xbt_dynar_get_as(info->global_variables,
 126                                            cursor, mc_variable_t);
 127       int cmp = strcmp(current_var->name.c_str(), name);
 128       if (cmp == 0) {
 129         xbt_dynar_remove_at(info->global_variables, cursor, NULL);
 130         start = 0;
 131         end = xbt_dynar_length(info->global_variables) - 1;
 132       } else if (cmp < 0) {
 133         start = cursor + 1;
 134       } else {
 135         end = cursor - 1;
 136       }
 137     }
 138   }
 139 }
 140
 141 // ***** Ignore local variables
 142
 143 static void mc_ignore_local_variable_in_scope(const char *var_name,
 144                                               const char *subprogram_name,
 145                                               dw_frame_t subprogram,
 146                                               dw_frame_t scope);
 147 static void MC_ignore_local_variable_in_object(const char *var_name,
 148                                                const char *subprogram_name,
 149                                                mc_object_info_t info);
 150
 151 void MC_ignore_local_variable(const char *var_name, const char *frame_name)
 152 {
 153   mc_process_t process = &mc_model_checker->process();
 154   if (strcmp(frame_name, "*") == 0)
 155     frame_name = NULL;
 156
 157   for (std::shared_ptr<s_mc_object_info_t> const& info : process->object_infos)
 158     MC_ignore_local_variable_in_object(var_name, frame_name, info.get());
 159 }
 160
 161 static void MC_ignore_local_variable_in_object(const char *var_name,
 162                                                const char *subprogram_name,
 163                                                mc_object_info_t info)
 164 {
 165   xbt_dict_cursor_t cursor2;
 166   dw_frame_t frame;
 167   char *key;
 168   xbt_dict_foreach(info->subprograms, cursor2, key, frame) {
 169     mc_ignore_local_variable_in_scope(var_name, subprogram_name, frame, frame);
 170   }
 171 }
 172
 173 /** \brief Ignore a local variable in a scope
 174  *
 175  *  Ignore all instances of variables with a given name in
 176  *  any (possibly inlined) subprogram with a given namespaced
 177  *  name.
 178  *
 179  *  \param var_name        Name of the local variable (or parameter to ignore)
 180  *  \param subprogram_name Name of the subprogram fo ignore (NULL for any)
 181  *  \param subprogram      (possibly inlined) Subprogram of the scope
 182  *  \param scope           Current scope
 183  */
 184 static void mc_ignore_local_variable_in_scope(const char *var_name,
 185                                               const char *subprogram_name,
 186                                               dw_frame_t subprogram,
 187                                               dw_frame_t scope)
 188 {
 189   // Processing of direct variables:
 190
 191   // If the current subprogram matches the given name:
 192   if (!subprogram_name ||
 193       (subprogram->name && strcmp(subprogram_name, subprogram->name) == 0)) {
 194
 195     // Try to find the variable and remove it:
 196     int start = 0;
 197     int end = xbt_dynar_length(scope->variables) - 1;
 198
 199     // Dichotomic search:
 200     while (start <= end) {
 201       int cursor = (start + end) / 2;
 202       mc_variable_t current_var =
 203           (mc_variable_t) xbt_dynar_get_as(scope->variables, cursor,
 204                                            mc_variable_t);
 205
 206       int compare = strcmp(current_var->name.c_str(), var_name);
 207       if (compare == 0) {
 208         // Variable found, remove it:
 209         xbt_dynar_remove_at(scope->variables, cursor, NULL);
 210
 211         // and start again:
 212         start = 0;
 213         end = xbt_dynar_length(scope->variables) - 1;
 214       } else if (compare < 0) {
 215         start = cursor + 1;
 216       } else {
 217         end = cursor - 1;
 218       }
 219     }
 220
 221   }
 222   // And recursive processing in nested scopes:
 223   unsigned cursor = 0;
 224   dw_frame_t nested_scope = NULL;
 225   xbt_dynar_foreach(scope->scopes, cursor, nested_scope) {
 226     // The new scope may be an inlined subroutine, in this case we want to use its
 227     // namespaced name in recursive calls:
 228     dw_frame_t nested_subprogram =
 229         nested_scope->tag ==
 230         DW_TAG_inlined_subroutine ? nested_scope : subprogram;
 231
 232     mc_ignore_local_variable_in_scope(var_name, subprogram_name,
 233                                       nested_subprogram, nested_scope);
 234   }
 235 }
 236
 237 extern xbt_dynar_t stacks_areas;
 238
 239 void MC_stack_area_add(stack_region_t stack_area)
 240 {
 241   if (stacks_areas == NULL)
 242     stacks_areas = xbt_dynar_new(sizeof(stack_region_t), NULL);
 243   xbt_dynar_push(stacks_areas, &stack_area);
 244 }
 245
 246 }