#define _GNU_SOURCE
#define UNW_LOCAL_ONLY
+
#include <string.h>
#include <link.h>
+
+#include "internal_config.h"
#include "mc_private.h"
#include "xbt/module.h"
#include <xbt/mmalloc.h>
void MC_region_destroy(mc_mem_region_t reg)
{
+ if (!reg)
+ return;
+
//munmap(reg->data, reg->size);
xbt_free(reg->data);
if (reg->page_numbers) {
void MC_free_snapshot(mc_snapshot_t snapshot)
{
unsigned int i;
- for (i = 0; i < NB_REGIONS; i++)
+ for (i = 0; i < NB_REGIONS; i++) {
MC_region_destroy(snapshot->regions[i]);
+ }
xbt_free(snapshot->stack_sizes);
xbt_dynar_free(&(snapshot->stacks));
/******************************* Snapshot regions ********************************/
/*********************************************************************************/
-static mc_mem_region_t MC_region_new(int type, void *start_addr, size_t size, mc_mem_region_t ref_reg)
+static mc_mem_region_t mc_region_new_dense(int type, void *start_addr, void* permanent_addr, size_t size, mc_mem_region_t ref_reg)
{
- if (_sg_mc_sparse_checkpoint) {
- return mc_region_new_sparse(type, start_addr, size, ref_reg);
- }
-
mc_mem_region_t new_reg = xbt_new(s_mc_mem_region_t, 1);
new_reg->start_addr = start_addr;
+ new_reg->permanent_addr = permanent_addr;
new_reg->data = NULL;
new_reg->size = size;
new_reg->page_numbers = NULL;
new_reg->data = xbt_malloc(size);
- memcpy(new_reg->data, start_addr, size);
+ memcpy(new_reg->data, permanent_addr, size);
XBT_DEBUG("New region : type : %d, data : %p (real addr %p), size : %zu",
- type, new_reg->data, start_addr, size);
+ type, new_reg->data, permanent_addr, size);
return new_reg;
}
+/** @brief Take a snapshot of a given region
+ *
+ * @param type
+ * @param start_addr Address of the region in the simulated process
+ * @param permanent_addr Permanent address of this data (for privatized variables, this is the virtual address of the privatized mapping)
+ * @param size Size of the data*
+ * @param ref_reg Reference corresponding region
+ */
+static mc_mem_region_t MC_region_new(int type, void *start_addr, void* permanent_addr, size_t size, mc_mem_region_t ref_reg)
+{
+ if (_sg_mc_sparse_checkpoint) {
+ return mc_region_new_sparse(type, start_addr, permanent_addr, size, ref_reg);
+ } else {
+ return mc_region_new_dense(type, start_addr, permanent_addr, size, ref_reg);
+ }
+}
+
/** @brief Restore a region from a snapshot
*
* If we are using per page snapshots, it is possible to use the reference
/*FIXME: check if start_addr is still mapped, if it is not, then map it
before copying the data */
if (!reg->page_numbers) {
- memcpy(reg->start_addr, reg->data, reg->size);
+ memcpy(reg->permanent_addr, reg->data, reg->size);
} else {
mc_region_restore_sparse(reg, ref_reg);
}
}
static void MC_snapshot_add_region(mc_snapshot_t snapshot, int type,
- void *start_addr, size_t size)
+ void *start_addr, void* permanent_addr, size_t size)
{
mc_mem_region_t ref_reg =
mc_model_checker->parent_snapshot ? mc_model_checker->parent_snapshot->regions[type] : NULL;
- mc_mem_region_t new_reg = MC_region_new(type, start_addr, size, ref_reg);
+ mc_mem_region_t new_reg = MC_region_new(type, start_addr, permanent_addr, size, ref_reg);
snapshot->regions[type] = new_reg;
return;
}
static void MC_get_memory_regions(mc_snapshot_t snapshot)
{
- size_t i;
- void *start_heap = ((xbt_mheap_t) std_heap)->base;
- void *end_heap = ((xbt_mheap_t) std_heap)->breakval;
- MC_snapshot_add_region(snapshot, 0, start_heap,
+ void *start_heap = std_heap->base;
+ void *end_heap = std_heap->breakval;
+ MC_snapshot_add_region(snapshot, 0, start_heap, start_heap,
(char *) end_heap - (char *) start_heap);
snapshot->heap_bytes_used = mmalloc_get_bytes_used(std_heap);
+ snapshot->privatization_regions = NULL;
- MC_snapshot_add_region(snapshot, 1, mc_libsimgrid_info->start_rw,
- mc_libsimgrid_info->end_rw -
- mc_libsimgrid_info->start_rw);
- if (!smpi_privatize_global_variables) {
- MC_snapshot_add_region(snapshot, 2, mc_binary_info->start_rw,
- mc_binary_info->end_rw - mc_binary_info->start_rw);
- snapshot->privatization_regions = NULL;
- snapshot->privatization_index = -1;
- } else {
+ MC_snapshot_add_region(snapshot, 1,
+ mc_libsimgrid_info->start_rw, mc_libsimgrid_info->start_rw,
+ mc_libsimgrid_info->end_rw - mc_libsimgrid_info->start_rw);
+
+#ifdef HAVE_SMPI
+ size_t i;
+ if (smpi_privatize_global_variables && smpi_process_count()) {
+ // Snapshot the global variable of the application separately for each
+ // simulated process:
snapshot->privatization_regions =
- xbt_new(mc_mem_region_t, SIMIX_process_count());
- for (i = 0; i < SIMIX_process_count(); i++) {
+ xbt_new(mc_mem_region_t, smpi_process_count());
+ for (i = 0; i < smpi_process_count(); i++) {
mc_mem_region_t ref_reg =
mc_model_checker->parent_snapshot ? mc_model_checker->parent_snapshot->privatization_regions[i] : NULL;
snapshot->privatization_regions[i] =
- MC_region_new(-1, mappings[i], size_data_exe, ref_reg);
+ MC_region_new(-1, mc_binary_info->start_rw, smpi_privatisation_regions[i].address, size_data_exe, ref_reg);
}
- snapshot->privatization_index = loaded_page;
+ snapshot->privatization_index = smpi_loaded_page;
+ snapshot->regions[2] = NULL;
+ } else
+#endif
+ {
+ MC_snapshot_add_region(snapshot, 2,
+ mc_binary_info->start_rw, mc_binary_info->start_rw,
+ mc_binary_info->end_rw - mc_binary_info->start_rw);
+ snapshot->privatization_regions = NULL;
+ snapshot->privatization_index = -1;
}
}
}
-/** \brief Fill/lookup the "subtype" field.
- */
-static void MC_resolve_subtype(mc_object_info_t info, dw_type_t type)
-{
-
- if (type->dw_type_id == NULL)
- return;
- type->subtype = xbt_dict_get_or_null(info->types, type->dw_type_id);
- if (type->subtype == NULL)
- return;
- if (type->subtype->byte_size != 0)
- return;
- if (type->subtype->name == NULL)
- return;
- // Try to find a more complete description of the type:
- // We need to fix in order to support C++.
-
- dw_type_t subtype =
- xbt_dict_get_or_null(info->full_types_by_name, type->subtype->name);
- if (subtype != NULL) {
- type->subtype = subtype;
- }
-
-}
-
-void MC_post_process_types(mc_object_info_t info)
-{
- xbt_dict_cursor_t cursor = NULL;
- char *origin;
- dw_type_t type;
-
- // Lookup "subtype" field:
- xbt_dict_foreach(info->types, cursor, origin, type) {
- MC_resolve_subtype(info, type);
-
- dw_type_t member;
- unsigned int i = 0;
- if (type->members != NULL)
- xbt_dynar_foreach(type->members, i, member) {
- MC_resolve_subtype(info, member);
- }
- }
-}
-
/** \brief Fills the position of the segments (executable, read-only, read/write).
*
* TODO, use dl_iterate_phdr to be more robust
}
static void mc_fill_local_variables_values(mc_stack_frame_t stack_frame,
- dw_frame_t scope, xbt_dynar_t result)
+ dw_frame_t scope, int process_index, xbt_dynar_t result)
{
void *ip = (void *) stack_frame->ip;
if (ip < scope->low_pc || ip >= scope->high_pc)
if (current_variable->address != NULL) {
new_var->address = current_variable->address;
} else if (current_variable->locations.size != 0) {
- new_var->address =
- (void *) mc_dwarf_resolve_locations(¤t_variable->locations,
+ s_mc_location_t location;
+ mc_dwarf_resolve_locations(&location, ¤t_variable->locations,
current_variable->object_info,
&(stack_frame->unw_cursor),
(void *) stack_frame->frame_base,
- NULL);
+ NULL, process_index);
+
+ switch(mc_get_location_type(&location)) {
+ case MC_LOCATION_TYPE_ADDRESS:
+ new_var->address = location.memory_location;
+ break;
+ case MC_LOCATION_TYPE_REGISTER:
+ default:
+ xbt_die("Cannot handle non-address variable");
+ }
+
} else {
xbt_die("No address");
}
// Recursive processing of nested scopes:
dw_frame_t nested_scope = NULL;
xbt_dynar_foreach(scope->scopes, cursor, nested_scope) {
- mc_fill_local_variables_values(stack_frame, nested_scope, result);
+ mc_fill_local_variables_values(stack_frame, nested_scope, process_index, result);
}
}
-static xbt_dynar_t MC_get_local_variables_values(xbt_dynar_t stack_frames)
+static xbt_dynar_t MC_get_local_variables_values(xbt_dynar_t stack_frames, int process_index)
{
unsigned cursor1 = 0;
xbt_dynar_new(sizeof(local_variable_t), local_variable_free_voidp);
xbt_dynar_foreach(stack_frames, cursor1, stack_frame) {
- mc_fill_local_variables_values(stack_frame, stack_frame->frame, variables);
+ mc_fill_local_variables_values(stack_frame, stack_frame->frame, process_index, variables);
}
return variables;
xbt_dynar_foreach(stacks_areas, cursor, current_stack) {
mc_snapshot_stack_t st = xbt_new(s_mc_snapshot_stack_t, 1);
st->stack_frames = MC_unwind_stack_frames(current_stack->context);
- st->local_variables = MC_get_local_variables_values(st->stack_frames);
+ st->local_variables = MC_get_local_variables_values(st->stack_frames, current_stack->process_index);
+ st->process_index = current_stack->process_index;
unw_word_t sp = xbt_dynar_get_as(st->stack_frames, 0, mc_stack_frame_t)->sp;
int mc_important_snapshot(mc_snapshot_t snapshot)
{
// We need this snapshot in order to know which
- // pages needs to be stored in the next snapshot:
+ // pages needs to be stored in the next snapshot.
+ // This field is only non-NULL when using soft-dirty
+ // page tracking.
if (snapshot == mc_model_checker->parent_snapshot)
return true;
parent_snapshot ? parent_snapshot->regions[i] : NULL);
}
+#ifdef HAVE_SMPI
if (snapshot->privatization_regions) {
- for (i = 0; i < SIMIX_process_count(); i++) {
+ // Restore the global variables of the application separately for each
+ // simulated process:
+ for (i = 0; i < smpi_process_count(); i++) {
if (snapshot->privatization_regions[i]) {
MC_region_restore(snapshot->privatization_regions[i],
parent_snapshot ? parent_snapshot->privatization_regions[i] : NULL);
}
}
- switch_data_segment(snapshot->privatization_index);
}
+ if(snapshot->privatization_index >= 0) {
+ // We just rewrote the global variables.
+ // The privatisation segment SMPI thinks
+ // is mapped might be inconsistent with the segment which
+ // is really mapped in memory (kernel state).
+ // We ask politely SMPI to map the segment anyway,
+ // even if it thinks it is the current one:
+ smpi_really_switch_data_segment(snapshot->privatization_index);
+ }
+#endif
if (_sg_mc_sparse_checkpoint && _sg_mc_soft_dirty) {
mc_softdirty_reset();
}
}
-mc_snapshot_t SIMIX_pre_mc_snapshot(smx_simcall_t simcall)
+mc_snapshot_t simcall_HANDLER_mc_snapshot(smx_simcall_t simcall)
{
return MC_take_snapshot(1);
}