typedef char* type_name;
struct s_mm_diff {
- void *s_heap, *heapbase1, *heapbase2;
+ /** \brief Base address of the real heap */
+ void *s_heap;
+ /** \brief Base address of the first heap snapshot */
+ void *heapbase1;
+ /** \brief Base address of the second heap snapshot */
+ void *heapbase2;
malloc_info *heapinfo1, *heapinfo2;
size_t heaplimit;
// Number of blocks in the heaps:
size_t heapsize1, heapsize2;
xbt_dynar_t to_ignore1, to_ignore2;
- heap_area_t *equals_to1, *equals_to2;
+ s_heap_area_t *equals_to1, *equals_to2;
dw_type_t *types1, *types2;
size_t available;
};
/************************************************************************************/
-static heap_area_t new_heap_area(int block, int fragment){
- heap_area_t area = NULL;
- area = xbt_new0(s_heap_area_t, 1);
- area->block = block;
- area->fragment = fragment;
+static s_heap_area_t make_heap_area(int block, int fragment){
+ s_heap_area_t area;
+ area.valid = 1;
+ area.block = block;
+ area.fragment = fragment;
return area;
}
unsigned int cursor = 0;
heap_area_pair_t current_pair;
- heap_area_t previous_area;
xbt_dynar_foreach(list, cursor, current_pair){
if(current_pair->fragment1 != -1){
- if(state->equals_to1_(current_pair->block1,current_pair->fragment1) != NULL){
- previous_area = state->equals_to1_(current_pair->block1,current_pair->fragment1);
- heap_area_free(state->equals_to2_(previous_area->block,previous_area->fragment));
- state->equals_to2_(previous_area->block,previous_area->fragment) = NULL;
- heap_area_free(previous_area);
- }
- if(state->equals_to2_(current_pair->block2,current_pair->fragment2) != NULL){
- previous_area = state->equals_to2_(current_pair->block2,current_pair->fragment2);
- heap_area_free(state->equals_to1_(previous_area->block,previous_area->fragment));
- state->equals_to1_(previous_area->block,previous_area->fragment) = NULL;
- heap_area_free(previous_area);
- }
-
- state->equals_to1_(current_pair->block1,current_pair->fragment1) = new_heap_area(current_pair->block2, current_pair->fragment2);
- state->equals_to2_(current_pair->block2,current_pair->fragment2) = new_heap_area(current_pair->block1, current_pair->fragment1);
+ state->equals_to1_(current_pair->block1,current_pair->fragment1) = make_heap_area(current_pair->block2, current_pair->fragment2);
+ state->equals_to2_(current_pair->block2,current_pair->fragment2) = make_heap_area(current_pair->block1, current_pair->fragment1);
}else{
- if(state->equals_to1_(current_pair->block1,0) != NULL){
- previous_area = state->equals_to1_(current_pair->block1,0);
- heap_area_free(state->equals_to2_(previous_area->block,0));
- state->equals_to2_(previous_area->block,0) = NULL;
- heap_area_free(previous_area);
- }
- if(state->equals_to2_(current_pair->block2,0) != NULL){
- previous_area = state->equals_to2_(current_pair->block2,0);
- heap_area_free(state->equals_to1_(previous_area->block,0));
- state->equals_to1_(previous_area->block,0) = NULL;
- heap_area_free(previous_area);
- }
-
- state->equals_to1_(current_pair->block1,0) = new_heap_area(current_pair->block2, current_pair->fragment2);
- state->equals_to2_(current_pair->block2,0) = new_heap_area(current_pair->block1, current_pair->fragment1);
+ state->equals_to1_(current_pair->block1,0) = make_heap_area(current_pair->block2, current_pair->fragment2);
+ state->equals_to2_(current_pair->block2,0) = make_heap_area(current_pair->block1, current_pair->fragment1);
}
*/
static int equal_blocks(struct s_mm_diff *state, int b1, int b2){
- if(state->equals_to1_(b1,0)->block == b2 && state->equals_to2_(b2,0)->block == b1)
+ if(state->equals_to1_(b1,0).block == b2 && state->equals_to2_(b2,0).block == b1)
return 1;
return 0;
*/
static int equal_fragments(struct s_mm_diff *state, int b1, int f1, int b2, int f2){
- if(state->equals_to1_(b1,f1)->block == b2
- && state->equals_to1_(b1,f1)->fragment == f2
- && state->equals_to2_(b2,f2)->block == b1
- && state->equals_to2_(b2,f2)->fragment == f1)
+ if(state->equals_to1_(b1,f1).block == b2
+ && state->equals_to1_(b1,f1).fragment == f2
+ && state->equals_to2_(b2,f2).block == b1
+ && state->equals_to2_(b2,f2).fragment == f1)
return 1;
return 0;
int init_heap_information(xbt_mheap_t heap1, xbt_mheap_t heap2, xbt_dynar_t i1, xbt_dynar_t i2){
if(mm_diff_info==NULL) {
mm_diff_info = xbt_new0(struct s_mm_diff, 1);
+ mm_diff_info->equals_to1 = NULL;
+ mm_diff_info->equals_to2 = NULL;
+ mm_diff_info->types1 = NULL;
+ mm_diff_info->types2 = NULL;
}
struct s_mm_diff *state = mm_diff_info;
state->heaplimit = ((struct mdesc *)heap1)->heaplimit;
+ // Mamailloute in order to find the base address of the main heap:
+ // This heavily depends on the structure of MC: we need to move this code into MC.
+ // (STD_HEAP_SIZE comes from mc.h anyway)
state->s_heap = (char *)mmalloc_get_current_heap() - STD_HEAP_SIZE - xbt_pagesize;
state->heapbase1 = (char *)heap1 + BLOCKSIZE;
state->to_ignore1 = i1;
state-> to_ignore2 = i2;
- state->equals_to1 = calloc(state->heaplimit * MAX_FRAGMENT_PER_BLOCK, sizeof(heap_area_t *));
- state->types1 = calloc(state->heaplimit * MAX_FRAGMENT_PER_BLOCK, sizeof(type_name *));
- state->equals_to2 = calloc(state->heaplimit * MAX_FRAGMENT_PER_BLOCK, sizeof(heap_area_t *));
- state->types2 = calloc(state->heaplimit * MAX_FRAGMENT_PER_BLOCK, sizeof(type_name *));
+ if(state->heaplimit > state->available) {
+ state->equals_to1 = realloc(state->equals_to1, state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(s_heap_area_t));
+ state->types1 = realloc(state->types1, state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(type_name *));
+ state->equals_to2 = realloc(state->equals_to2, state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(s_heap_area_t));
+ state->types2 = realloc(state->types2, state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(type_name *));
+ state->available = state->heaplimit;
+ }
- state->available = state->heaplimit;
+ memset(state->equals_to1, 0, state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(s_heap_area_t));
+ 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 *));
+ memset(state->types2, 0, state->heaplimit * MAX_FRAGMENT_PER_BLOCK * sizeof(type_name *));
if(MC_is_active()){
MC_ignore_global_variable("mm_diff_info");
void reset_heap_information(){
- struct s_mm_diff *state = mm_diff_info;
-
- size_t i;
- for(i=0; i!=state->heaplimit * MAX_FRAGMENT_PER_BLOCK; ++i)
- xbt_free(state->equals_to1[i]);
- for(i=0; i!=state->heaplimit * MAX_FRAGMENT_PER_BLOCK; ++i)
- xbt_free(state->equals_to2[i]);
-
- free(state->equals_to1);
- free(state->equals_to2);
- free(state->types1);
- free(state->types2);
-
- state->s_heap = NULL, state->heapbase1 = NULL, state->heapbase2 = NULL;
- state->heapinfo1 = NULL, state->heapinfo2 = NULL;
- state->heaplimit = 0, state->heapsize1 = 0, state->heapsize2 = 0;
- state->to_ignore1 = NULL, state->to_ignore2 = NULL;
- state->equals_to1 = NULL, state->equals_to2 = NULL;
- state->types1 = NULL, state->types2 = NULL;
-
}
int mmalloc_compare_heap(mc_snapshot_t snapshot1, mc_snapshot_t snapshot2, xbt_mheap_t heap1, xbt_mheap_t heap2){
if(is_stack(addr_block1)){
for(k=0; k < state->heapinfo1[i1].busy_block.size; k++)
- state->equals_to1_(i1+k,0) = new_heap_area(i1, -1);
+ state->equals_to1_(i1+k,0) = make_heap_area(i1, -1);
for(k=0; k < state->heapinfo2[i1].busy_block.size; k++)
- state->equals_to2_(i1+k,0) = new_heap_area(i1, -1);
+ state->equals_to2_(i1+k,0) = make_heap_area(i1, -1);
i1 += state->heapinfo1[i1].busy_block.size;
continue;
}
- if(state->equals_to1_(i1,0) != NULL){
+ if(state->equals_to1_(i1,0).valid){
i1++;
continue;
}
/* Try first to associate to same block in the other heap */
if(state->heapinfo2[i1].type == state->heapinfo1[i1].type){
- if(state->equals_to2_(i1,0) == NULL){
+ if(state->equals_to2_(i1,0).valid == 0){
addr_block2 = ((void*) (((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)((xbt_mheap_t)state->s_heap)->heapbase));
if(res_compare != 1){
for(k=1; k < state->heapinfo2[i1].busy_block.size; k++)
- state->equals_to2_(i1+k,0) = new_heap_area(i1, -1);
+ state->equals_to2_(i1+k,0) = make_heap_area(i1, -1);
for(k=1; k < state->heapinfo1[i1].busy_block.size; k++)
- state->equals_to1_(i1+k,0) = new_heap_area(i1, -1);
+ state->equals_to1_(i1+k,0) = make_heap_area(i1, -1);
equal = 1;
i1 += state->heapinfo1[i1].busy_block.size;
}
continue;
}
- if(state->equals_to2_(i2,0) != NULL){
+ if(state->equals_to2_(i2,0).valid){
i2++;
continue;
}
if(res_compare != 1 ){
for(k=1; k < state->heapinfo2[i2].busy_block.size; k++)
- state->equals_to2_(i2+k,0) = new_heap_area(i1, -1);
+ state->equals_to2_(i2+k,0) = make_heap_area(i1, -1);
for(k=1; k < state->heapinfo1[i1].busy_block.size; k++)
- state->equals_to1_(i1+k,0) = new_heap_area(i2, -1);
+ state->equals_to1_(i1+k,0) = make_heap_area(i2, -1);
equal = 1;
i1 += state->heapinfo1[i1].busy_block.size;
}
if(state->heapinfo1[i1].busy_frag.frag_size[j1] == -1) /* Free fragment */
continue;
- if(state->equals_to1_(i1,j1) != NULL)
+ if(state->equals_to1_(i1,j1).valid)
continue;
addr_frag1 = (void*) ((char *)addr_block1 + (j1 << state->heapinfo1[i1].type));
/* Try first to associate to same fragment in the other heap */
if(state->heapinfo2[i1].type == state->heapinfo1[i1].type){
- if(state->equals_to2_(i1,j1) == NULL){
+ if(state->equals_to2_(i1,j1).valid == 0){
addr_block2 = ((void*) (((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)((xbt_mheap_t)state->s_heap)->heapbase));
addr_frag2 = (void*) ((char *)addr_block2 + (j1 << ((xbt_mheap_t)state->s_heap)->heapinfo[i1].type));
if(i2 == i1 && j2 == j1)
continue;
- if(state->equals_to2_(i2,j2) != NULL)
+ if(state->equals_to2_(i2,j2).valid)
continue;
addr_block2 = ((void*) (((ADDR2UINT(i2)) - 1) * BLOCKSIZE + (char*)((xbt_mheap_t)state->s_heap)->heapbase));
if(state->heapinfo1[i].type == 0){
if(i1 == state->heaplimit){
if(state->heapinfo1[i].busy_block.busy_size > 0){
- if(state->equals_to1_(i,0) == NULL){
+ if(state->equals_to1_(i,0).valid == 0){
if(XBT_LOG_ISENABLED(mm_diff, xbt_log_priority_debug)){
addr_block1 = ((void*) (((ADDR2UINT(i)) - 1) * BLOCKSIZE + (char*)state->heapbase1));
XBT_DEBUG("Block %zu (%p) not found (size used = %zu)", i, addr_block1, state->heapinfo1[i].busy_block.busy_size);
for(j=0; j < (size_t) (BLOCKSIZE >> state->heapinfo1[i].type); j++){
if(i1== state->heaplimit){
if(state->heapinfo1[i].busy_frag.frag_size[j] > 0){
- if(state->equals_to1_(i,j) == NULL){
+ if(state->equals_to1_(i,j).valid == 0){
if(XBT_LOG_ISENABLED(mm_diff, xbt_log_priority_debug)){
addr_frag1 = (void*) ((char *)addr_block1 + (j << state->heapinfo1[i].type));
real_addr_frag1 = (void*) ((char *)real_addr_block1 + (j << ((struct mdesc *)state->s_heap)->heapinfo[i].type));
if(state->heapinfo2[i].type == 0){
if(i1 == state->heaplimit){
if(state->heapinfo2[i].busy_block.busy_size > 0){
- if(state->equals_to2_(i,0) == NULL){
+ if(state->equals_to2_(i,0).valid == 0){
if(XBT_LOG_ISENABLED(mm_diff, xbt_log_priority_debug)){
addr_block2 = ((void*) (((ADDR2UINT(i)) - 1) * BLOCKSIZE + (char*)state->heapbase2));
XBT_DEBUG("Block %zu (%p) not found (size used = %zu)", i, addr_block2, state->heapinfo2[i].busy_block.busy_size);
for(j=0; j < (size_t) (BLOCKSIZE >> state->heapinfo2[i].type); j++){
if(i1 == state->heaplimit){
if(state->heapinfo2[i].busy_frag.frag_size[j] > 0){
- if(state->equals_to2_(i,j) == NULL){
+ if(state->equals_to2_(i,j).valid == 0){
if(XBT_LOG_ISENABLED(mm_diff, xbt_log_priority_debug)){
addr_frag2 = (void*) ((char *)addr_block2 + (j << state->heapinfo2[i].type));
real_addr_frag2 = (void*) ((char *)real_addr_block2 + (j << ((struct mdesc *)state->s_heap)->heapinfo[i].type));
// TODO, lookup variable type from block type as done for fragmented blocks
- if(state->equals_to1_(block1,0) != NULL && state->equals_to2_(block2,0) != NULL){
+ if(state->equals_to1_(block1,0).valid && state->equals_to2_(block2,0).valid){
if(equal_blocks(state, block1, block2)){
if(match_pairs){
match_equals(state, previous);
}
// Check if the blocks are already matched together:
- if(state->equals_to1_(block1,frag1) != NULL && state->equals_to2_(block2,frag2) != NULL){
+ if(state->equals_to1_(block1,frag1).valid && state->equals_to2_(block2,frag2).valid){
if(equal_fragments(state, block1, frag1, block2, frag2)){
if(match_pairs){
match_equals(state, previous);
