src/mc/mc_ignore.c

   1 /* Copyright (c) 2008-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 "internal_config.h"
   8 #include "mc_object_info.h"
   9 #include "mc_private.h"
  10 #include "smpi/private.h"
  11 #include "mc/mc_snapshot.h"
  12 #include "mc_ignore.h"
  13 #include "mc_protocol.h"
  14 #include "mc_client.h"
  15
  16 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_ignore, mc,
  17                                 "Logging specific to MC ignore mechanism");
  18
  19
  20 /**************************** Global variables ******************************/
  21 // Those structures live with the MCer and should be moved in the model_checker
  22 // structure but they are currently used before the MC initialisation
  23 // (in standalone mode).
  24
  25 extern xbt_dynar_t mc_heap_comparison_ignore;
  26 extern xbt_dynar_t stacks_areas;
  27
  28 /**************************** Structures ******************************/
  29 typedef struct s_mc_stack_ignore_variable {
  30   char *var_name;
  31   char *frame;
  32 } s_mc_stack_ignore_variable_t, *mc_stack_ignore_variable_t;
  33
  34 /**************************** Free functions ******************************/
  35
  36 static void stack_ignore_variable_free(mc_stack_ignore_variable_t v)
  37 {
  38   xbt_free(v->var_name);
  39   xbt_free(v->frame);
  40   xbt_free(v);
  41 }
  42
  43 static void stack_ignore_variable_free_voidp(void *v)
  44 {
  45   stack_ignore_variable_free((mc_stack_ignore_variable_t) * (void **) v);
  46 }
  47
  48 void heap_ignore_region_free(mc_heap_ignore_region_t r)
  49 {
  50   xbt_free(r);
  51 }
  52
  53 void heap_ignore_region_free_voidp(void *r)
  54 {
  55   heap_ignore_region_free((mc_heap_ignore_region_t) * (void **) r);
  56 }
  57
  58 static void checkpoint_ignore_region_free(mc_checkpoint_ignore_region_t r)
  59 {
  60   xbt_free(r);
  61 }
  62
  63 static void checkpoint_ignore_region_free_voidp(void *r)
  64 {
  65   checkpoint_ignore_region_free((mc_checkpoint_ignore_region_t) * (void **) r);
  66 }
  67
  68 xbt_dynar_t MC_checkpoint_ignore_new(void)
  69 {
  70   return xbt_dynar_new(sizeof(mc_checkpoint_ignore_region_t),
  71                         checkpoint_ignore_region_free_voidp);
  72 }
  73
  74 /***********************************************************************/
  75
  76 // Mcer
  77 void MC_heap_region_ignore_insert(mc_heap_ignore_region_t region)
  78 {
  79   if (mc_heap_comparison_ignore == NULL) {
  80     mc_heap_comparison_ignore =
  81         xbt_dynar_new(sizeof(mc_heap_ignore_region_t),
  82                       heap_ignore_region_free_voidp);
  83     xbt_dynar_push(mc_heap_comparison_ignore, &region);
  84     return;
  85   }
  86
  87   unsigned int cursor = 0;
  88   mc_heap_ignore_region_t current_region = NULL;
  89   int start = 0;
  90   int end = xbt_dynar_length(mc_heap_comparison_ignore) - 1;
  91
  92   // Find the position where we want to insert the mc_heap_ignore_region_t:
  93   while (start <= end) {
  94     cursor = (start + end) / 2;
  95     current_region =
  96         (mc_heap_ignore_region_t) xbt_dynar_get_as(mc_heap_comparison_ignore,
  97                                                    cursor,
  98                                                    mc_heap_ignore_region_t);
  99     if (current_region->address == region->address) {
 100       heap_ignore_region_free(region);
 101       return;
 102     } else if (current_region->address < region->address) {
 103       start = cursor + 1;
 104     } else {
 105       end = cursor - 1;
 106     }
 107   }
 108
 109   // Insert it mc_heap_ignore_region_t:
 110   if (current_region->address < region->address)
 111     xbt_dynar_insert_at(mc_heap_comparison_ignore, cursor + 1, &region);
 112   else
 113     xbt_dynar_insert_at(mc_heap_comparison_ignore, cursor, &region);
 114 }
 115
 116 // MCed:
 117 static void MC_heap_region_ignore_send(mc_heap_ignore_region_t region)
 118 {
 119   s_mc_ignore_heap_message_t message;
 120   message.type = MC_MESSAGE_IGNORE_HEAP;
 121   message.region = *region;
 122   if (MC_protocol_send(mc_client->fd, &message, sizeof(message)))
 123     xbt_die("Could not send ignored region to MCer");
 124 }
 125
 126 // MCed:
 127 void MC_ignore_heap(void *address, size_t size)
 128 {
 129   xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
 130
 131   mc_heap_ignore_region_t region = xbt_new0(s_mc_heap_ignore_region_t, 1);
 132   region->address = address;
 133   region->size = size;
 134
 135   region->block =
 136       ((char *) address -
 137        (char *) std_heap->heapbase) / BLOCKSIZE + 1;
 138
 139   if (std_heap->heapinfo[region->block].type == 0) {
 140     region->fragment = -1;
 141     std_heap->heapinfo[region->block].busy_block.ignore++;
 142   } else {
 143     region->fragment =
 144         ((uintptr_t) (ADDR2UINT(address) % (BLOCKSIZE))) >> std_heap->
 145         heapinfo[region->block].type;
 146     std_heap->heapinfo[region->block].busy_frag.ignore[region->fragment]++;
 147   }
 148
 149   MC_heap_region_ignore_insert(region);
 150
 151 #if 1
 152   if (mc_mode == MC_MODE_CLIENT)
 153     MC_heap_region_ignore_send(region);
 154 #endif
 155   mmalloc_set_current_heap(heap);
 156 }
 157
 158 void MC_remove_ignore_heap(void *address, size_t size)
 159 {
 160   if (mc_mode == MC_MODE_CLIENT) {
 161     s_mc_ignore_memory_message_t message;
 162     message.type = MC_MESSAGE_UNIGNORE_HEAP;
 163     message.addr = address;
 164     message.size = size;
 165     MC_client_send_message(&message, sizeof(message));
 166   }
 167
 168   xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
 169
 170   unsigned int cursor = 0;
 171   int start = 0;
 172   int end = xbt_dynar_length(mc_heap_comparison_ignore) - 1;
 173   mc_heap_ignore_region_t region;
 174   int ignore_found = 0;
 175
 176   while (start <= end) {
 177     cursor = (start + end) / 2;
 178     region =
 179         (mc_heap_ignore_region_t) xbt_dynar_get_as(mc_heap_comparison_ignore,
 180                                                    cursor,
 181                                                    mc_heap_ignore_region_t);
 182     if (region->address == address) {
 183       ignore_found = 1;
 184       break;
 185     } else if (region->address < address) {
 186       start = cursor + 1;
 187     } else {
 188       if ((char *) region->address <= ((char *) address + size)) {
 189         ignore_found = 1;
 190         break;
 191       } else {
 192         end = cursor - 1;
 193       }
 194     }
 195   }
 196
 197   if (ignore_found == 1) {
 198     xbt_dynar_remove_at(mc_heap_comparison_ignore, cursor, NULL);
 199     MC_remove_ignore_heap(address, size);
 200   }
 201   mmalloc_set_current_heap(heap);
 202 }
 203
 204 // MCer
 205 void MC_ignore_global_variable(const char *name)
 206 {
 207   mc_process_t process = &mc_model_checker->process;
 208   xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
 209   xbt_assert(process->object_infos, "MC subsystem not initialized");
 210
 211   size_t n = process->object_infos_size;
 212   for (size_t i=0; i!=n; ++i) {
 213     mc_object_info_t info = process->object_infos[i];
 214
 215     // Binary search:
 216     int start = 0;
 217     int end = xbt_dynar_length(info->global_variables) - 1;
 218     while (start <= end) {
 219       unsigned int cursor = (start + end) / 2;
 220       dw_variable_t current_var =
 221           (dw_variable_t) xbt_dynar_get_as(info->global_variables,
 222                                            cursor, dw_variable_t);
 223       if (strcmp(current_var->name, name) == 0) {
 224         xbt_dynar_remove_at(info->global_variables, cursor, NULL);
 225         start = 0;
 226         end = xbt_dynar_length(info->global_variables) - 1;
 227       } else if (strcmp(current_var->name, name) < 0) {
 228         start = cursor + 1;
 229       } else {
 230         end = cursor - 1;
 231       }
 232     }
 233   }
 234   mmalloc_set_current_heap(heap);
 235 }
 236
 237 /** \brief Ignore a local variable in a scope
 238  *
 239  *  Ignore all instances of variables with a given name in
 240  *  any (possibly inlined) subprogram with a given namespaced
 241  *  name.
 242  *
 243  *  \param var_name        Name of the local variable (or parameter to ignore)
 244  *  \param subprogram_name Name of the subprogram fo ignore (NULL for any)
 245  *  \param subprogram      (possibly inlined) Subprogram of the scope
 246  *  \param scope           Current scope
 247  */
 248 static void mc_ignore_local_variable_in_scope(const char *var_name,
 249                                               const char *subprogram_name,
 250                                               dw_frame_t subprogram,
 251                                               dw_frame_t scope)
 252 {
 253   // Processing of direct variables:
 254
 255   // If the current subprogram matches the given name:
 256   if (!subprogram_name ||
 257       (subprogram->name && strcmp(subprogram_name, subprogram->name) == 0)) {
 258
 259     // Try to find the variable and remove it:
 260     int start = 0;
 261     int end = xbt_dynar_length(scope->variables) - 1;
 262
 263     // Dichotomic search:
 264     while (start <= end) {
 265       int cursor = (start + end) / 2;
 266       dw_variable_t current_var =
 267           (dw_variable_t) xbt_dynar_get_as(scope->variables, cursor,
 268                                            dw_variable_t);
 269
 270       int compare = strcmp(current_var->name, var_name);
 271       if (compare == 0) {
 272         // Variable found, remove it:
 273         xbt_dynar_remove_at(scope->variables, cursor, NULL);
 274
 275         // and start again:
 276         start = 0;
 277         end = xbt_dynar_length(scope->variables) - 1;
 278       } else if (compare < 0) {
 279         start = cursor + 1;
 280       } else {
 281         end = cursor - 1;
 282       }
 283     }
 284
 285   }
 286   // And recursive processing in nested scopes:
 287   unsigned cursor = 0;
 288   dw_frame_t nested_scope = NULL;
 289   xbt_dynar_foreach(scope->scopes, cursor, nested_scope) {
 290     // The new scope may be an inlined subroutine, in this case we want to use its
 291     // namespaced name in recursive calls:
 292     dw_frame_t nested_subprogram =
 293         nested_scope->tag ==
 294         DW_TAG_inlined_subroutine ? nested_scope : subprogram;
 295
 296     mc_ignore_local_variable_in_scope(var_name, subprogram_name,
 297                                       nested_subprogram, nested_scope);
 298   }
 299 }
 300
 301 static void MC_ignore_local_variable_in_object(const char *var_name,
 302                                                const char *subprogram_name,
 303                                                mc_object_info_t info)
 304 {
 305   xbt_dict_cursor_t cursor2;
 306   dw_frame_t frame;
 307   char *key;
 308   xbt_dict_foreach(info->subprograms, cursor2, key, frame) {
 309     mc_ignore_local_variable_in_scope(var_name, subprogram_name, frame, frame);
 310   }
 311 }
 312
 313 // MCer
 314 void MC_ignore_local_variable(const char *var_name, const char *frame_name)
 315 {
 316   mc_process_t process = &mc_model_checker->process;
 317   if (strcmp(frame_name, "*") == 0)
 318     frame_name = NULL;
 319   xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
 320
 321   size_t n = process->object_infos_size;
 322   size_t i;
 323   for (i=0; i!=n; ++i) {
 324     MC_ignore_local_variable_in_object(var_name, frame_name, process->object_infos[i]);
 325   }
 326
 327   mmalloc_set_current_heap(heap);
 328 }
 329
 330 void MC_stack_area_add(stack_region_t stack_area)
 331 {
 332   if (stacks_areas == NULL)
 333     stacks_areas = xbt_dynar_new(sizeof(stack_region_t), NULL);
 334   xbt_dynar_push(stacks_areas, &stack_area);
 335 }
 336
 337 /** @brief Register a stack in the model checker
 338  *
 339  *  The stacks are allocated in the heap. The MC handle them especially
 340  *  when we analyse/compare the content of the heap so it must be told where
 341  *  they are with this function.
 342  *
 343  *  @param stack
 344  *  @param process Process owning the stack
 345  *  @param context
 346  *  @param size    Size of the stack
 347  */
 348 void MC_new_stack_area(void *stack, smx_process_t process, void *context, size_t size)
 349 {
 350   xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
 351
 352   stack_region_t region = xbt_new0(s_stack_region_t, 1);
 353   region->address = stack;
 354   region->context = context;
 355   region->size = size;
 356   region->block =
 357       ((char *) stack -
 358        (char *) std_heap->heapbase) / BLOCKSIZE + 1;
 359 #ifdef HAVE_SMPI
 360   if (smpi_privatize_global_variables && process) {
 361     region->process_index = smpi_process_index_of_smx_process(process);
 362   } else
 363 #endif
 364   region->process_index = -1;
 365
 366   if (mc_mode == MC_MODE_CLIENT) {
 367     s_mc_stack_region_message_t message;
 368     message.type = MC_MESSAGE_STACK_REGION;
 369     message.stack_region = *region;
 370     MC_client_send_message(&message, sizeof(message));
 371   }
 372
 373   MC_stack_area_add(region);
 374
 375   mmalloc_set_current_heap(heap);
 376 }
 377
 378 void MC_process_ignore_memory(mc_process_t process, void *addr, size_t size)
 379 {
 380   xbt_dynar_t checkpoint_ignore = process->checkpoint_ignore;
 381   mc_checkpoint_ignore_region_t region =
 382       xbt_new0(s_mc_checkpoint_ignore_region_t, 1);
 383   region->addr = addr;
 384   region->size = size;
 385
 386   if (xbt_dynar_is_empty(checkpoint_ignore)) {
 387     xbt_dynar_push(checkpoint_ignore, &region);
 388   } else {
 389
 390     unsigned int cursor = 0;
 391     int start = 0;
 392     int end = xbt_dynar_length(checkpoint_ignore) - 1;
 393     mc_checkpoint_ignore_region_t current_region = NULL;
 394
 395     while (start <= end) {
 396       cursor = (start + end) / 2;
 397       current_region =
 398           (mc_checkpoint_ignore_region_t) xbt_dynar_get_as(checkpoint_ignore,
 399                                                            cursor,
 400                                                            mc_checkpoint_ignore_region_t);
 401       if (current_region->addr == addr) {
 402         if (current_region->size == size) {
 403           checkpoint_ignore_region_free(region);
 404           return;
 405         } else if (current_region->size < size) {
 406           start = cursor + 1;
 407         } else {
 408           end = cursor - 1;
 409         }
 410       } else if (current_region->addr < addr) {
 411         start = cursor + 1;
 412       } else {
 413         end = cursor - 1;
 414       }
 415     }
 416
 417     if (current_region->addr == addr) {
 418       if (current_region->size < size) {
 419         xbt_dynar_insert_at(checkpoint_ignore, cursor + 1, &region);
 420       } else {
 421         xbt_dynar_insert_at(checkpoint_ignore, cursor, &region);
 422       }
 423     } else if (current_region->addr < addr) {
 424       xbt_dynar_insert_at(checkpoint_ignore, cursor + 1, &region);
 425     } else {
 426       xbt_dynar_insert_at(checkpoint_ignore, cursor, &region);
 427     }
 428   }
 429 }