extern char *xbt_binary_name;
-void mmalloc_backtrace_display(xbt_mheap_t mdp, void *ptr){
- size_t block = BLOCK(ptr);
- int type;
- xbt_ex_t e;
-
- if ((char *) ptr < (char *) mdp->heapbase || block > mdp->heapsize) {
- fprintf(stderr,"Ouch, this pointer is not mine. I cannot display its backtrace. I refuse it to death!!\n");
- abort();
- }
-
- type = mdp->heapinfo[block].type;
+void mmalloc_backtrace_block_display(xbt_mheap_t heap, size_t block){
- if (type != 0) {
- //fprintf(stderr,"Only full blocks are backtraced for now. Ignoring your request.\n");
- return;
- }
- if (mdp->heapinfo[block].busy_block.bt_size == 0) {
- fprintf(stderr,"No backtrace available for that block, sorry.\n");
- return;
- }
-
- memcpy(&e.bt,&(mdp->heapinfo[block].busy_block.bt),sizeof(void*)*XBT_BACKTRACE_SIZE);
- e.used = mdp->heapinfo[block].busy_block.bt_size;
-
- xbt_ex_setup_backtrace(&e);
- if (e.used == 0) {
- fprintf(stderr, "(backtrace not set)\n");
- } else if (e.bt_strings == NULL) {
- fprintf(stderr, "(backtrace not ready to be computed. %s)\n",xbt_binary_name?"Dunno why":"xbt_binary_name not setup yet");
- } else {
- int i;
-
- fprintf(stderr, "Backtrace of where the block %p was malloced (%d frames):\n",ptr,e.used);
- for (i = 0; i < e.used; i++) /* no need to display "xbt_backtrace_display" */{
- fprintf(stderr,"%d",i);fflush(NULL);
- fprintf(stderr, "---> %s\n", e.bt_strings[i] + 4);
- }
- }
-}
-
-
-void mmalloc_backtrace_block_display(xbt_mheap_t mdp, size_t block){
-
- int type;
xbt_ex_t e;
- type = mdp->heapinfo[block].type;
-
- if (type != 0) {
- fprintf(stderr,"Only full blocks are backtraced for now. Ignoring your request.\n");
- return;
- }
- if (mdp->heapinfo[block].busy_block.bt_size == 0) {
+ if (heap->heapinfo[block].busy_block.bt_size == 0) {
fprintf(stderr,"No backtrace available for that block, sorry.\n");
return;
}
- memcpy(&e.bt,&(mdp->heapinfo[block].busy_block.bt),sizeof(void*)*XBT_BACKTRACE_SIZE);
- e.used = mdp->heapinfo[block].busy_block.bt_size;
+ memcpy(&e.bt,&(heap->heapinfo[block].busy_block.bt),sizeof(void*)*XBT_BACKTRACE_SIZE);
+ e.used = heap->heapinfo[block].busy_block.bt_size;
xbt_ex_setup_backtrace(&e);
if (e.used == 0) {
void *heapbase1 = (char *)mdp1 + BLOCKSIZE;
void *heapbase2 = (char *)mdp2 + BLOCKSIZE;
- void * breakval1 = (char *)mdp1 + ((char *)mdp1->breakval - (char *)s_heap);
- void * breakval2 = (char *)mdp2 + ((char *)mdp2->breakval - (char *)s_heap);
-
size_t i, j;
- void *addr_block1, *addr_block2, *addr_frag1, *addr_frag2;
+ void *addr_block1 = NULL, *addr_block2 = NULL, *addr_frag1 = NULL, *addr_frag2 = NULL;
size_t frag_size;
i = 1;
- int k;
+ int k = 0;
int distance = 0;
int total_distance = 0;
int pointer_align;
- void *address_pointed1, *address_pointed2;
+ void *address_pointed1 = NULL, *address_pointed2 = NULL;
int block_pointed1, block_pointed2, frag_pointed1, frag_pointed2;
- void *addr_block_pointed1, *addr_block_pointed2;
+ void *addr_block_pointed1 = NULL, *addr_block_pointed2 = NULL, *addr_frag_pointed1 = NULL, *addr_frag_pointed2 = NULL;
/* Check busy blocks*/
/* Get address of block i in each heap */
addr_block1 = ((void*) (((ADDR2UINT(i)) - 1) * BLOCKSIZE + (char*)heapbase1));
- xbt_assert(addr_block1 < breakval1, "Block address out of heap memory used");
-
addr_block2 = ((void*) (((ADDR2UINT(i)) - 1) * BLOCKSIZE + (char*)heapbase2));
- xbt_assert(addr_block2 < breakval2, "Block address out of heap memory used");
if(mdp1->heapinfo[i].type == 0){ /* busy large block */
fprintf(stderr, "Blocks pointed : %d - %d\n", block_pointed1, block_pointed2);
if((char *) address_pointed1 < (char*)((struct mdesc*)s_heap)->heapbase || block_pointed1 > mdp1->heapsize || block_pointed1 < 1 || (char *) address_pointed2 < (char*)((struct mdesc*)s_heap)->heapbase || block_pointed2 > mdp2->heapsize || block_pointed2 < 1) {
- fprintf(stderr, "Unknown pointer ! \n");
+ fprintf(stderr, "Unknown pointer(s) ! \n");
fflush(NULL);
distance++;
continue;
}
+
+ /*if(((char *) address_pointed1 > (char*)((struct mdesc*)s_heap)->heapbase) && (block_pointed1 < mdp1->heapsize) && (block_pointed1 >= 1)){
+ addr_block_pointed1 = ((void*) (((ADDR2UINT((size_t)block_pointed1)) - 1) * BLOCKSIZE + (char*)heapbase1));
+ if(((char *) address_pointed2 > (char*)((struct mdesc*)s_heap)->heapbase) && (block_pointed2 < mdp2->heapsize) && (block_pointed2 >= 1)){
+ addr_block_pointed2 = ((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)heapbase2));
+ }else{
+ addr_block_pointed2 = addr_block2;
+ block_pointed2 = i;
+ }
+ }else{
+ addr_block_pointed1 = addr_block1;
+ block_pointed1 = i;
+ if(((char *) address_pointed2 > (char*)((struct mdesc*)s_heap)->heapbase) && (block_pointed2 < mdp2->heapsize) && (block_pointed2 >= 1)){
+ addr_block_pointed2 = ((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)heapbase2));
+ }else{
+ fprintf(stderr, "Unknown pointers ! \n");
+ fflush(NULL);
+ distance++;
+ continue;
+ }
+ }*/
addr_block_pointed1 = ((void*) (((ADDR2UINT((size_t)block_pointed1)) - 1) * BLOCKSIZE + (char*)heapbase1));
addr_block_pointed2 = ((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)heapbase2));
}else{ // Fragmented block
- frag_pointed1 = ((char *)address_pointed1 - (char *)((void*) (((ADDR2UINT((size_t)block_pointed1)) - 1) * BLOCKSIZE + (char*)((struct mdesc*)s_heap)->heapbase))) / pow( 2, mdp1->heapinfo[block_pointed1].type);
- frag_pointed2 = ((char *)address_pointed2 - (char *)((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)((struct mdesc*)s_heap)->heapbase))) / pow( 2, mdp1->heapinfo[block_pointed1].type);
-
+
+ frag_pointed1 = ((uintptr_t) (ADDR2UINT (address_pointed1) % (BLOCKSIZE))) >> mdp1->heapinfo[block_pointed1].type;
+ frag_pointed2 = ((uintptr_t) (ADDR2UINT (address_pointed2) % (BLOCKSIZE))) >> mdp2->heapinfo[block_pointed2].type;
+
fprintf(stderr, "Fragments pointed : %d - %d\n", frag_pointed1, frag_pointed2);
- if((frag_pointed1 < 0) || (frag_pointed1 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type))) || (frag_pointed2 < 0) || (frag_pointed2 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type)))){
- fprintf(stderr, "Unknown pointer ! \n");
+ if((frag_pointed1 < 0) || (frag_pointed1 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type))) || (frag_pointed2 < 0) || (frag_pointed2 > (BLOCKSIZE / pow( 2, mdp2->heapinfo[block_pointed2].type)))){
+ fprintf(stderr, "Unknown pointer(s) ! \n");
fflush(NULL);
distance++;
continue;
fprintf(stderr, "Size used in fragments pointed : %d - %d\n", mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1], mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]);
if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]){
+
+ addr_frag_pointed1 = (char *)addr_block_pointed1 + (frag_pointed1 * (int)pow(2, mdp1->heapinfo[block_pointed1].type));
+ addr_frag_pointed2 = (char *)addr_block_pointed2 + (frag_pointed2 * (int)pow(2, mdp2->heapinfo[block_pointed2].type));
- if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
+ if(memcmp(addr_frag_pointed1, addr_frag_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
distance++;
}else{
fprintf(stderr, "False difference detected\n");
}
}else{
- fprintf(stderr, "Pointers on blocks with different types \n");
- distance++;
+
+ if(((mdp1->heapinfo[block_pointed1].type == 0) && (mdp2->heapinfo[block_pointed2].type != 0)) || ((mdp1->heapinfo[block_pointed1].type != 0) && (mdp2->heapinfo[block_pointed2].type == 0))){
+ fprintf(stderr, "Pointers on blocks with different types \n");
+ distance++;
+ }else{
+
+ frag_pointed1 = ((uintptr_t) (ADDR2UINT (address_pointed1) % (BLOCKSIZE))) >> mdp1->heapinfo[block_pointed1].type;
+ frag_pointed2 = ((uintptr_t) (ADDR2UINT (address_pointed2) % (BLOCKSIZE))) >> mdp2->heapinfo[block_pointed2].type;
+
+ fprintf(stderr, "Fragments pointed : %d - %d\n", frag_pointed1, frag_pointed2);
+
+ if((frag_pointed1 < 0) || (frag_pointed1 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type))) || (frag_pointed2 < 0) || (frag_pointed2 > (BLOCKSIZE / pow( 2, mdp2->heapinfo[block_pointed2].type)))){
+ fprintf(stderr, "Unknown pointer(s) ! \n");
+ fflush(NULL);
+ distance++;
+ continue;
+ }
+
+ fprintf(stderr, "Size used in fragments pointed : %d - %d\n", mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1], mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]);
+
+ if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]){
+
+ addr_frag_pointed1 = (char *)addr_block_pointed1 + (frag_pointed1 * (int)pow(2, mdp1->heapinfo[block_pointed1].type));
+ addr_frag_pointed2 = (char *)addr_block_pointed2 + (frag_pointed2 * (int)pow(2, mdp2->heapinfo[block_pointed2].type));
+
+ if(memcmp(addr_frag_pointed1, addr_frag_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
+ distance++;
+ }else{
+ fprintf(stderr, "False difference detected\n");
+ }
+
+ }else{
+ distance ++;
+ }
+ }
}
}
if(mdp1->heapinfo[i].busy_frag.frag_size[j] > 0){
addr_frag1 = (char *)addr_block1 + (j * frag_size);
- xbt_assert(addr_frag1 < breakval1, "Fragment address out of heap memory used");
-
addr_frag2 = (char *)addr_block2 + (j * frag_size);
- xbt_assert(addr_frag1 < breakval1, "Fragment address out of heap memory used");
/* Hamming distance on different blocks */
distance = 0;
continue;
}
+ /*if(((char *) address_pointed1 > (char*)((struct mdesc*)s_heap)->heapbase) && (block_pointed1 < mdp1->heapsize) && (block_pointed1 >= 1)){
+ addr_block_pointed1 = ((void*) (((ADDR2UINT((size_t)block_pointed1)) - 1) * BLOCKSIZE + (char*)heapbase1));
+ pointer1 = 1;
+ if(((char *) address_pointed2 > (char*)((struct mdesc*)s_heap)->heapbase) && (block_pointed2 < mdp2->heapsize) && (block_pointed2 >= 1)){
+ addr_block_pointed2 = ((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)heapbase2));
+ pointer2 = 1;
+ }else{
+ pointer2 = 0;
+ addr_block_pointed2 = addr_block2;
+ block_pointed2 = i;
+ }
+ }else{
+ addr_block_pointed1 = addr_block1;
+ block_pointed1 = i;
+ pointer1 = 0;
+ if(((char *) address_pointed2 > (char*)((struct mdesc*)s_heap)->heapbase) && (block_pointed2 < mdp2->heapsize) && (block_pointed2 >= 1)){
+ addr_block_pointed2 = ((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)heapbase2));
+ pointer2 = 1;
+ }else{
+ fprintf(stderr, "Unknown pointers ! \n");
+ fflush(NULL);
+ distance++;
+ continue;
+ }
+ }*/
+
addr_block_pointed1 = ((void*) (((ADDR2UINT((size_t)block_pointed1)) - 1) * BLOCKSIZE + (char*)heapbase1));
addr_block_pointed2 = ((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)heapbase2));
}else{ // Fragmented block
- frag_pointed1 = ((char *)address_pointed1 - (char *)((void*) (((ADDR2UINT((size_t)block_pointed1)) - 1) * BLOCKSIZE + (char*)((struct mdesc*)s_heap)->heapbase))) / pow( 2, mdp1->heapinfo[block_pointed1].type);
- frag_pointed2 = ((char *)address_pointed2 - (char *)((void*) (((ADDR2UINT((size_t)block_pointed2)) - 1) * BLOCKSIZE + (char*)((struct mdesc*)s_heap)->heapbase))) / pow( 2, mdp1->heapinfo[block_pointed1].type);
-
+
+ frag_pointed1 = ((uintptr_t) (ADDR2UINT (address_pointed1) % (BLOCKSIZE))) >> mdp1->heapinfo[block_pointed1].type;
+ frag_pointed2 = ((uintptr_t) (ADDR2UINT (address_pointed2) % (BLOCKSIZE))) >> mdp2->heapinfo[block_pointed2].type;
+
fprintf(stderr, "Fragments pointed : %d - %d\n", frag_pointed1, frag_pointed2);
- if((frag_pointed1 < 0) || (frag_pointed1 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type))) || (frag_pointed2 < 0) || (frag_pointed2 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type)))){
+ if((frag_pointed1 < 0) || (frag_pointed1 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type))) || (frag_pointed2 < 0) || (frag_pointed2 > (BLOCKSIZE / pow( 2, mdp2->heapinfo[block_pointed2].type)))){
fprintf(stderr, "Unknown pointer ! \n");
fflush(NULL);
distance++;
fprintf(stderr, "Size used in fragments pointed : %d - %d\n", mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1], mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]);
if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]){
+
+ addr_frag_pointed1 = (char *)addr_block_pointed1 + (frag_pointed1 * (int)pow(2, mdp1->heapinfo[block_pointed1].type));
+ addr_frag_pointed2 = (char *)addr_block_pointed2 + (frag_pointed2 * (int)pow(2, mdp2->heapinfo[block_pointed2].type));
- if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
+ if(memcmp(addr_frag_pointed1, addr_frag_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
distance++;
}else{
fprintf(stderr, "False difference detected\n");
}
}else{
- fprintf(stderr, "Pointers on blocks with different types \n");
- distance++;
+
+ if(((mdp1->heapinfo[block_pointed1].type == 0) && (mdp2->heapinfo[block_pointed2].type != 0)) || ((mdp1->heapinfo[block_pointed1].type != 0) && (mdp2->heapinfo[block_pointed2].type == 0))){
+ fprintf(stderr, "Pointers on blocks with different types \n");
+ distance++;
+ }else{
+
+ frag_pointed1 = ((uintptr_t) (ADDR2UINT (address_pointed1) % (BLOCKSIZE))) >> mdp1->heapinfo[block_pointed1].type;
+ frag_pointed2 = ((uintptr_t) (ADDR2UINT (address_pointed2) % (BLOCKSIZE))) >> mdp2->heapinfo[block_pointed2].type;
+
+ fprintf(stderr, "Fragments pointed : %d - %d\n", frag_pointed1, frag_pointed2);
+
+ if((frag_pointed1 < 0) || (frag_pointed1 > (BLOCKSIZE / pow( 2, mdp1->heapinfo[block_pointed1].type))) || (frag_pointed2 < 0) || (frag_pointed2 > (BLOCKSIZE / pow( 2, mdp2->heapinfo[block_pointed2].type)))){
+ fprintf(stderr, "Unknown pointers ! \n");
+ fflush(NULL);
+ distance++;
+ continue;
+ }
+
+ fprintf(stderr, "Size used in fragments pointed : %d - %d\n", mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1], mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]);
+
+ if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]){
+
+ addr_frag_pointed1 = (char *)addr_block_pointed1 + (frag_pointed1 * (int)pow(2, mdp1->heapinfo[block_pointed1].type));
+ addr_frag_pointed2 = (char *)addr_block_pointed2 + (frag_pointed2 * (int)pow(2, mdp2->heapinfo[block_pointed2].type));
+
+ if(memcmp(addr_frag_pointed1, addr_frag_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
+ distance++;
+ }else{
+ fprintf(stderr, "False difference detected\n");
+ }
+
+ }else{
+ distance ++;
+ }
+ }
+
}
}
/* } */
-void mmalloc_display_info_heap(xbt_mheap_t h){
-
-}
-
-
