/* mc_diff - Memory snapshooting and comparison */
#include "src/xbt/ex_interface.h" /* internals of backtrace setup */
-#include "xbt/str.h"
#include "mc/mc.h"
#include "xbt/mmalloc.h"
#include "mc/datatypes.h"
+#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"
+#include <xbt/dynar.h>
+
using simgrid::mc::remote;
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_diff, xbt,
"Logging specific to mc_diff in mc");
-extern "C" {
-
/*********************************** Heap comparison ***********************************/
/***************************************************************************************/
-typedef char *type_name;
-
struct XBT_PRIVATE s_mc_diff {
s_xbt_mheap_t std_heap_copy;
std::size_t heaplimit;
return 0;
}
-}
+namespace simgrid {
+namespace mc {
int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2,
std::vector<simgrid::mc::IgnoredHeapRegion>* i1,
memset(state->equals_to2, 0,
state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(s_heap_area_t));
memset(state->types1, 0,
- state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(type_name *));
+ state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(char**));
memset(state->types2, 0,
- state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(type_name *));
+ state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(char**));
return 0;
}
-extern "C" {
-
void reset_heap_information()
{
// TODO, have a robust way to find it in O(1)
static inline
-mc_mem_region_t MC_get_heap_region(mc_snapshot_t snapshot)
+mc_mem_region_t MC_get_heap_region(simgrid::mc::Snapshot* snapshot)
{
size_t n = snapshot->snapshot_regions.size();
for (size_t i=0; i!=n; ++i) {
xbt_die("No heap region");
}
-int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2)
+int mmalloc_compare_heap(simgrid::mc::Snapshot* snapshot1, simgrid::mc::Snapshot* snapshot2)
{
simgrid::mc::Process* process = &mc_model_checker->process();
struct s_mc_diff *state = mc_diff_info;
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
- nullptr, NULL, 0);
+ nullptr, nullptr, 0);
if (res_compare != 1) {
for (k = 1; k < heapinfo2->busy_block.size; k++)
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_block1, addr_block2, snapshot1, snapshot2,
- nullptr, NULL, 0);
+ nullptr, nullptr, 0);
if (res_compare != 1) {
for (k = 1; k < heapinfo2b->busy_block.size; k++)
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot1, snapshot2,
- nullptr, NULL, 0);
+ nullptr, nullptr, 0);
if (res_compare != 1)
equal = 1;
res_compare =
compare_heap_area(simgrid::mc::ProcessIndexMissing, addr_frag1, addr_frag2, snapshot2, snapshot2,
- nullptr, NULL, 0);
+ nullptr, nullptr, 0);
if (res_compare != 1) {
equal = 1;
// TODO, add address
XBT_DEBUG("Block %zu not found (size used = %zu)", i,
heapinfo1->busy_block.busy_size);
- //mmalloc_backtrace_block_display((void*)heapinfo1, i);
}
nb_diff1++;
}
("Block %zu, Fragment %zu not found (size used = %zd)",
i, j,
heapinfo1->busy_frag.frag_size[j]);
- //mmalloc_backtrace_fragment_display((void*)heapinfo1, i, j);
}
nb_diff1++;
}
// TODO, print address of the block
XBT_DEBUG("Block %zu not found (size used = %zu)", i,
heapinfo2->busy_block.busy_size);
- //mmalloc_backtrace_block_display((void*)heapinfo2, i);
}
nb_diff2++;
}
("Block %zu, Fragment %zu not found (size used = %zd)",
i, j,
heapinfo2->busy_frag.frag_size[j]);
- //mmalloc_backtrace_fragment_display((void*)heapinfo2, i, j);
}
nb_diff2++;
}
*/
static int compare_heap_area_without_type(struct s_mc_diff *state, int process_index,
const void *real_area1, const void *real_area2,
- mc_snapshot_t snapshot1,
- mc_snapshot_t snapshot2,
+ simgrid::mc::Snapshot* snapshot1,
+ simgrid::mc::Snapshot* snapshot2,
xbt_dynar_t previous, int size,
int check_ignore)
{
*/
static int compare_heap_area_with_type(struct s_mc_diff *state, int process_index,
const void *real_area1, const void *real_area2,
- mc_snapshot_t snapshot1,
- mc_snapshot_t snapshot2,
+ simgrid::mc::Snapshot* snapshot1,
+ simgrid::mc::Snapshot* snapshot2,
xbt_dynar_t previous, simgrid::mc::Type* type,
int area_size, int check_ignore,
int pointer_level)
*/
static simgrid::mc::Type* get_offset_type(void *real_base_address, simgrid::mc::Type* type,
int offset, int area_size,
- mc_snapshot_t snapshot, int process_index)
+ simgrid::mc::Snapshot* snapshot, int process_index)
{
// Beginning of the block, the infered variable type if the type of the block:
* @param pointer_level
* @return 0 (same), 1 (different), -1
*/
-int compare_heap_area(int process_index, const void *area1, const void *area2, mc_snapshot_t snapshot1,
- mc_snapshot_t snapshot2, xbt_dynar_t previous,
+int compare_heap_area(int process_index, const void *area1, const void *area2, simgrid::mc::Snapshot* snapshot1,
+ simgrid::mc::Snapshot* snapshot2, xbt_dynar_t previous,
simgrid::mc::Type* type, int pointer_level)
{
simgrid::mc::Process* process = &mc_model_checker->process();
int type_size = -1;
int offset1 = 0, offset2 = 0;
int new_size1 = -1, new_size2 = -1;
- simgrid::mc::Type *new_type1 = nullptr, *new_type2 = NULL;
+ simgrid::mc::Type *new_type1 = nullptr, *new_type2 = nullptr;
int match_pairs = 0;
return -1;
}
- if (new_type1 != nullptr && new_type2 != NULL && new_type1 != new_type2) {
+ if (new_type1 != nullptr && new_type2 != nullptr && new_type1 != new_type2) {
type = new_type1;
while (type->byte_size == 0 && type->subtype != nullptr)
return 0;
}
-/*********************************************** Miscellaneous ***************************************************/
-/****************************************************************************************************************/
-
-// Not used and broken code:
-# if 0
-
-// Not used:
-static int get_pointed_area_size(void *area, int heap)
-{
-
- struct s_mc_diff *state = mc_diff_info;
-
- int block, frag;
- malloc_info *heapinfo;
-
- if (heap == 1)
- heapinfo = state->heapinfo1;
- else
- heapinfo = state->heapinfo2;
-
- block =
- ((char *) area -
- (char *) state->std_heap_copy.heapbase) / BLOCKSIZE + 1;
-
- if (((char *) area < (char *) state->std_heap_copy.heapbase)
- || (block > state->heapsize1) || (block < 1))
- return -1;
-
- if (heapinfo[block].type == MMALLOC_TYPE_FREE || heapinfo[block].type == MMALLOC_TYPE_HEAPINFO) { /* Free block */
- return -1;
- else if (heapinfo[block].type == MMALLOC_TYPE_UNFRAGMENTED) /* Complete block */
- return (int) heapinfo[block].busy_block.busy_size;
- else
- frag =
- ((uintptr_t) (ADDR2UINT(area) % (BLOCKSIZE))) >> heapinfo[block].type;
- return (int) heapinfo[block].busy_frag.frag_size[frag];
-
-}
-
-#ifndef max
-#define max( a, b ) ( ((a) > (b)) ? (a) : (b) )
-#endif
-
-// Not used:
-int mmalloc_linear_compare_heap(xbt_mheap_t heap1, xbt_mheap_t heap2)
-{
-
- struct s_mc_diff *state = mc_diff_info;
-
- if (heap1 == nullptr && heap1 == NULL) {
- XBT_DEBUG("Malloc descriptors null");
- return 0;
- }
-
- if (heap1->heaplimit != heap2->heaplimit) {
- XBT_DEBUG("Different limit of valid info table indices");
- return 1;
- }
-
- /* Heap information */
- state->heaplimit = ((struct mdesc *) heap1)->heaplimit;
-
- state->std_heap_copy = *mc_model_checker->process().get_heap();
-
- state->heapbase1 = (char *) heap1 + BLOCKSIZE;
- state->heapbase2 = (char *) heap2 + BLOCKSIZE;
-
- state->heapinfo1 =
- (malloc_info *) ((char *) heap1 +
- ((uintptr_t)
- ((char *) heap1->heapinfo - (char *) state->s_heap)));
- state->heapinfo2 =
- (malloc_info *) ((char *) heap2 +
- ((uintptr_t)
- ((char *) heap2->heapinfo - (char *) state->s_heap)));
-
- state->heapsize1 = heap1->heapsize;
- state->heapsize2 = heap2->heapsize;
-
- /* Start comparison */
- size_t i, j, k;
- void *addr_block1, *addr_block2, *addr_frag1, *addr_frag2;
-
- int distance = 0;
-
- /* Check busy blocks */
-
- i = 1;
-
- while (i <= state->heaplimit) {
-
- addr_block1 =
- ((void *) (((ADDR2UINT(i)) - 1) * BLOCKSIZE +
- (char *) state->heapbase1));
- addr_block2 =
- ((void *) (((ADDR2UINT(i)) - 1) * BLOCKSIZE +
- (char *) state->heapbase2));
-
- if (state->heapinfo1[i].type != state->heapinfo2[i].type) {
-
- distance += BLOCKSIZE;
- XBT_DEBUG("Different type of blocks (%zu) : %d - %d -> distance = %d", i,
- state->heapinfo1[i].type, state->heapinfo2[i].type, distance);
- i++;
-
- } else {
-
- if (state->heapinfo1[i].type == MMALLOC_TYPE_FREE
- || state->heapinfo1[i].type == MMALLOC_TYPE_HAPINFO) { /* Free block */
- i++;
- continue;
- }
-
- if (state->heapinfo1[i].type == MMALLOC_TYPE_UNFRAGMENTED) { /* Large block */
-
- if (state->heapinfo1[i].busy_block.size !=
- state->heapinfo2[i].busy_block.size) {
- distance +=
- BLOCKSIZE * max(state->heapinfo1[i].busy_block.size,
- state->heapinfo2[i].busy_block.size);
- i += max(state->heapinfo1[i].busy_block.size,
- state->heapinfo2[i].busy_block.size);
- XBT_DEBUG
- ("Different larger of cluster at block %zu : %zu - %zu -> distance = %d",
- i, state->heapinfo1[i].busy_block.size,
- state->heapinfo2[i].busy_block.size, distance);
- continue;
- }
-
- /*if(heapinfo1[i].busy_block.busy_size != heapinfo2[i].busy_block.busy_size){
- distance += max(heapinfo1[i].busy_block.busy_size, heapinfo2[i].busy_block.busy_size);
- i += max(heapinfo1[i].busy_block.size, heapinfo2[i].busy_block.size);
- XBT_DEBUG("Different size used oin large cluster at block %zu : %zu - %zu -> distance = %d", i, heapinfo1[i].busy_block.busy_size, heapinfo2[i].busy_block.busy_size, distance);
- continue;
- } */
-
- k = 0;
-
- //while(k < (heapinfo1[i].busy_block.busy_size)){
- while (k < state->heapinfo1[i].busy_block.size * BLOCKSIZE) {
- if (memcmp((char *) addr_block1 + k, (char *) addr_block2 + k, 1) !=
- 0) {
- distance++;
- }
- k++;
- }
-
- i++;
-
- } else { /* Fragmented block */
-
- for (j = 0; j < (size_t) (BLOCKSIZE >> state->heapinfo1[i].type); j++) {
-
- addr_frag1 =
- (void *) ((char *) addr_block1 + (j << state->heapinfo1[i].type));
- addr_frag2 =
- (void *) ((char *) addr_block2 + (j << state->heapinfo2[i].type));
-
- if (state->heapinfo1[i].busy_frag.frag_size[j] == 0
- && state->heapinfo2[i].busy_frag.frag_size[j] == 0) {
- continue;
- }
-
-
- /*if(heapinfo1[i].busy_frag.frag_size[j] != heapinfo2[i].busy_frag.frag_size[j]){
- distance += max(heapinfo1[i].busy_frag.frag_size[j], heapinfo2[i].busy_frag.frag_size[j]);
- XBT_DEBUG("Different size used in fragment %zu in block %zu : %d - %d -> distance = %d", j, i, heapinfo1[i].busy_frag.frag_size[j], heapinfo2[i].busy_frag.frag_size[j], distance);
- continue;
- } */
-
- k = 0;
-
- //while(k < max(heapinfo1[i].busy_frag.frag_size[j], heapinfo2[i].busy_frag.frag_size[j])){
- while (k < (BLOCKSIZE / (BLOCKSIZE >> state->heapinfo1[i].type))) {
- if (memcmp((char *) addr_frag1 + k, (char *) addr_frag2 + k, 1) !=
- 0) {
- distance++;
- }
- k++;
- }
-
- }
-
- i++;
-
- }
-
- }
-
- }
-
- return distance;
-
}
-#endif
-
}