[mc] Remove the dual heap mc_heap/std_heap

diff --git a/src/mc/mc_diff.cpp b/src/mc/mc_diff.cpp
index b8fc44c..abeaf9c 100644 (file)
--- a/src/mc/mc_diff.cpp
+++ b/src/mc/mc_diff.cpp
@@ -87,8 +87,6 @@ static void mmalloc_backtrace_display(void *addr)
   /* size_t block, frag_nb; */
   /* int type; */
 
-  /* xbt_mheap_t heap = __mmalloc_current_heap ?: (xbt_mheap_t) mmalloc_preinit(); */
-
   /* block = (((char*) (addr) - (char*) heap -> heapbase) / BLOCKSIZE + 1); */
 
   /* type = heap->heapinfo[block].type; */

diff --git a/src/mc/mc_global.cpp b/src/mc/mc_global.cpp
index 3565626..3b6f904 100644 (file)
--- a/src/mc/mc_global.cpp
+++ b/src/mc/mc_global.cpp
@@ -232,8 +232,6 @@ int MC_deadlock_check()
  */
 void MC_replay(xbt_fifo_t stack)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
   int value, count = 1;
   char *req_str;
   smx_simcall_t req = NULL, saved_req = NULL;
@@ -250,7 +248,6 @@ void MC_replay(xbt_fifo_t stack)
       MC_restore_snapshot(state->system_state);
       if(_sg_mc_comms_determinism || _sg_mc_send_determinism) 
         MC_restore_communications_pattern(state);
-      mmalloc_set_current_heap(std_heap);
       return;
     }
   }
@@ -260,11 +257,8 @@ void MC_replay(xbt_fifo_t stack)
   MC_restore_snapshot(initial_global_state->snapshot);
   /* At the moment of taking the snapshot the raw heap was set, so restoring
    * it will set it back again, we have to unset it to continue  */
-  mmalloc_set_current_heap(std_heap);
 
   start_item = xbt_fifo_get_last_item(stack);
-  
-  mmalloc_set_current_heap(mc_heap);
 
   if (_sg_mc_comms_determinism || _sg_mc_send_determinism) {
     // int n = xbt_dynar_length(incomplete_communications_pattern);
@@ -277,8 +271,6 @@ void MC_replay(xbt_fifo_t stack)
     }
   }
 
-  mmalloc_set_current_heap(std_heap);
-
   /* Traverse the stack from the state at position start and re-execute the transitions */
   for (item = start_item;
        item != xbt_fifo_get_first_item(stack);
@@ -308,10 +300,8 @@ void MC_replay(xbt_fifo_t stack)
 
       MC_simcall_handle(req, value);
 
-      mmalloc_set_current_heap(mc_heap);
       if (_sg_mc_comms_determinism || _sg_mc_send_determinism)
         MC_handle_comm_pattern(call, req, value, NULL, 1);
-      mmalloc_set_current_heap(std_heap);
 
       MC_wait_for_requests();
 
@@ -325,14 +315,10 @@ void MC_replay(xbt_fifo_t stack)
   }
 
   XBT_DEBUG("**** End Replay ****");
-  mmalloc_set_current_heap(heap);
 }
 
 void MC_replay_liveness(xbt_fifo_t stack)
 {
-
-  initial_global_state->raw_mem_set = (mmalloc_get_current_heap() == mc_heap);
-
   xbt_fifo_item_t item;
   mc_pair_t pair = NULL;
   mc_state_t state = NULL;
@@ -348,7 +334,6 @@ void MC_replay_liveness(xbt_fifo_t stack)
     pair = (mc_pair_t) xbt_fifo_get_item_content(item);
     if(pair->graph_state->system_state){
       MC_restore_snapshot(pair->graph_state->system_state);
-      mmalloc_set_current_heap(std_heap);
       return;
     }
   }
@@ -356,11 +341,6 @@ void MC_replay_liveness(xbt_fifo_t stack)
   /* Restore the initial state */
   MC_restore_snapshot(initial_global_state->snapshot);
 
-  /* At the moment of taking the snapshot the raw heap was set, so restoring
-   * it will set it back again, we have to unset it to continue  */
-  if (!initial_global_state->raw_mem_set)
-    mmalloc_set_current_heap(std_heap);
-
     /* Traverse the stack from the initial state and re-execute the transitions */
     for (item = xbt_fifo_get_last_item(stack);
          item != xbt_fifo_get_first_item(stack);
@@ -402,12 +382,6 @@ void MC_replay_liveness(xbt_fifo_t stack)
     }
 
   XBT_DEBUG("**** End Replay ****");
-
-  if (initial_global_state->raw_mem_set)
-    mmalloc_set_current_heap(mc_heap);
-  else
-    mmalloc_set_current_heap(std_heap);
-
 }
 
 /**
@@ -417,23 +391,17 @@ void MC_replay_liveness(xbt_fifo_t stack)
  */
 void MC_dump_stack_safety(xbt_fifo_t stack)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
   MC_show_stack_safety(stack);
   
   mc_state_t state;
-  
-  mmalloc_set_current_heap(mc_heap);
+
   while ((state = (mc_state_t) xbt_fifo_pop(stack)) != NULL)
     MC_state_delete(state, !state->in_visited_states ? 1 : 0);
-  mmalloc_set_current_heap(heap);
 }
 
 
 void MC_show_stack_safety(xbt_fifo_t stack)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
   int value;
   mc_state_t state;
   xbt_fifo_item_t item;
@@ -450,8 +418,6 @@ void MC_show_stack_safety(xbt_fifo_t stack)
       xbt_free(req_str);
     }
   }
-
-  mmalloc_set_current_heap(heap);
 }
 
 void MC_show_deadlock(smx_simcall_t req)
@@ -502,11 +468,9 @@ void MC_show_stack_liveness(xbt_fifo_t stack)
 
 void MC_dump_stack_liveness(xbt_fifo_t stack)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
   mc_pair_t pair;
   while ((pair = (mc_pair_t) xbt_fifo_pop(stack)) != NULL)
     MC_pair_delete(pair);
-  mmalloc_set_current_heap(heap);
 }
 
 void MC_print_statistics(mc_stats_t stats)
@@ -533,7 +497,6 @@ void MC_print_statistics(mc_stats_t stats)
     XBT_INFO("Visited pairs = %lu", stats->visited_pairs);
   }
   XBT_INFO("Executed transitions = %lu", stats->executed_transitions);
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
   if ((_sg_mc_dot_output_file != NULL) && (_sg_mc_dot_output_file[0] != '\0')) {
     fprintf(dot_output, "}\n");
     fclose(dot_output);
@@ -543,18 +506,14 @@ void MC_print_statistics(mc_stats_t stats)
     if (_sg_mc_comms_determinism)
       XBT_INFO("Recv-deterministic : %s", !initial_global_state->recv_deterministic ? "No" : "Yes");
   }
-  mmalloc_set_current_heap(heap);
 }
 
 void MC_automaton_load(const char *file)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
   if (_mc_property_automaton == NULL)
     _mc_property_automaton = xbt_automaton_new();
 
   xbt_automaton_load(_mc_property_automaton, file);
-  mmalloc_set_current_heap(heap);
 }
 
 static void register_symbol(xbt_automaton_propositional_symbol_t symbol)
@@ -574,44 +533,35 @@ static void register_symbol(xbt_automaton_propositional_symbol_t symbol)
 
 void MC_automaton_new_propositional_symbol(const char *id, int(*fct)(void))
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
   if (_mc_property_automaton == NULL)
     _mc_property_automaton = xbt_automaton_new();
 
   xbt_automaton_propositional_symbol_t symbol = xbt_automaton_propositional_symbol_new(_mc_property_automaton, id, fct);
   register_symbol(symbol);
-  mmalloc_set_current_heap(heap);
 }
 
 void MC_automaton_new_propositional_symbol_pointer(const char *id, int* value)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
   if (_mc_property_automaton == NULL)
     _mc_property_automaton = xbt_automaton_new();
   xbt_automaton_propositional_symbol_t symbol = xbt_automaton_propositional_symbol_new_pointer(_mc_property_automaton, id, value);
   register_symbol(symbol);
-  mmalloc_set_current_heap(heap);
 }
 
 void MC_automaton_new_propositional_symbol_callback(const char* id,
   xbt_automaton_propositional_symbol_callback_type callback,
   void* data, xbt_automaton_propositional_symbol_free_function_type free_function)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
   if (_mc_property_automaton == NULL)
     _mc_property_automaton = xbt_automaton_new();
   xbt_automaton_propositional_symbol_t symbol = xbt_automaton_propositional_symbol_new_callback(
     _mc_property_automaton, id, callback, data, free_function);
   register_symbol(symbol);
