From 1e117c3744cf64c0bc5d05340b6933e593ba52d0 Mon Sep 17 00:00:00 2001 From: Marion Guthmuller Date: Wed, 20 Jun 2012 13:13:01 +0200 Subject: [PATCH] model-checker : cosmetics reindent --- src/xbt/mmalloc/mfree.c | 68 +++---- src/xbt/mmalloc/mm_diff.c | 402 +++++++++++++++++++------------------- src/xbt/mmalloc/mmalloc.c | 30 +-- 3 files changed, 250 insertions(+), 250 deletions(-) diff --git a/src/xbt/mmalloc/mfree.c b/src/xbt/mmalloc/mfree.c index de6aa5c6ce..f452a9ef1b 100644 --- a/src/xbt/mmalloc/mfree.c +++ b/src/xbt/mmalloc/mfree.c @@ -42,15 +42,15 @@ void mfree(struct mdesc *mdp, void *ptr) fprintf(stderr,"Asked to free a fragment in a block that is already free. I'm puzzled\n"); abort(); break; - + case 0: - /* Get as many statistics as early as we can. */ - mdp -> heapstats.chunks_used--; - mdp -> heapstats.bytes_used -= - mdp -> heapinfo[block].busy_block.size * BLOCKSIZE; - mdp -> heapstats.bytes_free += - mdp -> heapinfo[block].busy_block.size * BLOCKSIZE; - + /* Get as many statistics as early as we can. */ + mdp -> heapstats.chunks_used--; + mdp -> heapstats.bytes_used -= + mdp -> heapinfo[block].busy_block.size * BLOCKSIZE; + mdp -> heapstats.bytes_free += + mdp -> heapinfo[block].busy_block.size * BLOCKSIZE; + /* Find the free cluster previous to this one in the free list. Start searching at the last block referenced; this may benefit programs with locality of allocation. */ @@ -76,7 +76,7 @@ void mfree(struct mdesc *mdp, void *ptr) for (it=0; itheapinfo[block].busy_block.size; it++) { if (mdp->heapinfo[block+it].type <0) { fprintf(stderr,"Internal Error: Asked to free a block already marked as free (block=%lu it=%d type=%lu). Please report this bug.\n", - (unsigned long)block,it,(unsigned long)mdp->heapinfo[block].type); + (unsigned long)block,it,(unsigned long)mdp->heapinfo[block].type); abort(); } mdp->heapinfo[block+it].type = -1; @@ -96,7 +96,7 @@ void mfree(struct mdesc *mdp, void *ptr) for (it=0; itheapinfo[block].free_block.size; it++) { if (mdp->heapinfo[block+it].type <0) { fprintf(stderr,"Internal error: Asked to free a block already marked as free (block=%lu it=%d/%lu type=%lu). Please report this bug.\n", - (unsigned long)block,it,(unsigned long)mdp->heapinfo[block].free_block.size,(unsigned long)mdp->heapinfo[block].type); + (unsigned long)block,it,(unsigned long)mdp->heapinfo[block].free_block.size,(unsigned long)mdp->heapinfo[block].type); abort(); } mdp->heapinfo[block+it].type = -1; @@ -109,29 +109,29 @@ void mfree(struct mdesc *mdp, void *ptr) if (block + mdp->heapinfo[block].free_block.size == mdp->heapinfo[block].free_block.next) { mdp->heapinfo[block].free_block.size - += mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.size; + += mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.size; mdp->heapinfo[block].free_block.next - = mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.next; + = mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.next; mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.prev = block; mdp -> heapstats.chunks_free--; } /* Now see if we can return stuff to the system. */ /* blocks = mdp -> heapinfo[block].free.size; - if (blocks >= FINAL_FREE_BLOCKS && block + blocks == mdp -> heaplimit - && mdp -> morecore (mdp, 0) == ADDRESS (block + blocks)) - { - register size_t bytes = blocks * BLOCKSIZE; - mdp -> heaplimit -= blocks; - mdp -> morecore (mdp, -bytes); - mdp -> heapinfo[mdp -> heapinfo[block].free.prev].free.next - = mdp -> heapinfo[block].free.next; - mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev - = mdp -> heapinfo[block].free.prev; - block = mdp -> heapinfo[block].free.prev; - mdp -> heapstats.chunks_free--; - mdp -> heapstats.bytes_free -= bytes; - } */ + if (blocks >= FINAL_FREE_BLOCKS && block + blocks == mdp -> heaplimit + && mdp -> morecore (mdp, 0) == ADDRESS (block + blocks)) + { + register size_t bytes = blocks * BLOCKSIZE; + mdp -> heaplimit -= blocks; + mdp -> morecore (mdp, -bytes); + mdp -> heapinfo[mdp -> heapinfo[block].free.prev].free.next + = mdp -> heapinfo[block].free.next; + mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev + = mdp -> heapinfo[block].free.prev; + block = mdp -> heapinfo[block].free.prev; + mdp -> heapstats.chunks_free--; + mdp -> heapstats.bytes_free -= bytes; + } */ /* Set the next search to begin at this block. */ mdp->heapindex = block; @@ -139,16 +139,16 @@ void mfree(struct mdesc *mdp, void *ptr) default: /* Do some of the statistics. */ - mdp -> heapstats.chunks_used--; - mdp -> heapstats.bytes_used -= 1 << type; - mdp -> heapstats.chunks_free++; - mdp -> heapstats.bytes_free += 1 << type; + mdp -> heapstats.chunks_used--; + mdp -> heapstats.bytes_used -= 1 << type; + mdp -> heapstats.chunks_free++; + mdp -> heapstats.bytes_free += 1 << type; /* Get the address of the first free fragment in this block. */ prev = (struct list *) - ((char *) ADDRESS(block) + - (mdp->heapinfo[block].busy_frag.first << type)); + ((char *) ADDRESS(block) + + (mdp->heapinfo[block].busy_frag.first << type)); if (mdp->heapinfo[block].busy_frag.nfree == (BLOCKSIZE >> type) - 1) { @@ -189,11 +189,11 @@ void mfree(struct mdesc *mdp, void *ptr) } else { /* No fragments of this block were free before the one we just released, * so link this fragment into the fragment list and announce that - it is the first free fragment of this block. */ + it is the first free fragment of this block. */ prev = (struct list *) ptr; mdp->heapinfo[block].busy_frag.nfree = 1; mdp->heapinfo[block].busy_frag.first = - RESIDUAL(ptr, BLOCKSIZE) >> type; + RESIDUAL(ptr, BLOCKSIZE) >> type; prev->next = mdp->fraghead[type].next; prev->prev = &mdp->fraghead[type]; prev->prev->next = prev; diff --git a/src/xbt/mmalloc/mm_diff.c b/src/xbt/mmalloc/mm_diff.c index 1a2a5eedda..f46ac6fb14 100644 --- a/src/xbt/mmalloc/mm_diff.c +++ b/src/xbt/mmalloc/mm_diff.c @@ -48,8 +48,8 @@ void mmalloc_backtrace_display(xbt_mheap_t mdp, void *ptr){ 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); + fprintf(stderr,"%d",i);fflush(NULL); + fprintf(stderr, "---> %s\n", e.bt_strings[i] + 4); } } } @@ -84,8 +84,8 @@ void mmalloc_backtrace_block_display(xbt_mheap_t mdp, size_t block){ fprintf(stderr, "Backtrace of where the block %zu was malloced (%d frames):\n", block ,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); + fprintf(stderr,"%d",i);fflush(NULL); + fprintf(stderr, "---> %s\n", e.bt_strings[i] + 4); } } } @@ -107,8 +107,8 @@ void mmalloc_backtrace_fragment_display(xbt_mheap_t mdp, size_t block, size_t fr fprintf(stderr, "Backtrace of where the fragment %zu in block %zu was malloced (%d frames):\n", frag, block ,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); + fprintf(stderr,"%d",i);fflush(NULL); + fprintf(stderr, "---> %s\n", e.bt_strings[i] + 4); } } } @@ -164,8 +164,8 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){ while(i < mdp1->heaplimit){ if(mdp1->heapinfo[i].type != mdp2->heapinfo[i].type){ - fprintf(stderr,"Different type of block : %d - %d\n", mdp1->heapinfo[i].type, mdp2->heapinfo[i].type); - errors++; + fprintf(stderr,"Different type of block : %d - %d\n", mdp1->heapinfo[i].type, mdp2->heapinfo[i].type); + errors++; } addr_block1 = (char*)heapbase1 + ((i-1)*BLOCKSIZE); @@ -176,213 +176,213 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){ if(mdp1->heapinfo[i].type == 0){ /* busy large block */ - if(mdp1->heapinfo[i].busy_block.size != mdp2->heapinfo[i].busy_block.size){ - fprintf(stderr,"Different size of a large cluster : %zu - %zu\n", mdp1->heapinfo[i].busy_block.size, mdp2->heapinfo[i].busy_block.size); - fflush(NULL); - errors++; - } - - if(mdp1->heapinfo[i].busy_block.busy_size != mdp2->heapinfo[i].busy_block.busy_size){ - fprintf(stderr,"Different busy_size of a large cluster : %zu - %zu\n", mdp1->heapinfo[i].busy_block.busy_size, mdp2->heapinfo[i].busy_block.busy_size); - fflush(NULL); - errors++; - } - - /* Hamming distance on different blocks */ - distance = 0; - - //for(k=0;kheapinfo[i].busy_block.size * BLOCKSIZE;k++){ - for(k=0;kheapinfo[i].busy_block.busy_size;k++){ - if((((char *)addr_block1) + k != 0) && (((char *)addr_block2) + k != 0)){ - if(memcmp(((char *)addr_block1) + k, ((char *)addr_block2) + k, 1) != 0){ - fprintf(stderr, "Different byte (offset=%d) (%p - %p) in block %zu\n", k, (char *)addr_block1 + k, (char *)addr_block2 + k, i); fflush(NULL); - pointer_align = (k / sizeof(void*)) * sizeof(void*); - address_pointed1 = *((void **)((char *)addr_block1 + pointer_align)); - address_pointed2 = *((void **)((char *)addr_block2 + pointer_align)); - if(((address_pointed1 > (void *)s_heap) && (address_pointed1 < mdp1->breakval)) && ((address_pointed2 > (void *)s_heap) && (address_pointed2 < mdp2->breakval))){ - block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; - block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; - //fprintf(stderr, "Blocks pointed : %d - %d\n", block_pointed1, block_pointed2); - if((block_pointed1 == 0) && (block_pointed2 == 0)){ - block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; - block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; - if(mdp1->heapinfo[block_pointed1].type == mdp2->heapinfo[block_pointed2].type){ - if(mdp1->heapinfo[block_pointed1].type == 0){ // Large block - if(mdp1->heapinfo[block_pointed1].busy_block.busy_size == mdp2->heapinfo[block_pointed2].busy_block.busy_size){ - addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE); - addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE); - if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size) != 0){ - distance++; - }else{ - fprintf(stderr, "False difference detected\n"); - } - }else{ - distance++; - } - }else{ // Fragmented block - addr_block_pointed1 = (char*)mdp1 + ((char *)address_pointed1 - (char *)s_heap); - addr_block_pointed2 = (char*)mdp2 + ((char *)address_pointed2 - (char *)s_heap); - if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[0]){ - if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0]) != 0){ - fprintf(stderr, "Pointed fragments are different \n"); - distance++; - }else{ - fprintf(stderr, "False difference detected\n"); - } - }else{ - fprintf(stderr, "Different size of pointed fragments\n"); - distance ++; - } - } - }else{ - fprintf(stderr, "Pointers on blocks with different types \n"); - distance++; - } - }else{ - /* FIXME : peut pointer vers le début d'un fragment mais dans un bloc */ - fprintf(stderr, "Pointed addresses (%p - %p) not valid\n", address_pointed1, address_pointed2); - distance++; - } - }else{ - fprintf(stderr, "Pointed addresses (%p - %p) not in std_heap\n", address_pointed1, address_pointed2); - distance++; + if(mdp1->heapinfo[i].busy_block.size != mdp2->heapinfo[i].busy_block.size){ + fprintf(stderr,"Different size of a large cluster : %zu - %zu\n", mdp1->heapinfo[i].busy_block.size, mdp2->heapinfo[i].busy_block.size); + fflush(NULL); + errors++; } - } - } - } - - - if(distance>0){ - fprintf(stderr,"\nDifferent data in large block %zu (size = %zu (in blocks), busy_size = %zu (in bytes))\n", i, mdp1->heapinfo[i].busy_block.size, mdp1->heapinfo[i].busy_block.busy_size); - fflush(NULL); - fprintf(stderr, "Hamming distance between blocks : %d\n", distance); - mmalloc_backtrace_block_display(mdp1, i); - mmalloc_backtrace_block_display(mdp2, i); - fprintf(stderr, "\n"); - errors++; - total_distance += distance; - } - - i++; - - }else{ - - if(mdp1->heapinfo[i].type > 0){ /* busy fragmented block */ - - if(mdp1->heapinfo[i].type != mdp2->heapinfo[i].type){ - fprintf(stderr,"Different size of fragments in fragmented block %zu : %d - %d\n", i, mdp1->heapinfo[i].type, mdp2->heapinfo[i].type); fflush(NULL); - errors++; - } - - if(mdp1->heapinfo[i].busy_frag.nfree != mdp2->heapinfo[i].busy_frag.nfree){ - fprintf(stderr,"Different free fragments in fragmented block %zu : %zu - %zu\n", i, mdp1->heapinfo[i].busy_frag.nfree, mdp2->heapinfo[i].busy_frag.nfree); fflush(NULL); - errors++; - } - - if(mdp1->heapinfo[i].busy_frag.first != mdp2->heapinfo[i].busy_frag.first){ - fprintf(stderr,"Different busy_size of a large cluster : %zu - %zu\n", mdp1->heapinfo[i].busy_block.busy_size, mdp2->heapinfo[i].busy_block.busy_size); fflush(NULL); - errors++; - } - frag_size = pow(2, mdp1->heapinfo[i].type); - - for(j=0; j< (BLOCKSIZE/frag_size); j++){ - - if(mdp1->heapinfo[i].busy_frag.frag_size[j] != mdp2->heapinfo[i].busy_frag.frag_size[j]){ - fprintf(stderr,"Different busy_size for fragment %zu in block %zu : %hu - %hu\n", j, i, mdp1->heapinfo[i].busy_frag.frag_size[j], mdp2->heapinfo[i].busy_frag.frag_size[j]); fflush(NULL); - errors++; - } - - 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"); + if(mdp1->heapinfo[i].busy_block.busy_size != mdp2->heapinfo[i].busy_block.busy_size){ + fprintf(stderr,"Different busy_size of a large cluster : %zu - %zu\n", mdp1->heapinfo[i].busy_block.busy_size, mdp2->heapinfo[i].busy_block.busy_size); + fflush(NULL); + errors++; + } /* Hamming distance on different blocks */ distance = 0; - //for(k=0;kheapinfo[i].busy_frag.frag_size[j];k++){ - if((((char *)addr_frag1) + k != 0) && (((char *)addr_frag2) + k != 0)){ - if(memcmp(((char *)addr_frag1) + k, ((char *)addr_frag2) + k, 1) != 0){ - fprintf(stderr, "Different byte (offset=%d) (%p - %p) in fragment %zu in block %zu\n", k, (char *)addr_frag1 + k, (char *)addr_frag2 + k, j, i); fflush(NULL); - pointer_align = (k / sizeof(void*)) * sizeof(void*); - address_pointed1 = *((void **)((char *)addr_frag1 + pointer_align)); - address_pointed2 = *((void **)((char *)addr_frag2 + pointer_align)); - if(((address_pointed1 > (void *)s_heap) && (address_pointed1 < mdp1->breakval)) && ((address_pointed2 > (void *)s_heap) && (address_pointed2 < mdp2->breakval))){ - block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; - block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; - if((block_pointed1 == 0) && (block_pointed2 == 0)){ - block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; - block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; - if(mdp1->heapinfo[block_pointed1].type == mdp2->heapinfo[block_pointed2].type){ - if(mdp1->heapinfo[block_pointed1].type == 0){ // Large block - if(mdp1->heapinfo[block_pointed1].busy_block.busy_size == mdp2->heapinfo[block_pointed2].busy_block.busy_size){ - addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE); - addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE); - fprintf(stderr, "Memcmp between blocks %d and %d (size = %zu)\n", block_pointed1, block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size); - if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size) != 0){ - distance++; - }else{ - fprintf(stderr, "False difference detected\n"); - } - }else{ - distance++; - } - }else{ // Fragmented block - addr_block_pointed1 = (char*)mdp1 + ((char *)address_pointed1 - (char *)s_heap); - addr_block_pointed2 = (char*)mdp2 + ((char *)address_pointed2 - (char *)s_heap); - if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[0]){ - if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0]) != 0){ - distance++; - }else{ - fprintf(stderr, "False difference detected\n"); - } - }else{ - distance ++; - } - } - }else{ - fprintf(stderr, "Pointers on blocks with different types \n"); - distance++; - } - }else{ - /* FIXME : peut pointer vers le début d'un fragment mais dans un bloc */ - fprintf(stderr, "Pointed addresses (%p - %p) not valid \n", address_pointed1, address_pointed2); - distance++; - } - }else{ - fprintf(stderr, "Pointed addresses (%p - %p) not in std_heap\n", address_pointed1, address_pointed2); - distance++; - } - } - } + //for(k=0;kheapinfo[i].busy_block.size * BLOCKSIZE;k++){ + for(k=0;kheapinfo[i].busy_block.busy_size;k++){ + if((((char *)addr_block1) + k != 0) && (((char *)addr_block2) + k != 0)){ + if(memcmp(((char *)addr_block1) + k, ((char *)addr_block2) + k, 1) != 0){ + fprintf(stderr, "Different byte (offset=%d) (%p - %p) in block %zu\n", k, (char *)addr_block1 + k, (char *)addr_block2 + k, i); fflush(NULL); + pointer_align = (k / sizeof(void*)) * sizeof(void*); + address_pointed1 = *((void **)((char *)addr_block1 + pointer_align)); + address_pointed2 = *((void **)((char *)addr_block2 + pointer_align)); + if(((address_pointed1 > (void *)s_heap) && (address_pointed1 < mdp1->breakval)) && ((address_pointed2 > (void *)s_heap) && (address_pointed2 < mdp2->breakval))){ + block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; + block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; + //fprintf(stderr, "Blocks pointed : %d - %d\n", block_pointed1, block_pointed2); + if((block_pointed1 == 0) && (block_pointed2 == 0)){ + block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; + block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; + if(mdp1->heapinfo[block_pointed1].type == mdp2->heapinfo[block_pointed2].type){ + if(mdp1->heapinfo[block_pointed1].type == 0){ // Large block + if(mdp1->heapinfo[block_pointed1].busy_block.busy_size == mdp2->heapinfo[block_pointed2].busy_block.busy_size){ + addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE); + addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE); + if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size) != 0){ + distance++; + }else{ + fprintf(stderr, "False difference detected\n"); + } + }else{ + distance++; + } + }else{ // Fragmented block + addr_block_pointed1 = (char*)mdp1 + ((char *)address_pointed1 - (char *)s_heap); + addr_block_pointed2 = (char*)mdp2 + ((char *)address_pointed2 - (char *)s_heap); + if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[0]){ + if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0]) != 0){ + fprintf(stderr, "Pointed fragments are different \n"); + distance++; + }else{ + fprintf(stderr, "False difference detected\n"); + } + }else{ + fprintf(stderr, "Different size of pointed fragments\n"); + distance ++; + } + } + }else{ + fprintf(stderr, "Pointers on blocks with different types \n"); + distance++; + } + }else{ + /* FIXME : peut pointer vers le début d'un fragment mais dans un bloc */ + fprintf(stderr, "Pointed addresses (%p - %p) not valid\n", address_pointed1, address_pointed2); + distance++; + } + }else{ + fprintf(stderr, "Pointed addresses (%p - %p) not in std_heap\n", address_pointed1, address_pointed2); + distance++; + } + } + } } - if(distance > 0){ - fprintf(stderr,"\nDifferent data in fragment %zu (size = %zu, size used = %hu) in block %zu \n", j, frag_size, mdp1->heapinfo[i].busy_frag.frag_size[j], i); - fprintf(stderr, "Hamming distance between fragments : %d\n", distance); - mmalloc_backtrace_fragment_display(mdp1, i, j); - mmalloc_backtrace_fragment_display(mdp2, i, j); - fprintf(stderr, "\n"); - errors++; - total_distance += distance; + if(distance>0){ + fprintf(stderr,"\nDifferent data in large block %zu (size = %zu (in blocks), busy_size = %zu (in bytes))\n", i, mdp1->heapinfo[i].busy_block.size, mdp1->heapinfo[i].busy_block.busy_size); + fflush(NULL); + fprintf(stderr, "Hamming distance between blocks : %d\n", distance); + mmalloc_backtrace_block_display(mdp1, i); + mmalloc_backtrace_block_display(mdp2, i); + fprintf(stderr, "\n"); + errors++; + total_distance += distance; } - } - } - - i++; + i++; - }else{ /* free block */ + }else{ - i++; + if(mdp1->heapinfo[i].type > 0){ /* busy fragmented block */ + + if(mdp1->heapinfo[i].type != mdp2->heapinfo[i].type){ + fprintf(stderr,"Different size of fragments in fragmented block %zu : %d - %d\n", i, mdp1->heapinfo[i].type, mdp2->heapinfo[i].type); fflush(NULL); + errors++; + } + + if(mdp1->heapinfo[i].busy_frag.nfree != mdp2->heapinfo[i].busy_frag.nfree){ + fprintf(stderr,"Different free fragments in fragmented block %zu : %zu - %zu\n", i, mdp1->heapinfo[i].busy_frag.nfree, mdp2->heapinfo[i].busy_frag.nfree); fflush(NULL); + errors++; + } + + if(mdp1->heapinfo[i].busy_frag.first != mdp2->heapinfo[i].busy_frag.first){ + fprintf(stderr,"Different busy_size of a large cluster : %zu - %zu\n", mdp1->heapinfo[i].busy_block.busy_size, mdp2->heapinfo[i].busy_block.busy_size); fflush(NULL); + errors++; + } + + frag_size = pow(2, mdp1->heapinfo[i].type); + + for(j=0; j< (BLOCKSIZE/frag_size); j++){ + + if(mdp1->heapinfo[i].busy_frag.frag_size[j] != mdp2->heapinfo[i].busy_frag.frag_size[j]){ + fprintf(stderr,"Different busy_size for fragment %zu in block %zu : %hu - %hu\n", j, i, mdp1->heapinfo[i].busy_frag.frag_size[j], mdp2->heapinfo[i].busy_frag.frag_size[j]); fflush(NULL); + errors++; + } + + 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; + //for(k=0;kheapinfo[i].busy_frag.frag_size[j];k++){ + if((((char *)addr_frag1) + k != 0) && (((char *)addr_frag2) + k != 0)){ + if(memcmp(((char *)addr_frag1) + k, ((char *)addr_frag2) + k, 1) != 0){ + fprintf(stderr, "Different byte (offset=%d) (%p - %p) in fragment %zu in block %zu\n", k, (char *)addr_frag1 + k, (char *)addr_frag2 + k, j, i); fflush(NULL); + pointer_align = (k / sizeof(void*)) * sizeof(void*); + address_pointed1 = *((void **)((char *)addr_frag1 + pointer_align)); + address_pointed2 = *((void **)((char *)addr_frag2 + pointer_align)); + if(((address_pointed1 > (void *)s_heap) && (address_pointed1 < mdp1->breakval)) && ((address_pointed2 > (void *)s_heap) && (address_pointed2 < mdp2->breakval))){ + block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; + block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) % BLOCKSIZE; + if((block_pointed1 == 0) && (block_pointed2 == 0)){ + block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; + block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1; + if(mdp1->heapinfo[block_pointed1].type == mdp2->heapinfo[block_pointed2].type){ + if(mdp1->heapinfo[block_pointed1].type == 0){ // Large block + if(mdp1->heapinfo[block_pointed1].busy_block.busy_size == mdp2->heapinfo[block_pointed2].busy_block.busy_size){ + addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE); + addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE); + fprintf(stderr, "Memcmp between blocks %d and %d (size = %zu)\n", block_pointed1, block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size); + if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size) != 0){ + distance++; + }else{ + fprintf(stderr, "False difference detected\n"); + } + }else{ + distance++; + } + }else{ // Fragmented block + addr_block_pointed1 = (char*)mdp1 + ((char *)address_pointed1 - (char *)s_heap); + addr_block_pointed2 = (char*)mdp2 + ((char *)address_pointed2 - (char *)s_heap); + if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[0]){ + if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[0]) != 0){ + distance++; + }else{ + fprintf(stderr, "False difference detected\n"); + } + }else{ + distance ++; + } + } + }else{ + fprintf(stderr, "Pointers on blocks with different types \n"); + distance++; + } + }else{ + /* FIXME : peut pointer vers le début d'un fragment mais dans un bloc */ + fprintf(stderr, "Pointed addresses (%p - %p) not valid \n", address_pointed1, address_pointed2); + distance++; + } + }else{ + fprintf(stderr, "Pointed addresses (%p - %p) not in std_heap\n", address_pointed1, address_pointed2); + distance++; + } + } + } + + } + + if(distance > 0){ + fprintf(stderr,"\nDifferent data in fragment %zu (size = %zu, size used = %hu) in block %zu \n", j, frag_size, mdp1->heapinfo[i].busy_frag.frag_size[j], i); + fprintf(stderr, "Hamming distance between fragments : %d\n", distance); + mmalloc_backtrace_fragment_display(mdp1, i, j); + mmalloc_backtrace_fragment_display(mdp2, i, j); + fprintf(stderr, "\n"); + errors++; + total_distance += distance; + + } + + } + } + + i++; + + }else{ /* free block */ + + i++; - } + } } diff --git a/src/xbt/mmalloc/mmalloc.c b/src/xbt/mmalloc/mmalloc.c index ce35d8a912..5f13f656f0 100644 --- a/src/xbt/mmalloc/mmalloc.c +++ b/src/xbt/mmalloc/mmalloc.c @@ -161,7 +161,7 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) } if (--mdp->heapinfo[block].busy_frag.nfree != 0) { mdp->heapinfo[block].busy_frag.first = - RESIDUAL(next->next, BLOCKSIZE) >> log; + RESIDUAL(next->next, BLOCKSIZE) >> log; } /* Update the statistics. */ @@ -183,7 +183,7 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) /* Link all fragments but the first into the free list, and mark their requested size to 0. */ block = BLOCK(result); for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i) { - mdp->heapinfo[block].busy_frag.frag_size[i] = 0; + mdp->heapinfo[block].busy_frag.frag_size[i] = 0; next = (struct list *) ((char *) result + (i << log)); next->next = mdp->fraghead[log].next; next->prev = &mdp->fraghead[log]; @@ -213,8 +213,8 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) start = block = MALLOC_SEARCH_START; while (mdp->heapinfo[block].free_block.size < blocks) { if (mdp->heapinfo[block].type >=0) { // Don't trust xbt_die and friends in malloc-level library, you fool! - fprintf(stderr,"Internal error: found a free block not marked as such (block=%lu type=%lu). Please report this bug.\n",(unsigned long)block,(unsigned long)mdp->heapinfo[block].type); - abort(); + fprintf(stderr,"Internal error: found a free block not marked as such (block=%lu type=%lu). Please report this bug.\n",(unsigned long)block,(unsigned long)mdp->heapinfo[block].type); + abort(); } block = mdp->heapinfo[block].free_block.next; @@ -237,16 +237,16 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) continue; } result = register_morecore(mdp, blocks * BLOCKSIZE); - memset(result, 0, requested_size); + memset(result, 0, requested_size); block = BLOCK(result); for (it=0;itheapinfo[block+it].type = 0; + mdp->heapinfo[block+it].type = 0; mdp->heapinfo[block].busy_block.size = blocks; mdp->heapinfo[block].busy_block.busy_size = requested_size; mdp->heapinfo[block].busy_block.bt_size=xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_block.bt,XBT_BACKTRACE_SIZE); - mdp -> heapstats.chunks_used++; - mdp -> heapstats.bytes_used += blocks * BLOCKSIZE; + mdp -> heapstats.chunks_used++; + mdp -> heapstats.bytes_used += blocks * BLOCKSIZE; return result; } /* Need large block(s), but found some in the existing heap */ @@ -259,21 +259,21 @@ void *mmalloc(xbt_mheap_t mdp, size_t size) /* The block we found has a bit left over, so relink the tail end back into the free list. */ mdp->heapinfo[block + blocks].free_block.size - = mdp->heapinfo[block].free_block.size - blocks; + = mdp->heapinfo[block].free_block.size - blocks; mdp->heapinfo[block + blocks].free_block.next - = mdp->heapinfo[block].free_block.next; + = mdp->heapinfo[block].free_block.next; mdp->heapinfo[block + blocks].free_block.prev - = mdp->heapinfo[block].free_block.prev; + = mdp->heapinfo[block].free_block.prev; mdp->heapinfo[mdp->heapinfo[block].free_block.prev].free_block.next - = mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.prev - = mdp->heapindex = block + blocks; + = mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.prev + = mdp->heapindex = block + blocks; } else { /* The block exactly matches our requirements, so just remove it from the list. */ mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.prev - = mdp->heapinfo[block].free_block.prev; + = mdp->heapinfo[block].free_block.prev; mdp->heapinfo[mdp->heapinfo[block].free_block.prev].free_block.next - = mdp->heapindex = mdp->heapinfo[block].free_block.next; + = mdp->heapindex = mdp->heapinfo[block].free_block.next; } for (it=0;it