/* Copyright (c) 2008-2015. The SimGrid Team.
* All rights reserved. */
/* 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. */
/* Copyright (c) 2008-2015. The SimGrid Team.
* All rights reserved. */
/* 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 "mc/mc_private.h"
-#include "mc/mc_snapshot.h"
-#include "mc/mc_dwarf.hpp"
-#include "mc/Type.hpp"
+#include "src/mc/malloc.hpp"
+#include "src/mc/mc_private.h"
+#include "src/mc/mc_snapshot.h"
+#include "src/mc/mc_dwarf.hpp"
+#include "src/mc/Type.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_diff, xbt,
"Logging specific to mc_diff in mc");
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_diff, xbt,
"Logging specific to mc_diff in mc");
/*********************************** Heap comparison ***********************************/
/***************************************************************************************/
/*********************************** Heap comparison ***********************************/
/***************************************************************************************/
struct XBT_PRIVATE s_mc_diff {
s_xbt_mheap_t std_heap_copy;
std::size_t heaplimit;
// Number of blocks in the heaps:
std::size_t heapsize1, heapsize2;
struct XBT_PRIVATE s_mc_diff {
s_xbt_mheap_t std_heap_copy;
std::size_t heaplimit;
// Number of blocks in the heaps:
std::size_t heapsize1, heapsize2;
- std::vector<s_mc_heap_ignore_region_t>* to_ignore1;
- std::vector<s_mc_heap_ignore_region_t>* to_ignore2;
+ std::vector<simgrid::mc::IgnoredHeapRegion>* to_ignore1;
+ std::vector<simgrid::mc::IgnoredHeapRegion>* to_ignore2;
s_heap_area_t *equals_to1, *equals_to2;
simgrid::mc::Type **types1;
simgrid::mc::Type **types2;
s_heap_area_t *equals_to1, *equals_to2;
simgrid::mc::Type **types1;
simgrid::mc::Type **types2;
#define types1_(i,j) types1[ MAX_FRAGMENT_PER_BLOCK*(i) + (j)]
#define types2_(i,j) types2[ MAX_FRAGMENT_PER_BLOCK*(i) + (j)]
#define types1_(i,j) types1[ MAX_FRAGMENT_PER_BLOCK*(i) + (j)]
#define types2_(i,j) types2[ MAX_FRAGMENT_PER_BLOCK*(i) + (j)]
/*********************************** Free functions ************************************/
static void heap_area_pair_free(heap_area_pair_t pair)
{
xbt_free(pair);
/*********************************** Free functions ************************************/
static void heap_area_pair_free(heap_area_pair_t pair)
{
xbt_free(pair);
if (current_pair->block1 == block1 && current_pair->block2 == block2
&& current_pair->fragment1 == fragment1
&& current_pair->fragment2 == fragment2)
return 0;
if (current_pair->block1 == block1 && current_pair->block2 == block2
&& current_pair->fragment1 == fragment1
&& current_pair->fragment2 == fragment2)
return 0;
{
if (is_new_heap_area_pair(list, block1, fragment1, block2, fragment2)) {
{
if (is_new_heap_area_pair(list, block1, fragment1, block2, fragment2)) {
pair = xbt_new0(s_heap_area_pair_t, 1);
pair->block1 = block1;
pair->fragment1 = fragment1;
pair = xbt_new0(s_heap_area_pair_t, 1);
pair->block1 = block1;
pair->fragment1 = fragment1;
- unsigned int cursor = 0;
- stack_region_t stack;
-
- xbt_dynar_foreach(stacks_areas, cursor, stack) {
- if (address == stack->address)
- return 1;
- }
-
- return 0;
+ for (auto const& stack : mc_model_checker->process().stack_areas())
+ if (address == stack.address)
+ return true;
+ return false;
- unsigned int cursor = 0;
- stack_region_t stack;
-
- xbt_dynar_foreach(stacks_areas, cursor, stack) {
- if (block == stack->block)
- return 1;
- }
-
- return 0;
+ for (auto const& stack : mc_model_checker->process().stack_areas())
+ if (block == stack.block)
+ return true;
+ return false;
- std::vector<s_mc_heap_ignore_region_t>* i1,
- std::vector<s_mc_heap_ignore_region_t>* i2)
+ std::vector<simgrid::mc::IgnoredHeapRegion>* i1,
+ std::vector<simgrid::mc::IgnoredHeapRegion>* i2)
- mc_diff_info->equals_to1 = NULL;
- mc_diff_info->equals_to2 = NULL;
- mc_diff_info->types1 = NULL;
- mc_diff_info->types2 = NULL;
+ mc_diff_info->equals_to1 = nullptr;
+ mc_diff_info->equals_to2 = nullptr;
+ mc_diff_info->types1 = nullptr;
+ mc_diff_info->types2 = nullptr;
memset(state->equals_to2, 0,
state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(s_heap_area_t));
memset(state->types1, 0,
memset(state->equals_to2, 0,
state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(s_heap_area_t));
memset(state->types1, 0,
const malloc_info* heapinfos2 = snapshot2->read<malloc_info*>(
(std::uint64_t)heapinfo_address, simgrid::mc::ProcessIndexMissing);
const malloc_info* heapinfos2 = snapshot2->read<malloc_info*>(
(std::uint64_t)heapinfo_address, simgrid::mc::ProcessIndexMissing);
const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(heap_region1, &heapinfo_temp1, &heapinfos1[i1], sizeof(malloc_info));
const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(heap_region2, &heapinfo_temp2, &heapinfos2[i1], sizeof(malloc_info));
const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(heap_region1, &heapinfo_temp1, &heapinfos1[i1], sizeof(malloc_info));
const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(heap_region2, &heapinfo_temp2, &heapinfos2[i1], sizeof(malloc_info));
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot1, snapshot2,
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot1, snapshot2,
const malloc_info* heapinfo2b = (const malloc_info*) MC_region_read(
heap_region2, &heapinfo_temp2b, &heapinfos2[i2],
const malloc_info* heapinfo2b = (const malloc_info*) MC_region_read(
heap_region2, &heapinfo_temp2b, &heapinfos2[i2],
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot2, snapshot2,
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot2, snapshot2,
const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(
heap_region1, &heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info));
if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED) {
const malloc_info* heapinfo1 = (const malloc_info*) MC_region_read(
heap_region1, &heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info));
if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED) {
if (i1 == state->heaplimit)
XBT_DEBUG("Number of blocks/fragments not found in heap1 : %d", nb_diff1);
if (i1 == state->heaplimit)
XBT_DEBUG("Number of blocks/fragments not found in heap1 : %d", nb_diff1);
const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(
heap_region2, &heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info));
if (heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED) {
const malloc_info* heapinfo2 = (const malloc_info*) MC_region_read(
heap_region2, &heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info));
if (heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED) {
// Both addreses are in the heap:
res_compare =
compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1,
// Both addreses are in the heap:
res_compare =
compare_heap_area(process_index, addr_pointed1, addr_pointed2, snapshot1,
- snapshot2, previous, NULL, 0);
- if (res_compare == 1) {
+ snapshot2, previous, nullptr, 0);
+ if (res_compare == 1)
ssize_t ignore1, ignore2;
if ((check_ignore > 0)
&& ((ignore1 = heap_comparison_ignore_size(state->to_ignore1, real_area1))
> 0)
&& ((ignore2 = heap_comparison_ignore_size(state->to_ignore2, real_area2))
ssize_t ignore1, ignore2;
if ((check_ignore > 0)
&& ((ignore1 = heap_comparison_ignore_size(state->to_ignore1, real_area1))
> 0)
&& ((ignore2 = heap_comparison_ignore_size(state->to_ignore2, real_area2))
return (MC_snapshot_region_memcmp(real_area1, heap_region1, real_area2, heap_region2, type->byte_size) != 0);
return (MC_snapshot_region_memcmp(real_area1, heap_region1, real_area2, heap_region2, type->byte_size) != 0);
} else {
for(simgrid::mc::Member& member : type->members) {
// TODO, optimize this? (for the offset case)
} else {
for(simgrid::mc::Member& member : type->members) {
// TODO, optimize this? (for the offset case)
void *real_member2 = simgrid::dwarf::resolve_member(
real_area2, type, &member, (simgrid::mc::AddressSpace*) snapshot2, process_index);
res =
void *real_member2 = simgrid::dwarf::resolve_member(
real_area2, type, &member, (simgrid::mc::AddressSpace*) snapshot2, process_index);
res =
- compare_heap_area_with_type(state, process_index, real_member1, real_member2,
+ compare_heap_area_with_type(state, process_index, real_member1, real_member2,
snapshot1, snapshot2,
previous, member.type, -1,
check_ignore, 0);
snapshot1, snapshot2,
previous, member.type, -1,
check_ignore, 0);
* @param area2 Process address for state 2
* @param snapshot1 Snapshot of state 1
* @param snapshot2 Snapshot of state 2
* @param area2 Process address for state 2
* @param snapshot1 Snapshot of state 1
* @param snapshot2 Snapshot of state 2
* @param type_id Type of variable
* @param pointer_level
* @return 0 (same), 1 (different), -1
* @param type_id Type of variable
* @param pointer_level
* @return 0 (same), 1 (different), -1
int type_size = -1;
int offset1 = 0, offset2 = 0;
int new_size1 = -1, new_size2 = -1;
int type_size = -1;
int offset1 = 0, offset2 = 0;
int new_size1 = -1, new_size2 = -1;
|| (block1 > (ssize_t) state->heapsize1) || (block1 < 1)
|| ((char *) area2 < (char *) state->std_heap_copy.heapbase)
|| (block2 > (ssize_t) state->heapsize2) || (block2 < 1)) {
|| (block1 > (ssize_t) state->heapsize1) || (block1 < 1)
|| ((char *) area2 < (char *) state->std_heap_copy.heapbase)
|| (block2 > (ssize_t) state->heapsize2) || (block2 < 1)) {
// Remember (basic) type inference.
// The current data structure only allows us to do this for the whole block.
// Remember (basic) type inference.
// The current data structure only allows us to do this for the whole block.
// Remember (basic) type inference.
// The current data structure only allows us to do this for the whole fragment.
// Remember (basic) type inference.
// The current data structure only allows us to do this for the whole fragment.
- else if (state->types1_(block1, frag1) != NULL
- || state->types2_(block2, frag2) != NULL) {
+ else if (state->types1_(block1, frag1) != nullptr
+ || state->types2_(block2, frag2) != nullptr) {
offset1 = (char *) area1 - (char *) real_addr_frag1;
offset2 = (char *) area2 - (char *) real_addr_frag2;
offset1 = (char *) area1 - (char *) real_addr_frag1;
offset2 = (char *) area2 - (char *) real_addr_frag2;
- if (state->types1_(block1, frag1) != NULL
- && state->types2_(block2, frag2) != NULL) {
+ if (state->types1_(block1, frag1) != nullptr
+ && state->types2_(block2, frag2) != nullptr) {
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types2_(block2, frag2),
offset1, size, snapshot2, process_index);
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types2_(block2, frag2),
offset1, size, snapshot2, process_index);
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types1_(block1, frag1),
offset2, size, snapshot2, process_index);
new_type1 =
get_offset_type(real_addr_frag1, state->types1_(block1, frag1),
offset1, size, snapshot1, process_index);
new_type2 =
get_offset_type(real_addr_frag2, state->types1_(block1, frag1),
offset2, size, snapshot2, process_index);
new_type1 =
get_offset_type(real_addr_frag1, state->types2_(block2, frag2),
offset1, size, snapshot1, process_index);
new_type1 =
get_offset_type(real_addr_frag1, state->types2_(block2, frag2),
offset1, size, snapshot1, process_index);
- if (offset1 == 0 && offset2 == 0) {
- if (!add_heap_area_pair(previous, block1, frag1, block2, frag2)) {
+ if (offset1 == 0 && offset2 == 0
+ && !add_heap_area_pair(previous, block1, frag1, block2, frag2)) {
if (match_pairs) {
match_equals(state, previous);
xbt_dynar_free(&previous);
}
return 0;
}
if (match_pairs) {
match_equals(state, previous);
xbt_dynar_free(&previous);
}
return 0;
}
res_compare =
compare_heap_area_with_type(state, process_index, area1, area2, snapshot1, snapshot2,
previous, type, size, check_ignore,
pointer_level);
res_compare =
compare_heap_area_with_type(state, process_index, area1, area2, snapshot1, snapshot2,
previous, type, size, check_ignore,
pointer_level);
res_compare =
compare_heap_area_without_type(state, process_index, area1, area2, snapshot1, snapshot2,
previous, size, check_ignore);
res_compare =
compare_heap_area_without_type(state, process_index, area1, area2, snapshot1, snapshot2,
previous, size, check_ignore);
frag =
((uintptr_t) (ADDR2UINT(area) % (BLOCKSIZE))) >> heapinfo[block].type;
return (int) heapinfo[block].busy_frag.frag_size[frag];
frag =
((uintptr_t) (ADDR2UINT(area) % (BLOCKSIZE))) >> heapinfo[block].type;
return (int) heapinfo[block].busy_frag.frag_size[frag];