-  mmalloc_set_current_heap(heap);
 }
 
 // TODO, fix cross-process access (this function is not used)
 void MC_dump_stacks(FILE* file)
 {
-  xbt_mheap_t heap = mmalloc_set_current_heap(mc_heap);
-
   int nstack = 0;
   stack_region_t current_stack;
   unsigned cursor;
@@ -641,7 +591,6 @@ void MC_dump_stacks(FILE* file)
 
     ++nstack;
   }
-  mmalloc_set_current_heap(heap);
 }
 #endif
 

diff --git a/src/mc/mc_ignore.cpp b/src/mc/mc_ignore.cpp
index 250c9e4..f1ac12e 100644 (file)
--- a/src/mc/mc_ignore.cpp
+++ b/src/mc/mc_ignore.cpp
@@ -25,21 +25,23 @@ void MC_ignore_heap(void *address, size_t size)
   if (mc_mode != MC_MODE_CLIENT)
     return;
 
+  xbt_mheap_t heap = mmalloc_get_current_heap();
+
   s_mc_heap_ignore_region_t region;
   memset(&region, 0, sizeof(region));
   region.address = address;
   region.size = size;
   region.block =
    ((char *) address -
-    (char *) std_heap->heapbase) / BLOCKSIZE + 1;
-  if (std_heap->heapinfo[region.block].type == 0) {
+    (char *) heap->heapbase) / BLOCKSIZE + 1;
+  if (heap->heapinfo[region.block].type == 0) {
     region.fragment = -1;
-    std_heap->heapinfo[region.block].busy_block.ignore++;
+    heap->heapinfo[region.block].busy_block.ignore++;
   } else {
     region.fragment =
-        ((uintptr_t) (ADDR2UINT(address) % (BLOCKSIZE))) >> std_heap->
-        heapinfo[region.block].type;
-    std_heap->heapinfo[region.block].busy_frag.ignore[region.fragment]++;
+        ((uintptr_t) (ADDR2UINT(address) % (BLOCKSIZE))) >>
+        heap->heapinfo[region.block].type;
+    heap->heapinfo[region.block].busy_frag.ignore[region.fragment]++;
   }
 
   s_mc_ignore_heap_message_t message;
