int mmalloc_compare_heap(struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2);
int mmalloc_linear_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2);
int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dynar_t to_ignore1, xbt_dynar_t to_ignore2);
-int compare_heap_area(void *area1, void* area2, struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2, xbt_dynar_t previous, struct s_dw_type *type, int pointer_level);
+int compare_heap_area(int process_index, void *area1, void* area2, struct s_mc_snapshot* snapshot1, struct s_mc_snapshot* snapshot2, xbt_dynar_t previous, struct s_dw_type *type, int pointer_level);
void reset_heap_information(void);
size_t mmalloc_get_bytes_used(xbt_mheap_t);
void *context;
size_t size;
int block;
+ int process_index;
}s_stack_region_t, *stack_region_t;
void heap_ignore_region_free(mc_heap_ignore_region_t r);
XBT_PUBLIC(void) MC_remove_ignore_heap(void *address, size_t size);
XBT_PUBLIC(void) MC_ignore_local_variable(const char *var_name, const char *frame);
XBT_PUBLIC(void) MC_ignore_global_variable(const char *var_name);
-void MC_new_stack_area(void *stack, char *name, void *context, size_t size);
+XBT_PUBLIC(void) MC_new_stack_area(void *stack, smx_process_t process, void *context, size_t size);
/********************************* Memory *************************************/
XBT_PUBLIC(void) MC_memory_init(void); /* Initialize the memory subsystem */
#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_dense(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)
{
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;
}
-static mc_mem_region_t MC_region_new(int type, void *start_addr, size_t size, mc_mem_region_t ref_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, size, ref_reg);
+ return mc_region_new_sparse(type, start_addr, permanent_addr, size, ref_reg);
} else {
- return mc_region_new_dense(type, start_addr, size, ref_reg);
+ return mc_region_new_dense(type, start_addr, permanent_addr, size, ref_reg);
}
}
/*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, start_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,
+ 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, mappings[i], size_data_exe, ref_reg);
}
snapshot->privatization_index = 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;
}
}
}
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)
current_variable->object_info,
&(stack_frame->unw_cursor),
(void *) stack_frame->frame_base,
- NULL);
+ NULL, process_index);
} 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;
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);
}
+#endif
if (_sg_mc_sparse_checkpoint && _sg_mc_soft_dirty) {
mc_softdirty_reset();
#include <inttypes.h>
#include <boost/unordered_set.hpp>
+#include "internal_config.h"
#include "mc_private.h"
+#ifdef HAVE_SMPI
+#include "smpi/private.h"
+#endif
+
#include "xbt/mmalloc.h"
#include "xbt/mmalloc/mmprivate.h"
}
static int compare_areas_with_type(struct mc_compare_state& state,
+ int process_index,
void* real_area1, mc_snapshot_t snapshot1, mc_mem_region_t region1,
void* real_area2, mc_snapshot_t snapshot2, mc_mem_region_t region2,
dw_type_t type, int pointer_level)
}
for (i = 0; i < type->element_count; i++) {
size_t off = i * elm_size;
- res = compare_areas_with_type(state,
+ res = compare_areas_with_type(state, process_index,
(char*) real_area1 + off, snapshot1, region1,
(char*) real_area2 + off, snapshot2, region2,
type->subtype, pointer_level);
&& addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)))
return 1;
// The pointers are both in the heap:
- return compare_heap_area(addr_pointed1, addr_pointed2, snapshot1,
+ return compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1,
snapshot2, NULL, type->subtype, pointer_level);
}
if (type->dw_type_id == NULL)
return (addr_pointed1 != addr_pointed2);
else {
- return compare_areas_with_type(state,
+ return compare_areas_with_type(state, process_index,
addr_pointed1, snapshot1, region1,
addr_pointed2, snapshot2, region2,
type->subtype, pointer_level);
case DW_TAG_class_type:
xbt_dynar_foreach(type->members, cursor, member) {
void *member1 =
- mc_member_resolve(real_area1, type, member, snapshot1);
+ mc_member_resolve(real_area1, type, member, snapshot1, process_index);
void *member2 =
- mc_member_resolve(real_area2, type, member, snapshot2);
- mc_mem_region_t subregion1 = mc_get_region_hinted(member1, snapshot1, region1);
- mc_mem_region_t subregion2 = mc_get_region_hinted(member2, snapshot2, region2);
+ mc_member_resolve(real_area2, type, member, snapshot2, process_index);
+ mc_mem_region_t subregion1 = mc_get_region_hinted(member1, snapshot1, process_index, region1);
+ mc_mem_region_t subregion2 = mc_get_region_hinted(member2, snapshot2, process_index, region2);
res =
- compare_areas_with_type(state,
+ compare_areas_with_type(state, process_index,
member1, snapshot1, subregion1,
member2, snapshot2, subregion2,
member->subtype, pointer_level);
return 0;
}
-static int compare_global_variables(int region_type, mc_mem_region_t r1,
+static int compare_global_variables(mc_object_info_t object_info,
+ int process_index,
+ mc_mem_region_t r1,
mc_mem_region_t r2, mc_snapshot_t snapshot1,
mc_snapshot_t snapshot2)
{
unsigned int cursor = 0;
dw_variable_t current_var;
- mc_object_info_t object_info = NULL;
- if (region_type == 2) {
- object_info = mc_binary_info;
- } else {
- object_info = mc_libsimgrid_info;
- }
variables = object_info->global_variables;
xbt_dynar_foreach(variables, cursor, current_var) {
dw_type_t bvariable_type = current_var->type;
res =
- compare_areas_with_type(state,
+ compare_areas_with_type(state, process_index,
(char *) current_var->address, snapshot1, r1,
(char *) current_var->address, snapshot2, r2,
bvariable_type, 0);
}
-static int compare_local_variables(mc_snapshot_t snapshot1,
+static int compare_local_variables(int process_index,
+ mc_snapshot_t snapshot1,
mc_snapshot_t snapshot2,
mc_snapshot_stack_t stack1,
mc_snapshot_stack_t stack2)
dw_type_t subtype = current_var1->type;
res =
- compare_areas_with_type(state,
- current_var1->address, snapshot1, mc_get_snapshot_region(current_var1->address, snapshot1),
- current_var2->address, snapshot2, mc_get_snapshot_region(current_var2->address, snapshot2),
+ compare_areas_with_type(state, process_index,
+ current_var1->address, snapshot1, mc_get_snapshot_region(current_var1->address, snapshot1, process_index),
+ current_var2->address, snapshot2, mc_get_snapshot_region(current_var2->address, snapshot2, process_index),
subtype, 0);
if (res == 1) {
#endif
/* Init heap information used in heap comparison algorithm */
- xbt_mheap_t heap1 = (xbt_mheap_t) mc_snapshot_read(std_heap, s1,
+ xbt_mheap_t heap1 = (xbt_mheap_t) mc_snapshot_read(std_heap, s1, MC_NO_PROCESS_INDEX,
alloca(sizeof(struct mdesc)), sizeof(struct mdesc));
- xbt_mheap_t heap2 = (xbt_mheap_t) mc_snapshot_read(std_heap, s2,
+ xbt_mheap_t heap2 = (xbt_mheap_t) mc_snapshot_read(std_heap, s2, MC_NO_PROCESS_INDEX,
alloca(sizeof(struct mdesc)), sizeof(struct mdesc));
res_init = init_heap_information(heap1, heap2, s1->to_ignore, s2->to_ignore);
if (res_init == -1) {
is_diff = 0;
#endif
mc_snapshot_stack_t stack1, stack2;
-
while (cursor < xbt_dynar_length(s1->stacks)) {
stack1 =
(mc_snapshot_stack_t) xbt_dynar_get_as(s1->stacks, cursor,
stack2 =
(mc_snapshot_stack_t) xbt_dynar_get_as(s2->stacks, cursor,
mc_snapshot_stack_t);
- diff_local =
- compare_local_variables(s1, s2, stack1, stack2);
+
+ if (stack1->process_index != stack2->process_index) {
+ diff_local = 1;
+ XBT_DEBUG("(%d - %d) Stacks with different process index (%i vs %i)", num1, num2,
+ stack1->process_index, stack2->process_index);
+ }
+ else diff_local =
+ compare_local_variables(stack1->process_index, s1, s2, stack1, stack2);
if (diff_local > 0) {
#ifdef MC_DEBUG
if (is_diff == 0) {
};
#endif
+ mc_object_info_t object_infos[] = { NULL, mc_libsimgrid_info, mc_binary_info };
+
int k = 0;
for (k = 2; k != 0; --k) {
#ifdef MC_DEBUG
#endif
/* Compare global variables */
- is_diff =
- compare_global_variables(k, s1->regions[k], s2->regions[k], s1, s2);
+#ifdef HAVE_SMPI
+ if (object_infos[k] == mc_binary_info && smpi_privatize_global_variables) {
+ // Compare the global variables separately for each simulates process:
+ for (int process_index = 0; process_index < smpi_process_count(); process_index++) {
+ is_diff =
+ compare_global_variables(object_infos[k], process_index,
+ s1->privatization_regions[process_index], s2->privatization_regions[process_index], s1, s2);
+ if (is_diff) break;
+ }
+ }
+ else
+#endif
+ is_diff =
+ compare_global_variables(object_infos[k], MC_NO_PROCESS_INDEX, s1->regions[k], s2->regions[k], s1, s2);
+
if (is_diff != 0) {
#ifdef MC_DEBUG
xbt_os_walltimer_stop(timer);
mc_mem_region_t heap_region2 = snapshot2->regions[0];
// This is in snapshot do not use them directly:
- malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1);
- malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2);
+ malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1, MC_NO_PROCESS_INDEX);
+ malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2, MC_NO_PROCESS_INDEX);
while (i1 <= state->heaplimit) {
(char *) ((xbt_mheap_t) state->s_heap)->heapbase));
res_compare =
- compare_heap_area(addr_block1, addr_block2, snapshot1, snapshot2,
+ compare_heap_area(MC_NO_PROCESS_INDEX, addr_block1, addr_block2, snapshot1, snapshot2,
NULL, NULL, 0);
if (res_compare != 1) {
}
res_compare =
- compare_heap_area(addr_block1, addr_block2, snapshot1, snapshot2,
+ compare_heap_area(MC_NO_PROCESS_INDEX, addr_block1, addr_block2, snapshot1, snapshot2,
NULL, NULL, 0);
if (res_compare != 1) {
(j1 << heapinfo2->type));
res_compare =
- compare_heap_area(addr_frag1, addr_frag2, snapshot1, snapshot2,
+ compare_heap_area(MC_NO_PROCESS_INDEX, addr_frag1, addr_frag2, snapshot1, snapshot2,
NULL, NULL, 0);
if (res_compare != 1)
(j2 << heapinfo2b->type));
res_compare =
- compare_heap_area(addr_frag1, addr_frag2, snapshot2, snapshot2,
+ compare_heap_area(MC_NO_PROCESS_INDEX, addr_frag1, addr_frag2, snapshot2, snapshot2,
NULL, NULL, 0);
if (res_compare != 1) {
* @param size
* @param check_ignore
*/
-static int compare_heap_area_without_type(struct s_mc_diff *state,
+static int compare_heap_area_without_type(struct s_mc_diff *state, int process_index,
void *real_area1, void *real_area2,
mc_snapshot_t snapshot1,
mc_snapshot_t snapshot2,
if (mc_snapshot_region_memcmp(((char *) real_area1) + i, heap_region1, ((char *) real_area2) + i, heap_region2, 1) != 0) {
pointer_align = (i / sizeof(void *)) * sizeof(void *);
- addr_pointed1 = mc_snapshot_read_pointer((char *) real_area1 + pointer_align, snapshot1);
- addr_pointed2 = mc_snapshot_read_pointer((char *) real_area2 + pointer_align, snapshot2);
+ addr_pointed1 = mc_snapshot_read_pointer((char *) real_area1 + pointer_align, snapshot1, process_index);
+ addr_pointed2 = mc_snapshot_read_pointer((char *) real_area2 + pointer_align, snapshot2, process_index);
if (addr_pointed1 > maestro_stack_start
&& addr_pointed1 < maestro_stack_end
&& addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)) {
// Both addreses are in the heap:
res_compare =
- compare_heap_area(addr_pointed1, addr_pointed2, snapshot1,
+ compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1,
snapshot2, previous, NULL, 0);
if (res_compare == 1) {
return res_compare;
* @param pointer_level
* @return 0 (same), 1 (different), -1 (unknown)
*/
-static int compare_heap_area_with_type(struct s_mc_diff *state,
+static int compare_heap_area_with_type(struct s_mc_diff *state, int process_index,
void *real_area1, void *real_area2,
mc_snapshot_t snapshot1,
mc_snapshot_t snapshot2,
for (i = 0; i < type->element_count; i++) {
// TODO, add support for variable stride (DW_AT_byte_stride)
res =
- compare_heap_area_with_type(state,
+ compare_heap_area_with_type(state, process_index,
(char *) real_area1 + (i * elm_size),
(char *) real_area2 + (i * elm_size),
snapshot1, snapshot2, previous,
case DW_TAG_rvalue_reference_type:
case DW_TAG_pointer_type:
if (type->subtype && type->subtype->type == DW_TAG_subroutine_type) {
- addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1);
- addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2);
+ addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1, process_index);
+ addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2, process_index);
return (addr_pointed1 != addr_pointed2);;
} else {
pointer_level++;
if (pointer_level > 1) { /* Array of pointers */
for (i = 0; i < (area_size / sizeof(void *)); i++) {
- addr_pointed1 = mc_snapshot_read_pointer((char*) real_area1 + i * sizeof(void *), snapshot1);
- addr_pointed2 = mc_snapshot_read_pointer((char*) real_area2 + i * sizeof(void *), snapshot2);
+ addr_pointed1 = mc_snapshot_read_pointer((char*) real_area1 + i * sizeof(void *), snapshot1, process_index);
+ addr_pointed2 = mc_snapshot_read_pointer((char*) real_area2 + i * sizeof(void *), snapshot2, process_index);
if (addr_pointed1 > state->s_heap
&& addr_pointed1 < mc_snapshot_get_heap_end(snapshot1)
&& addr_pointed2 > state->s_heap
&& addr_pointed2 < mc_snapshot_get_heap_end(snapshot2))
res =
- compare_heap_area(addr_pointed1, addr_pointed2, snapshot1,
+ compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1,
snapshot2, previous, type->subtype,
pointer_level);
else
return res;
}
} else {
- addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1);
- addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2);
+ addr_pointed1 = mc_snapshot_read_pointer(real_area1, snapshot1, process_index);
+ addr_pointed2 = mc_snapshot_read_pointer(real_area2, snapshot2, process_index);
if (addr_pointed1 > state->s_heap
&& addr_pointed1 < mc_snapshot_get_heap_end(snapshot1)
&& addr_pointed2 > state->s_heap
&& addr_pointed2 < mc_snapshot_get_heap_end(snapshot2))
- return compare_heap_area(addr_pointed1, addr_pointed2, snapshot1,
+ return compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1,
snapshot2, previous, type->subtype,
pointer_level);
else
if (area_size > type->byte_size && area_size % type->byte_size == 0) {
for (i = 0; i < (area_size / type->byte_size); i++) {
res =
- compare_heap_area_with_type(state,
+ compare_heap_area_with_type(state, process_index,
(char *) real_area1 + i * type->byte_size,
(char *) real_area2 + i * type->byte_size,
snapshot1, snapshot2, previous, type, -1,
xbt_dynar_foreach(type->members, cursor, member) {
// TODO, optimize this? (for the offset case)
char *real_member1 =
- mc_member_resolve(real_area1, type, member, snapshot1);
+ mc_member_resolve(real_area1, type, member, snapshot1, process_index);
char *real_member2 =
- mc_member_resolve(real_area2, type, member, snapshot2);
+ mc_member_resolve(real_area2, type, member, snapshot2, process_index);
res =
- compare_heap_area_with_type(state, real_member1, real_member2,
+ compare_heap_area_with_type(state, process_index, real_member1, real_member2,
snapshot1, snapshot2,
previous, member->subtype, -1,
check_ignore, 0);
}
break;
case DW_TAG_union_type:
- return compare_heap_area_without_type(state, real_area1, real_area2,
+ return compare_heap_area_without_type(state, process_index, real_area1, real_area2,
snapshot1, snapshot2, previous,
type->byte_size, check_ignore);
break;
*/
static dw_type_t get_offset_type(void *real_base_address, dw_type_t type,
int offset, int area_size,
- mc_snapshot_t snapshot)
+ mc_snapshot_t snapshot, int process_index)
{
// Beginning of the block, the infered variable type if the type of the block:
return member->subtype;
} else {
char *real_member =
- mc_member_resolve(real_base_address, type, member, snapshot);
+ mc_member_resolve(real_base_address, type, member, snapshot, process_index);
if (real_member - (char *) real_base_address == offset)
return member->subtype;
}
* @param pointer_level
* @return 0 (same), 1 (different), -1
*/
-int compare_heap_area(void *area1, void *area2, mc_snapshot_t snapshot1,
+int compare_heap_area(int process_index, void *area1, void *area2, mc_snapshot_t snapshot1,
mc_snapshot_t snapshot2, xbt_dynar_t previous,
dw_type_t type, int pointer_level)
{
int match_pairs = 0;
- malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1);
- malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2);
+ malloc_info* heapinfos1 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot1, process_index);
+ malloc_info* heapinfos2 = mc_snapshot_read_pointer(&((xbt_mheap_t)std_heap)->heapinfo, snapshot2, process_index);
malloc_info heapinfo_temp1, heapinfo_temp2;
&& state->types2_(block2, frag2) != NULL) {
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
- offset1, size, snapshot1);
+ offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types2_(block2, frag2),
- offset1, size, snapshot2);
+ offset1, size, snapshot2, process_index);
} else if (state->types1_(block1, frag1) != NULL) {
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
- offset1, size, snapshot1);
+ offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types1_(block1, frag1),
- offset2, size, snapshot2);
+ offset2, size, snapshot2, process_index);
} else if (state->types2_(block2, frag2) != NULL) {
new_type1 =
get_offset_type(real_addr_frag1, state->types2_(block2, frag2),
- offset1, size, snapshot1);
+ offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types2_(block2, frag2),
- offset2, size, snapshot2);
+ offset2, size, snapshot2, process_index);
} else {
if (match_pairs) {
match_equals(state, previous);
/* Start comparison */
if (type) {
res_compare =
- compare_heap_area_with_type(state, real_area1_to_compare, real_area2_to_compare, snapshot1, snapshot2,
+ compare_heap_area_with_type(state, process_index, area1, area2, snapshot1, snapshot2,
previous, type, size, check_ignore,
pointer_level);
} else {
res_compare =
- compare_heap_area_without_type(state, real_area1_to_compare, real_area2_to_compare, snapshot1, snapshot2,
+ compare_heap_area_without_type(state, process_index, area1, area2, snapshot1, snapshot2,
previous, size, check_ignore);
}
if (res_compare == 1) {
// Computed address:
uintptr_t address = (uintptr_t) state->stack[state->stack_size - 1];
uintptr_t temp;
- uintptr_t* res = (uintptr_t*) mc_snapshot_read((void*) address, state->snapshot, &temp, sizeof(uintptr_t));
+ uintptr_t* res = (uintptr_t*) mc_snapshot_read((void*) address, state->snapshot, state->process_index, &temp, sizeof(uintptr_t));
state->stack[state->stack_size - 1] = *res;
}
break;
mc_object_info_t object_info,
unw_cursor_t * c,
void *frame_pointer_address,
- mc_snapshot_t snapshot)
+ mc_snapshot_t snapshot, int process_index)
{
s_mc_expression_state_t state;
memset(&state, 0, sizeof(s_mc_expression_state_t));
state.cursor = c;
state.snapshot = snapshot;
state.object_info = object_info;
+ state.process_index = process_index;
if (mc_dwarf_execute_expression(expression->size, expression->ops, &state))
xbt_die("Error evaluating DWARF expression");
mc_object_info_t object_info,
unw_cursor_t * c,
void *frame_pointer_address,
- mc_snapshot_t snapshot)
+ mc_snapshot_t snapshot, int process_index)
{
unw_word_t ip;
|| (c && ip >= (unw_word_t) expression->lowpc
&& ip < (unw_word_t) expression->highpc)) {
return mc_dwarf_resolve_location(expression, object_info, c,
- frame_pointer_address, snapshot);
+ frame_pointer_address, snapshot, process_index);
}
}
xbt_die("Could not resolve location");
unw_cursor_t * unw_cursor)
{
return (void *) mc_dwarf_resolve_locations(&frame->frame_base, object_info,
- unw_cursor, NULL, NULL);
+ unw_cursor, NULL, NULL, -1);
}
void mc_dwarf_expression_clear(mc_expression_t expression)
}
}
+#if 0
/** \brief Compute a hash for a given value of a given type
*
* We try to be very conservative (do not hash too ambiguous things).
}
}
-
static void mc_hash_object_globals(mc_hash_t * hash, mc_hashing_state * state,
mc_object_info_t info)
{
++i;
}
}
+#endif
uint64_t mc_hash_processes_state(int num_state, xbt_dynar_t stacks)
{
mc_hash_t hash = MC_HASH_INIT;
MC_HASH(hash, xbt_swag_size(simix_global->process_list)); // process count
- mc_hash_object_globals(&hash, &state, mc_binary_info);
+ // mc_hash_object_globals(&hash, &state, mc_binary_info);
// mc_hash_object_globals(&hash, &state, mc_libsimgrid_info);
- mc_hash_stacks(&hash, &state, stacks);
+ // mc_hash_stacks(&hash, &state, stacks);
mc_hash_state_destroy(&state);
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
+#include "internal_config.h"
#include "mc_private.h"
+#include "smpi/private.h"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_ignore, mc,
"Logging specific to MC ignore mechanism");
}
-void MC_new_stack_area(void *stack, char *name, void *context, size_t size)
+/** @brief Register a stack in the model checker
+ *
+ * The stacks are allocated in the heap. The MC handle them especially
+ * when we analyse/compare the content of theap so it must be told where
+ * they are with this function.
+ *
+ * @param stack
+ * @param process Process owning the stack
+ * @param context
+ * @param size Size of the stack
+ */
+void MC_new_stack_area(void *stack, smx_process_t process, void *context, size_t size)
{
int raw_mem_set = (mmalloc_get_current_heap() == mc_heap);
stack_region_t region = NULL;
region = xbt_new0(s_stack_region_t, 1);
region->address = stack;
- region->process_name = strdup(name);
+ region->process_name = process && process->name ? strdup(process->name) : NULL;
region->context = context;
region->size = size;
region->block =
((char *) stack -
(char *) ((xbt_mheap_t) std_heap)->heapbase) / BLOCKSIZE + 1;
+#ifdef HAVE_SMPI
+ if (smpi_privatize_global_variables && process) {
+ region->process_index = smpi_process_index_of_smx_process(process);
+ } else
+#endif
+ region->process_index = -1;
+
xbt_dynar_push(stacks_areas, ®ion);
if (!raw_mem_set)
* @return Process address of the given member of the 'object' struct/class
*/
void *mc_member_resolve(const void *base, dw_type_t type, dw_type_t member,
- mc_snapshot_t snapshot)
+ mc_snapshot_t snapshot, int process_index)
{
if (!member->location.size) {
return ((char *) base) + member->offset;
state.snapshot = snapshot;
state.stack_size = 1;
state.stack[0] = (uintptr_t) base;
+ state.process_index = process_index;
if (mc_dwarf_execute_expression
(member->location.size, member->location.ops, &state))
// ***** High level API
-mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, size_t size, mc_mem_region_t ref_reg)
+mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, void* permanent_addr, size_t size, mc_mem_region_t 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;
xbt_assert((((uintptr_t)start_addr) & (xbt_pagesize-1)) == 0,
"Not at the beginning of a page");
+ xbt_assert((((uintptr_t)permanent_addr) & (xbt_pagesize-1)) == 0,
+ "Not at the beginning of a page");
size_t page_count = mc_page_count(size);
uint64_t* pagemap = NULL;
if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot) {
pagemap = (uint64_t*) mmalloc_no_memset((xbt_mheap_t) mc_heap, sizeof(uint64_t) * page_count);
- mc_read_pagemap(pagemap, mc_page_number(NULL, start_addr), page_count);
+ mc_read_pagemap(pagemap, mc_page_number(NULL, permanent_addr), page_count);
}
// Take incremental snapshot:
- new_reg->page_numbers = mc_take_page_snapshot_region(start_addr, page_count, pagemap,
+ new_reg->page_numbers = mc_take_page_snapshot_region(permanent_addr, page_count, pagemap,
ref_reg==NULL ? NULL : ref_reg->page_numbers);
if(pagemap) {
void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg)
{
- xbt_assert((((uintptr_t)reg->start_addr) & (xbt_pagesize-1)) == 0,
+ xbt_assert((((uintptr_t)reg->permanent_addr) & (xbt_pagesize-1)) == 0,
"Not at the beginning of a page");
size_t page_count = mc_page_count(reg->size);
// Read soft-dirty bits if necessary in order to know which pages have changed:
if (_sg_mc_soft_dirty && mc_model_checker->parent_snapshot) {
pagemap = (uint64_t*) mmalloc_no_memset((xbt_mheap_t) mc_heap, sizeof(uint64_t) * page_count);
- mc_read_pagemap(pagemap, mc_page_number(NULL, reg->start_addr), page_count);
+ mc_read_pagemap(pagemap, mc_page_number(NULL, reg->permanent_addr), page_count);
}
// Incremental per-page snapshot restoration:
- mc_restore_page_snapshot_region(reg->start_addr, page_count, reg->page_numbers,
+ mc_restore_page_snapshot_region(reg->permanent_addr, page_count, reg->page_numbers,
pagemap, ref_reg ? ref_reg->page_numbers : NULL);
// This is funny, the restoration can restore the state of the current heap,
#define NB_REGIONS 3 /* binary data (data + BSS) (type = 2), libsimgrid data (data + BSS) (type = 1), std_heap (type = 0)*/
+/** @brief Copy/snapshot of a given memory region
+ *
+ * Two types of region snapshots exist:
+ * <ul>
+ * <li>flat/dense snapshots are a simple copy of the region;</li>
+ * <li>sparse/per-page snapshots are snaapshots which shared
+ * identical pages.</li>
+ * </ul>
+ */
typedef struct s_mc_mem_region{
- // Real address:
+ /** @brief Virtual address of the region in the simulated process */
void *start_addr;
- // Copy of the datra:
+
+ /** @brief Permanent virtual address of the region
+ *
+ * This is usually the same address as the simuilated process address.
+ * However, when using SMPI privatization of global variables,
+ * each SMPI process has its own set of global variables stored
+ * at a different virtual address. The scheduler maps those region
+ * on the region of the global variables.
+ *
+ * */
+ void *permanent_addr;
+
+ /** @brief Copy of the snapshot for flat snapshots regions (NULL otherwise) */
void *data;
- // Size of the data region:
+
+ /** @brief Size of the data region in bytes */
size_t size;
- // For per-page snapshots, this is an array to the number of
+
+ /** @brief Pages indices in the page store for per-page snapshots (NULL otherwise) */
size_t* page_numbers;
+
} s_mc_mem_region_t, *mc_mem_region_t;
static inline __attribute__ ((always_inline))
xbt_dynar_t ignored_data;
} s_mc_snapshot_t, *mc_snapshot_t;
-mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot);
+/** @brief Process index used when no process is available
+ *
+ * The expected behaviour is that if a process index is needed it will fail.
+ * */
+#define MC_NO_PROCESS_INDEX -1
+
+/** @brief Process index when any process is suitable
+ *
+ * We could use a special negative value in the future.
+ */
+#define MC_ANY_PROCESS_INDEX 0
+
+mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot, int process_index);
static inline __attribute__ ((always_inline))
-mc_mem_region_t mc_get_region_hinted(void* addr, mc_snapshot_t snapshot, mc_mem_region_t region)
+mc_mem_region_t mc_get_region_hinted(void* addr, mc_snapshot_t snapshot, int process_index, mc_mem_region_t region)
{
if (mc_region_contain(region, addr))
return region;
else
- return mc_get_snapshot_region(addr, snapshot);
+ return mc_get_snapshot_region(addr, snapshot, process_index);
}
/** Information about a given stack frame
typedef struct s_mc_snapshot_stack{
xbt_dynar_t local_variables;
xbt_dynar_t stack_frames; // mc_stack_frame_t
+ int process_index;
}s_mc_snapshot_stack_t, *mc_snapshot_stack_t;
typedef struct s_mc_global_t{
void mc_free_page_snapshot_region(size_t* pagenos, size_t page_count);
void mc_restore_page_snapshot_region(void* start_addr, size_t page_count, size_t* pagenos, uint64_t* pagemap, size_t* reference_pagenos);
-mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, size_t size, mc_mem_region_t ref_reg);
+mc_mem_region_t mc_region_new_sparse(int type, void *start_addr, void* data_addr, size_t size, mc_mem_region_t ref_reg);
void MC_region_destroy(mc_mem_region_t reg);
void mc_region_restore_sparse(mc_mem_region_t reg, mc_mem_region_t ref_reg);
void mc_softdirty_reset();
void* mc_snapshot_read_fragmented(void* addr, mc_mem_region_t region, void* target, size_t size);
-void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, void* target, size_t size);
+void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, int process_index, void* target, size_t size);
int mc_snapshot_region_memcmp(
void* addr1, mc_mem_region_t region1,
void* addr2, mc_mem_region_t region2, size_t size);
int mc_snapshot_memcmp(
void* addr1, mc_snapshot_t snapshot1,
- void* addr2, mc_snapshot_t snapshot2, size_t size);
+ void* addr2, mc_snapshot_t snapshot2, int process_index, size_t size);
-static void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot);
+static void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot, int process_index);
/** @brief State of the model-checker (global variables for the model checker)
*
mc_expression_t locations;
} s_mc_location_list_t, *mc_location_list_t;
-uintptr_t mc_dwarf_resolve_location(mc_expression_t expression, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot);
-uintptr_t mc_dwarf_resolve_locations(mc_location_list_t locations, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot);
+uintptr_t mc_dwarf_resolve_location(mc_expression_t expression, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot, int process_index);
+uintptr_t mc_dwarf_resolve_locations(mc_location_list_t locations, mc_object_info_t object_info, unw_cursor_t* c, void* frame_pointer_address, mc_snapshot_t snapshot, int process_index);
void mc_dwarf_expression_clear(mc_expression_t expression);
void mc_dwarf_expression_init(mc_expression_t expression, size_t len, Dwarf_Op* ops);
dw_type_t full_type; // The same (but more complete) type
};
-void* mc_member_resolve(const void* base, dw_type_t type, dw_type_t member, mc_snapshot_t snapshot);
+void* mc_member_resolve(const void* base, dw_type_t type, dw_type_t member, mc_snapshot_t snapshot, int process_index);
typedef struct s_dw_variable{
Dwarf_Off dwarf_offset; /* Global offset of the field. */
void* frame_base;
mc_snapshot_t snapshot;
mc_object_info_t object_info;
+ int process_index;
} s_mc_expression_state_t, *mc_expression_state_t;
int mc_dwarf_execute_expression(size_t n, const Dwarf_Op* ops, mc_expression_state_t state);
* \return Translated address in the snapshot address space
* */
static inline __attribute__((always_inline))
-void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot)
+void* mc_translate_address(uintptr_t addr, mc_snapshot_t snapshot, int process_index)
{
// If not in a process state/clone:
return (uintptr_t *) addr;
}
- mc_mem_region_t region = mc_get_snapshot_region((void*) addr, snapshot);
+ mc_mem_region_t region = mc_get_snapshot_region((void*) addr, snapshot, process_index);
xbt_assert(mc_region_contain(region, (void*) addr), "Trying to read out of the region boundary.");
if(snapshot==NULL)
xbt_die("snapshot is NULL");
void** addr = &((xbt_mheap_t)std_heap)->breakval;
- return mc_snapshot_read_pointer(addr, snapshot);
+ return mc_snapshot_read_pointer(addr, snapshot, MC_ANY_PROCESS_INDEX);
}
static inline __attribute__ ((always_inline))
-void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot)
+void* mc_snapshot_read_pointer(void* addr, mc_snapshot_t snapshot, int process_index)
{
void* res;
- return *(void**) mc_snapshot_read(addr, snapshot, &res, sizeof(void*));
+ return *(void**) mc_snapshot_read(addr, snapshot, process_index, &res, sizeof(void*));
}
/** @brief Read memory from a snapshot region
#include <stdbool.h>
+#include "internal_config.h"
+#include "smpi/private.h"
+
#include "mc_private.h"
#include "mc_mmu.h"
#include "mc_page_store.h"
* @param Snapshot region in the snapshot this pointer belongs to
* (or NULL if it does not belong to any snapshot region)
* */
-mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot)
+mc_mem_region_t mc_get_snapshot_region(void* addr, mc_snapshot_t snapshot, int process_index)
{
+#ifdef HAVE_SMPI
+ if (snapshot->privatization_regions) {
+
+ if (process_index < 0) {
+
+ mc_mem_region_t region = snapshot->privatization_regions[0];
+ if( mc_region_contain(region, addr) ) {
+ xbt_die("Missing process index");
+ }
+
+ } else {
+ if (process_index >= smpi_process_count()) {
+ xbt_die("Invalid process index");
+ }
+
+ mc_mem_region_t region = snapshot->privatization_regions[process_index];
+ if( mc_region_contain(region, addr) ) {
+ return region;
+ }
+
+ }
+ }
+#endif
+
for (size_t i = 0; i != NB_REGIONS; ++i) {
mc_mem_region_t region = snapshot->regions[i];
- void* start = region->start_addr;
- void* end = (char*) start + region->size;
-
- if (addr >= start && addr < end) {
+ if ( region && mc_region_contain(region, addr) ) {
return region;
}
}
* @param size Size of the data to read in bytes
* @return Pointer where the data is located (target buffer or original location)
*/
-void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, void* target, size_t size)
+void* mc_snapshot_read(void* addr, mc_snapshot_t snapshot, int process_index, void* target, size_t size)
{
if (snapshot) {
- mc_mem_region_t region = mc_get_snapshot_region(addr, snapshot);
+ mc_mem_region_t region = mc_get_snapshot_region(addr, snapshot, process_index);
return mc_snapshot_read_region(addr, region, target, size);
} else {
return addr;
* */
int mc_snapshot_region_memcmp(
void* addr1, mc_mem_region_t region1,
- void* addr2, mc_mem_region_t region2, size_t size)
+ void* addr2, mc_mem_region_t region2,
+ size_t size)
{
// Using alloca() for large allocations may trigger stack overflow:
// use malloc if the buffer is too big.
* */
int mc_snapshot_memcmp(
void* addr1, mc_snapshot_t snapshot1,
- void* addr2, mc_snapshot_t snapshot2, size_t size)
+ void* addr2, mc_snapshot_t snapshot2, int process_index, size_t size)
{
- mc_mem_region_t region1 = mc_get_snapshot_region(addr1, snapshot1);
- mc_mem_region_t region2 = mc_get_snapshot_region(addr2, snapshot2);
+ mc_mem_region_t region1 = mc_get_snapshot_region(addr1, snapshot1, process_index);
+ mc_mem_region_t region2 = mc_get_snapshot_region(addr2, snapshot2, process_index);
return mc_snapshot_region_memcmp(addr1, region1, addr2, region2, size);
}
// Init memory and take snapshots:
init_memory(source, byte_size);
- mc_mem_region_t region0 = mc_region_new_sparse(0, source, byte_size, NULL);
+ mc_mem_region_t region0 = mc_region_new_sparse(0, source, source, byte_size, NULL);
for(int i=0; i<n; i+=2) {
init_memory((char*) source + i*xbt_pagesize, xbt_pagesize);
}
- mc_mem_region_t region = mc_region_new_sparse(0, source, byte_size, NULL);
+ mc_mem_region_t region = mc_region_new_sparse(0, source, source, byte_size, NULL);
void* destination = mmap(NULL, byte_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
xbt_assert(source!=MAP_FAILED, "Could not allocate destination memory");
if (n==1) {
xbt_test_add("Read pointer for %i page(s)", n);
memcpy(source, &mc_model_checker, sizeof(void*));
- mc_mem_region_t region2 = mc_region_new_sparse(0, source, byte_size, NULL);
+ mc_mem_region_t region2 = mc_region_new_sparse(0, source, source, byte_size, NULL);
xbt_test_assert(mc_snapshot_read_pointer_region(source, region2) == mc_model_checker,
"Mismtach in mc_snapshot_read_pointer_region()");
MC_region_destroy(region2);
sysv_maestro_context = context;
}
- if(MC_is_active() && code)
- MC_new_stack_area(context->stack, ((smx_context_t)context)->process->name,
+ if (MC_is_active() && code) {
+ MC_new_stack_area(context->stack, ((smx_context_t)context)->process,
&(context->uc), smx_context_usable_stack_size);
+ }
return (smx_context_t) context;
}
#include "smpi/smpi_cocci.h"
#include "instr/instr_private.h"
+SG_BEGIN_DECL()
+
struct s_smpi_process_data;
typedef struct s_smpi_process_data *smpi_process_data_t;
extern void** mappings;
extern int loaded_page;
+int smpi_process_index_of_smx_process(smx_process_t process);
+
+SG_END_DECL()
+
#endif
double smpi_running_power;
int* fds;
+size_t mappings_count = 0;
void** mappings;
int loaded_page = -1;
char* start_data_exe = NULL;
if (loaded_page==dest)//no need to switch either
return;
-
#ifdef HAVE_MMAP
int i;
if(loaded_page==-1){//initial switch, do the copy from the real page here
return data ? data->index : MPI_UNDEFINED;
}
+int smpi_process_index_of_smx_process(smx_process_t process) {
+ smpi_process_data_t data = SIMIX_process_get_data(process);
+ return data ? data->index : MPI_UNDEFINED;
+}
+
MPI_Comm smpi_process_comm_world(void)
{
smpi_process_data_t data = smpi_process_data();
assert(var);
void* frame_base = mc_find_frame_base(subprogram, info, cursor);
- xbt_assert((void*)mc_dwarf_resolve_locations(&var->locations, info, cursor, frame_base, NULL) == address,
+ xbt_assert((void*)mc_dwarf_resolve_locations(&var->locations, info, cursor, frame_base, NULL, -1) == address,
"Bad resolution of local variable %s of %s", variable, function);
}
