Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
model-checker : cosmetics reindent
authorMarion Guthmuller <marion.guthmuller@loria.fr>
Wed, 20 Jun 2012 11:13:01 +0000 (13:13 +0200)
committerMarion Guthmuller <marion.guthmuller@loria.fr>
Wed, 20 Jun 2012 11:13:23 +0000 (13:13 +0200)
src/xbt/mmalloc/mfree.c
src/xbt/mmalloc/mm_diff.c
src/xbt/mmalloc/mmalloc.c

index de6aa5c..f452a9e 100644 (file)
@@ -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; it<mdp->heapinfo[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; it<mdp->heapinfo[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;
index 1a2a5ee..f46ac6f 100644 (file)
@@ -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;k<mdp1->heapinfo[i].busy_block.size * BLOCKSIZE;k++){
-      for(k=0;k<mdp1->heapinfo[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;k<frag_size;k++){
-           for(k=0;k<mdp1->heapinfo[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;k<mdp1->heapinfo[i].busy_block.size * BLOCKSIZE;k++){
+           for(k=0;k<mdp1->heapinfo[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;k<frag_size;k++){
+            for(k=0;k<mdp1->heapinfo[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++;
 
-      }
+           }
 
     }
 
index ce35d8a..5f13f65 100644 (file)
@@ -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;it<blocks;it++)
-    mdp->heapinfo[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<blocks;it++)