#include "src/xbt/mmalloc/mmprivate.h"
#if HAVE_SMPI
-#include "src/smpi/include/private.h"
#include "src/smpi/include/private.hpp"
#endif
-#include "src/mc/mc_forward.hpp"
-#include "src/mc/mc_private.h"
-#include "src/mc/mc_smx.h"
-#include "src/mc/mc_dwarf.hpp"
#include "src/mc/Frame.hpp"
#include "src/mc/ObjectInformation.hpp"
+#include "src/mc/Type.hpp"
#include "src/mc/Variable.hpp"
-#include "src/mc/mc_private.h"
-#include "src/mc/mc_snapshot.h"
#include "src/mc/mc_dwarf.hpp"
-#include "src/mc/Type.hpp"
+#include "src/mc/mc_forward.hpp"
+#include "src/mc/mc_private.hpp"
+#include "src/mc/mc_smx.hpp"
+#include "src/mc/mc_snapshot.hpp"
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_compare, xbt, "Logging specific to mc_compare in mc");
class HeapLocation {
public:
- int block = 0;
- int fragment = 0;
+ int block_ = 0;
+ int fragment_ = 0;
HeapLocation() = default;
- HeapLocation(int block, int fragment = 0) : block(block), fragment(fragment) {}
+ HeapLocation(int block, int fragment = 0) : block_(block), fragment_(fragment) {}
bool operator==(HeapLocation const& that) const
{
- return block == that.block && fragment == that.fragment;
+ return block_ == that.block_ && fragment_ == that.fragment_;
}
bool operator<(HeapLocation const& that) const
{
- return std::make_pair(block, fragment)
- < std::make_pair(that.block, that.fragment);
+ return std::make_pair(block_, fragment_) < std::make_pair(that.block_, that.fragment_);
}
};
class HeapArea : public HeapLocation {
public:
- bool valid = false;
+ bool valid_ = false;
HeapArea() = default;
- explicit HeapArea(int block) : valid(true), block(block) {}
- HeapArea(int block, int fragment) : valid(true), block(block), fragment(fragment) {}
+ explicit HeapArea(int block) : valid_(true) { block_ = block; }
+ HeapArea(int block, int fragment) : valid_(true)
+ {
+ block_ = block;
+ fragment_ = fragment;
+ }
};
class ProcessComparisonState {
*/
bool blocksEqual(int b1, int b2) const
{
- return this->equals_to1_(b1, 0).block == b2
- && this->equals_to2_(b2, 0).block == b1;
+ return this->equals_to1_(b1, 0).block_ == b2 && this->equals_to2_(b2, 0).block_ == b1;
}
/** Check whether two fragments are known to be matching
*/
int fragmentsEqual(int b1, int f1, int b2, int f2) const
{
- return this->equals_to1_(b1, f1).block == b2
- && this->equals_to1_(b1, f1).fragment == f2
- && this->equals_to2_(b2, f2).block == b1
- && this->equals_to2_(b2, f2).fragment == f1;
+ return this->equals_to1_(b1, f1).block_ == b2 && this->equals_to1_(b1, f1).fragment_ == f2 &&
+ this->equals_to2_(b2, f2).block_ == b1 && this->equals_to2_(b2, f2).fragment_ == f1;
}
void match_equals(HeapLocationPairs* list);
void StateComparator::match_equals(HeapLocationPairs* list)
{
for (auto const& pair : *list) {
- if (pair[0].fragment != -1) {
- this->equals_to1_(pair[0].block, pair[0].fragment) = simgrid::mc::HeapArea(pair[1].block, pair[1].fragment);
- this->equals_to2_(pair[1].block, pair[1].fragment) = simgrid::mc::HeapArea(pair[0].block, pair[0].fragment);
+ if (pair[0].fragment_ != -1) {
+ this->equals_to1_(pair[0].block_, pair[0].fragment_) = simgrid::mc::HeapArea(pair[1].block_, pair[1].fragment_);
+ this->equals_to2_(pair[1].block_, pair[1].fragment_) = simgrid::mc::HeapArea(pair[0].block_, pair[0].fragment_);
} else {
- this->equals_to1_(pair[0].block, 0) = simgrid::mc::HeapArea(pair[1].block, pair[1].fragment);
- this->equals_to2_(pair[1].block, 0) = simgrid::mc::HeapArea(pair[0].block, pair[0].fragment);
+ this->equals_to1_(pair[0].block_, 0) = simgrid::mc::HeapArea(pair[1].block_, pair[1].fragment_);
+ this->equals_to2_(pair[1].block_, 0) = simgrid::mc::HeapArea(pair[0].block_, pair[0].fragment_);
}
}
}
continue;
}
- if (state.equals_to1_(i1, 0).valid) {
+ if (state.equals_to1_(i1, 0).valid_) {
i1++;
continue;
}
equal = 0;
/* Try first to associate to same block in the other heap */
- if (heapinfo2->type == heapinfo1->type
- && state.equals_to2_(i1, 0).valid == 0) {
+ if (heapinfo2->type == heapinfo1->type && state.equals_to2_(i1, 0).valid_ == 0) {
addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
int res_compare = compare_heap_area(state, simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2,
snapshot1, snapshot2, nullptr, nullptr, 0);
continue;
}
- if (state.equals_to2_(i2, 0).valid) {
+ if (state.equals_to2_(i2, 0).valid_) {
i2++;
continue;
}
XBT_DEBUG("Block %zu not found (size_used = %zu, addr = %p)", i1, heapinfo1->busy_block.busy_size, addr_block1);
i1 = state.heaplimit + 1;
nb_diff1++;
- //i1++;
}
} else { /* Fragmented block */
for (j1 = 0; j1 < (size_t) (BLOCKSIZE >> heapinfo1->type); j1++) {
- if (heapinfo1->busy_frag.frag_size[j1] == -1) /* Free fragment */
+ if (heapinfo1->busy_frag.frag_size[j1] == -1) /* Free fragment_ */
continue;
- if (state.equals_to1_(i1, j1).valid)
+ if (state.equals_to1_(i1, j1).valid_)
continue;
addr_frag1 = (void*)((char*)addr_block1 + (j1 << heapinfo1->type));
i2 = 1;
equal = 0;
- /* Try first to associate to same fragment in the other heap */
- if (heapinfo2->type == heapinfo1->type && not state.equals_to2_(i1, j1).valid) {
+ /* Try first to associate to same fragment_ in the other heap */
+ if (heapinfo2->type == heapinfo1->type && not state.equals_to2_(i1, j1).valid_) {
addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE +
(char *) state.std_heap_copy.heapbase;
addr_frag2 =
if (i2 == i1 && j2 == j1)
continue;
- if (state.equals_to2_(i2, j2).valid)
+ if (state.equals_to2_(i2, j2).valid_)
continue;
addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase;
}
if (not equal) {
- XBT_DEBUG("Block %zu, fragment %zu not found (size_used = %zd, address = %p)\n", i1, j1,
+ XBT_DEBUG("Block %zu, fragment_ %zu not found (size_used = %zd, address = %p)\n", i1, j1,
heapinfo1->busy_frag.frag_size[j1], addr_frag1);
i1 = state.heaplimit + 1;
nb_diff1++;
}
}
- /* All blocks/fragments are equal to another block/fragment ? */
+ /* All blocks/fragments are equal to another block/fragment_ ? */
size_t i = 1;
size_t j = 0;
heap_region1, &heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info));
if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED && i1 == state.heaplimit && heapinfo1->busy_block.busy_size > 0 &&
- not state.equals_to1_(i, 0).valid) {
+ not state.equals_to1_(i, 0).valid_) {
XBT_DEBUG("Block %zu not found (size used = %zu)", i, heapinfo1->busy_block.busy_size);
nb_diff1++;
}
if (heapinfo1->type <= 0)
continue;
for (j = 0; j < (size_t) (BLOCKSIZE >> heapinfo1->type); j++)
- if (i1 == state.heaplimit && heapinfo1->busy_frag.frag_size[j] > 0 && not state.equals_to1_(i, j).valid) {
+ if (i1 == state.heaplimit && heapinfo1->busy_frag.frag_size[j] > 0 && not state.equals_to1_(i, j).valid_) {
XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)", i, j, heapinfo1->busy_frag.frag_size[j]);
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 && i1 == state.heaplimit && heapinfo2->busy_block.busy_size > 0 &&
- not state.equals_to2_(i, 0).valid) {
+ not state.equals_to2_(i, 0).valid_) {
XBT_DEBUG("Block %zu not found (size used = %zu)", i,
heapinfo2->busy_block.busy_size);
nb_diff2++;
continue;
for (j = 0; j < (size_t) (BLOCKSIZE >> heapinfo2->type); j++)
- if (i1 == state.heaplimit && heapinfo2->busy_frag.frag_size[j] > 0 && not state.equals_to2_(i, j).valid) {
+ if (i1 == state.heaplimit && heapinfo2->busy_frag.frag_size[j] > 0 && not state.equals_to2_(i, j).valid_) {
XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)",
i, j, heapinfo2->busy_frag.frag_size[j]);
nb_diff2++;
// TODO, lookup variable type from block type as done for fragmented blocks
- if (state.equals_to1_(block1, 0).valid && state.equals_to2_(block2, 0).valid && state.blocksEqual(block1, block2)) {
+ if (state.equals_to1_(block1, 0).valid_ && state.equals_to2_(block2, 0).valid_ &&
+ state.blocksEqual(block1, block2)) {
if (match_pairs)
state.match_equals(previous);
return 0;
ssize_t frag1 = ((uintptr_t)(ADDR2UINT(area1) % (BLOCKSIZE))) >> heapinfo1->type;
ssize_t frag2 = ((uintptr_t)(ADDR2UINT(area2) % (BLOCKSIZE))) >> heapinfo2->type;
- // Process address of the fragment:
+ // Process address of the fragment_:
void* real_addr_frag1 = (void*)((char*)real_addr_block1 + (frag1 << heapinfo1->type));
void* real_addr_frag2 = (void*)((char*)real_addr_block2 + (frag2 << heapinfo2->type));
}
// Check if the blocks are already matched together:
- if (state.equals_to1_(block1, frag1).valid && state.equals_to2_(block2, frag2).valid) {
+ if (state.equals_to1_(block1, frag1).valid_ && state.equals_to2_(block2, frag2).valid_) {
if (offset1==offset2 && state.fragmentsEqual(block1, frag1, block2, frag2)) {
if (match_pairs)
state.match_equals(previous);
return 1;
}
- // Size of the fragment:
+ // Size of the fragment_:
size = heapinfo1->busy_frag.frag_size[frag1];
// Remember (basic) type inference.
- // The current data structure only allows us to do this for the whole fragment.
+ // The current data structure only allows us to do this for the whole fragment_.
if (type != nullptr && area1 == real_addr_frag1)
state.types1_(block1, frag1) = type;
if (type != nullptr && area2 == real_addr_frag2)
pointer_level++;
- // Some cases are not handled here:
- // * the pointers lead to different areas (one to the heap, the other to the RW segment ...);
- // * a pointer leads to the read-only segment of the current object;
- // * a pointer lead to a different ELF object.
-
- if (addr_pointed1 > process->heap_address
- && addr_pointed1 < mc_snapshot_get_heap_end(snapshot1)) {
- if (not(addr_pointed2 > process->heap_address && addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)))
- return 1;
- // The pointers are both in the heap:
- return simgrid::mc::compare_heap_area(state,
- process_index, addr_pointed1, addr_pointed2, snapshot1,
- snapshot2, nullptr, type->subtype, pointer_level);
- }
+ // Some cases are not handled here:
+ // * the pointers lead to different areas (one to the heap, the other to the RW segment ...)
+ // * a pointer leads to the read-only segment of the current object
+ // * a pointer lead to a different ELF object
+
+ if (addr_pointed1 > process->heap_address && addr_pointed1 < mc_snapshot_get_heap_end(snapshot1)) {
+ if (not(addr_pointed2 > process->heap_address && addr_pointed2 < mc_snapshot_get_heap_end(snapshot2)))
+ return 1;
+ // The pointers are both in the heap:
+ return simgrid::mc::compare_heap_area(state, process_index, addr_pointed1, addr_pointed2, snapshot1, snapshot2,
+ nullptr, type->subtype, pointer_level);
+ } else if (region1->contain(simgrid::mc::remote(addr_pointed1))) {
// The pointers are both in the current object R/W segment:
- else if (region1->contain(simgrid::mc::remote(addr_pointed1))) {
- if (not region2->contain(simgrid::mc::remote(addr_pointed2)))
- return 1;
- if (not type->type_id)
- return (addr_pointed1 != addr_pointed2);
- else
- return compare_areas_with_type(state, process_index,
- addr_pointed1, snapshot1, region1,
- addr_pointed2, snapshot2, region2,
- type->subtype, pointer_level);
- }
+ if (not region2->contain(simgrid::mc::remote(addr_pointed2)))
+ return 1;
+ if (not type->type_id)
+ return (addr_pointed1 != addr_pointed2);
+ else
+ return compare_areas_with_type(state, process_index, addr_pointed1, snapshot1, region1, addr_pointed2,
+ snapshot2, region2, type->subtype, pointer_level);
+ } else {
// TODO, We do not handle very well the case where
// it belongs to a different (non-heap) region from the current one.
- else
- return (addr_pointed1 != addr_pointed2);
-
+ return (addr_pointed1 != addr_pointed2);
+ }
break;
}
case DW_TAG_structure_type: