Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
model-checker : cosmetics, tab forgotten
authorMarion Guthmuller <marion.guthmuller@loria.fr>
Wed, 20 Jun 2012 14:24:04 +0000 (16:24 +0200)
committerMarion Guthmuller <marion.guthmuller@loria.fr>
Wed, 20 Jun 2012 15:24:33 +0000 (17:24 +0200)
src/xbt/mmalloc/mm_diff.c

index f46ac6f..60fb787 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,83 +176,83 @@ 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){
+      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){
+      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{
+      }
+
+      /* 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{ // 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{
+                    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, "Different size of pointed fragments\n");
-                      distance ++;
+                      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);
+                fprintf(stderr, "Pointers on blocks with different types \n");
                 distance++;
               }
             }else{
-              fprintf(stderr, "Pointed addresses (%p - %p) not in std_heap\n", address_pointed1, address_pointed2);
+              /* 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){
+      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);
@@ -261,13 +261,13 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
         fprintf(stderr, "\n");
         errors++;
         total_distance += distance;
-           }
+      }
 
-           i++;
+      i++;
 
     }else{
 
-           if(mdp1->heapinfo[i].type > 0){ /* busy fragmented block */
+      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);
@@ -305,60 +305,60 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
             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{
+              //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{ // 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{ // 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{
-                            distance ++;
+                            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);
+                      fprintf(stderr, "Pointers on blocks with different types \n");
                       distance++;
                     }
                   }else{
-                    fprintf(stderr, "Pointed addresses (%p - %p) not in std_heap\n", address_pointed1, address_pointed2);
+                    /* 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++;
                 }
               }
+              //}
 
             }
 
@@ -378,11 +378,11 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
 
         i++;
 
-           }else{ /* free block */
+      }else{ /* free block */
 
         i++;
 
-           }
+      }
 
     }