Logo AND Algorithmique Numérique Distribuée
Public GIT Repository
projects / simgrid.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
model-checker : get fragment number like in realloc function
[simgrid.git] / src / xbt / mmalloc / mm_diff.c
diff --git a/src/xbt/mmalloc/mm_diff.c b/src/xbt/mmalloc/mm_diff.c
index f46ac6f..a93c2f0 100644 (file)
--- 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);
     }
   }
 }
@@ -156,7 +156,7 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
   int pointer_align;
   void *address_pointed1, *address_pointed2;
 
-  int block_pointed1, block_pointed2;
+  int block_pointed1, block_pointed2, frag_pointed1, frag_pointed2;
   void *addr_block_pointed1, *addr_block_pointed2;
 
   /* Check busy blocks*/
@@ -164,95 +164,118 @@ 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);
+    /* 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 = (char*)heapbase2 + ((i-1)*BLOCKSIZE);
+    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 */
 
-           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{
-                      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");
+      }
+
+      /* Hamming distance on different blocks */
+      distance = 0;
+
+
+      for(k=0;k<mdp1->heapinfo[i].busy_block.busy_size;k++){
+
+        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);
+          
+          /* Check if pointer difference */
+          pointer_align = (k >> sizeof(void*)) * sizeof(void*);
+          address_pointed1 = *((void **)((char *)addr_block1 + pointer_align));
+          address_pointed2 = *((void **)((char *)addr_block2 + pointer_align));
+
+          fprintf(stderr, "Addresses pointed : %p - %p\n", address_pointed1, address_pointed2);
+          
+          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;
+          
+          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");
+            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));
+          
+          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){
+                
+                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{
-                /* 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++;
+              
+            }else{ // Fragmented block
+              
+              frag_pointed1 = ((uintptr_t) (ADDR2UINT (address_pointed1) % (BLOCKSIZE))) >> mdp1->heapinfo[i].type;
+              frag_pointed2 = ((uintptr_t) (ADDR2UINT (address_pointed2) % (BLOCKSIZE))) >> mdp1->heapinfo[i].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");
+                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]){
+                
+                if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
+                  distance++;
+                }else{
+                  fprintf(stderr, "False difference detected\n");
+                }
+                
+              }else{
+                distance ++;
+              }
             }
+            
+          }else{
+            fprintf(stderr, "Pointers on blocks with different types \n");
+            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 +284,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);
@@ -303,60 +326,82 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
 
             /* 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");
+
+              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));
+
+                fprintf(stderr, "Addresses pointed : %p - %p\n", address_pointed1, address_pointed2);
+
+                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;
+
+                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");
+                  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));
+                
+                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){
+                      
+                      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{
-                      /* 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++;
+                    
+                  }else{ // Fragmented block
+
+                    frag_pointed1 = ((uintptr_t) (ADDR2UINT (address_pointed1) % (BLOCKSIZE))) >> mdp1->heapinfo[i].type;
+                    frag_pointed2 = ((uintptr_t) (ADDR2UINT (address_pointed2) % (BLOCKSIZE))) >> mdp1->heapinfo[i].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");
+                       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]){
+                      
+                      if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
+                        distance++;
+                      }else{
+                        fprintf(stderr, "False difference detected\n");
+                      }
+                      
+                    }else{
+                      distance ++;
+                    }
                   }
+
+                }else{
+                  fprintf(stderr, "Pointers on blocks with different types \n");
+                  distance++;
                 }
               }
 
@@ -378,11 +423,11 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
 
         i++;
 
-           }else{ /* free block */
+      }else{ /* free block */
 
         i++;
 
-           }
+      }
 
     }
 
Clone of SimGrid repository with local patches