@@ -83,6 +85,8 @@ void MC_register_stack_area(void *stack, smx_process_t process, void *context, s
   if (mc_mode != MC_MODE_CLIENT)
     return;
 
+  xbt_mheap_t heap = mmalloc_get_current_heap();
+
   s_stack_region_t region;
   memset(&region, 0, sizeof(region));
   region.address = stack;
@@ -90,7 +94,7 @@ void MC_register_stack_area(void *stack, smx_process_t process, void *context, s
   region.size = size;
   region.block =
       ((char *) stack -
-       (char *) std_heap->heapbase) / BLOCKSIZE + 1;
+       (char *) heap->heapbase) / BLOCKSIZE + 1;
 #ifdef HAVE_SMPI
   if (smpi_privatize_global_variables && process) {
     region.process_index = smpi_process_index_of_smx_process(process);

diff --git a/src/mc/mc_liveness.cpp b/src/mc/mc_liveness.cpp
index b7cc85d..0a46c4a 100644 (file)
--- a/src/mc/mc_liveness.cpp
+++ b/src/mc/mc_liveness.cpp
@@ -170,8 +170,6 @@ static void MC_modelcheck_liveness_main(void);
 
 static void MC_pre_modelcheck_liveness(void)
 {
-  initial_global_state->raw_mem_set = (mmalloc_get_current_heap() == mc_heap);
-
   mc_pair_t initial_pair = NULL;
   smx_process_t process;
 

diff --git a/src/mc/mc_memory.cpp b/src/mc/mc_memory.cpp
index 6f83983..fde3cd6 100644 (file)
--- a/src/mc/mc_memory.cpp
+++ b/src/mc/mc_memory.cpp
@@ -20,10 +20,6 @@ extern "C" {
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_memory, mc,
                                 "Logging specific to MC (memory)");
 
-/* Pointers to each of the heap regions to use */
-xbt_mheap_t std_heap = NULL;          /* memory erased each time the MC stuff rollbacks to the beginning. Almost everything goes here */
-xbt_mheap_t mc_heap = NULL;           /* memory persistent over the MC rollbacks. Only MC stuff should go there */
-
 /* Initialize the model-checker memory subsystem */
 /* It creates the two heap regions: std_heap and mc_heap */
 void MC_memory_init()
@@ -31,25 +27,12 @@ void MC_memory_init()
   if (!malloc_use_mmalloc()) {
     xbt_die("Model-checking support is not enabled: run with simgrid-mc.");
   }
-
-  /* Create the first region HEAP_OFFSET bytes after the heap break address */
-  std_heap = mmalloc_get_default_md();
-  xbt_assert(std_heap != NULL);
-
-  /* Create the second region a page after the first one ends + safety gap */
-  mc_heap =
-      xbt_mheap_new_options(-1,
-                            (char *) (std_heap) + STD_HEAP_SIZE + xbt_pagesize,
-                            0);
-  xbt_assert(mc_heap != NULL);
 }
 
 /* Finalize the memory subsystem */
 #include "xbt_modinter.h"
 void MC_memory_exit(void)
 {
-  if (mc_heap && mc_heap != std_heap)
-    xbt_mheap_destroy(mc_heap);
 }
 
 }

diff --git a/src/mc/mc_mmalloc.h b/src/mc/mc_mmalloc.h
index 6aa7d61..987bf89 100644 (file)
--- a/src/mc/mc_mmalloc.h
+++ b/src/mc/mc_mmalloc.h
@@ -20,9 +20,6 @@
 
 SG_BEGIN_DECL()
 
-extern xbt_mheap_t std_heap;
-extern xbt_mheap_t mc_heap;
-
 /* FIXME: Horrible hack! because the mmalloc library doesn't provide yet of */
 /* an API to query about the status of a heap, we simply call mmstats and */
 /* because I now how does structure looks like, then I redefine it here */

diff --git a/src/mc/mc_process.cpp b/src/mc/mc_process.cpp
index 40e9d03..334f8c9 100644 (file)
--- a/src/mc/mc_process.cpp
+++ b/src/mc/mc_process.cpp
@@ -81,7 +81,8 @@ void MC_process_init(mc_process_t process, pid_t pid, int sockfd)
   MC_process_open_memory_file(process);
 
   // Read std_heap (is a struct mdesc*):
-  dw_variable_t std_heap_var = MC_process_find_variable_by_name(process, "std_heap");
+  dw_variable_t std_heap_var = MC_process_find_variable_by_name(process,
+    "__mmalloc_default_mdp");
   if (!std_heap_var)
     xbt_die("No heap information in the target process");
   if(!std_heap_var->address)

diff --git a/src/mc/mc_process.h b/src/mc/mc_process.h
index d10a28c..4aadece 100644 (file)
--- a/src/mc/mc_process.h
+++ b/src/mc/mc_process.h
@@ -192,8 +192,6 @@ char* MC_process_read_string(mc_process_t, void* address);
 
 static inline xbt_mheap_t MC_process_get_heap(mc_process_t process)
 {
-  if (MC_process_is_self(process))
-    return std_heap;
   if (!(process->cache_flags & MC_PROCESS_CACHE_FLAG_HEAP))
     MC_process_refresh_heap(process);
   return process->heap;
@@ -201,8 +199,6 @@ static inline xbt_mheap_t MC_process_get_heap(mc_process_t process)
 
 static inline malloc_info* MC_process_get_malloc_info(mc_process_t process)
 {
-  if (MC_process_is_self(process))
-    return std_heap->heapinfo;
   if (!(process->cache_flags & MC_PROCESS_CACHE_FLAG_MALLOC_INFO))
     MC_process_refresh_malloc_info(process);
   return process->heap_info;

diff --git a/src/mc/mc_snapshot.h b/src/mc/mc_snapshot.h
index 738fee3..e01ac4e 100644 (file)
--- a/src/mc/mc_snapshot.h
+++ b/src/mc/mc_snapshot.h
@@ -248,7 +248,6 @@ typedef struct s_mc_snapshot_stack{
 
 typedef struct s_mc_global_t {
   mc_snapshot_t snapshot;
-  int raw_mem_set;
   int prev_pair;
   char *prev_req;
   int initial_communications_pattern_done;