Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
8aca355fc2f41ecf81a59b3440fefd413d7e9cd3
[simgrid.git] / src / xbt / mmalloc / mm_diff.c
1 /* mm_diff - Memory snapshooting and comparison                             */
2
3 /* Copyright (c) 2008-2012. The SimGrid Team. All rights reserved.          */
4
5 /* This program is free software; you can redistribute it and/or modify it
6  * under the terms of the license (GNU LGPL) which comes with this package. */
7
8 #include "xbt/ex_interface.h" /* internals of backtrace setup */
9 #include "xbt/str.h"
10 #include "mc/mc.h"
11
12 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mm_diff, xbt,
13                                 "Logging specific to mm_diff in mmalloc");
14
15 extern char *xbt_binary_name;
16
17 void mmalloc_backtrace_display(xbt_mheap_t mdp, void *ptr){
18   size_t block = BLOCK(ptr);
19   int type;
20   xbt_ex_t e;
21
22   if ((char *) ptr < (char *) mdp->heapbase || block > mdp->heapsize) {
23     fprintf(stderr,"Ouch, this pointer is not mine. I cannot display its backtrace. I refuse it to death!!\n");
24     abort();
25   }
26
27   type = mdp->heapinfo[block].type;
28
29   if (type != 0) {
30     //fprintf(stderr,"Only full blocks are backtraced for now. Ignoring your request.\n");
31     return;
32   }
33   if (mdp->heapinfo[block].busy_block.bt_size == 0) {
34     fprintf(stderr,"No backtrace available for that block, sorry.\n");
35     return;
36   }
37
38   memcpy(&e.bt,&(mdp->heapinfo[block].busy_block.bt),sizeof(void*)*XBT_BACKTRACE_SIZE);
39   e.used = mdp->heapinfo[block].busy_block.bt_size;
40
41   xbt_ex_setup_backtrace(&e);
42   if (e.used == 0) {
43     fprintf(stderr, "(backtrace not set)\n");
44   } else if (e.bt_strings == NULL) {
45     fprintf(stderr, "(backtrace not ready to be computed. %s)\n",xbt_binary_name?"Dunno why":"xbt_binary_name not setup yet");
46   } else {
47     int i;
48
49     fprintf(stderr, "Backtrace of where the block %p was malloced (%d frames):\n",ptr,e.used);
50     for (i = 0; i < e.used; i++)       /* no need to display "xbt_backtrace_display" */{
51       fprintf(stderr,"%d",i);fflush(NULL);
52       fprintf(stderr, "---> %s\n", e.bt_strings[i] + 4);
53     }
54   }
55 }
56
57
58 void mmalloc_backtrace_block_display(xbt_mheap_t mdp, size_t block){
59
60   int type;
61   xbt_ex_t e;
62
63   type = mdp->heapinfo[block].type;
64
65   if (type != 0) {
66     fprintf(stderr,"Only full blocks are backtraced for now. Ignoring your request.\n");
67     return;
68   }
69   if (mdp->heapinfo[block].busy_block.bt_size == 0) {
70     fprintf(stderr,"No backtrace available for that block, sorry.\n");
71     return;
72   }
73
74   memcpy(&e.bt,&(mdp->heapinfo[block].busy_block.bt),sizeof(void*)*XBT_BACKTRACE_SIZE);
75   e.used = mdp->heapinfo[block].busy_block.bt_size;
76
77   xbt_ex_setup_backtrace(&e);
78   if (e.used == 0) {
79     fprintf(stderr, "(backtrace not set)\n");
80   } else if (e.bt_strings == NULL) {
81     fprintf(stderr, "(backtrace not ready to be computed. %s)\n",xbt_binary_name?"Dunno why":"xbt_binary_name not setup yet");
82   } else {
83     int i;
84
85     fprintf(stderr, "Backtrace of where the block %zu was malloced (%d frames):\n", block ,e.used);
86     for (i = 0; i < e.used; i++)       /* no need to display "xbt_backtrace_display" */{
87       fprintf(stderr,"%d",i);fflush(NULL);
88       fprintf(stderr, "---> %s\n", e.bt_strings[i] + 4);
89     }
90   }
91 }
92
93 void mmalloc_backtrace_fragment_display(xbt_mheap_t mdp, size_t block, size_t frag){
94   
95   xbt_ex_t e;
96
97   memcpy(&e.bt,&(mdp->heapinfo[block].busy_frag.bt[frag]),sizeof(void*)*XBT_BACKTRACE_SIZE);
98   e.used = XBT_BACKTRACE_SIZE;
99
100   xbt_ex_setup_backtrace(&e);
101   if (e.used == 0) {
102     fprintf(stderr, "(backtrace not set)\n");
103   } else if (e.bt_strings == NULL) {
104     fprintf(stderr, "(backtrace not ready to be computed. %s)\n",xbt_binary_name?"Dunno why":"xbt_binary_name not setup yet");
105   } else {
106     int i;
107
108     fprintf(stderr, "Backtrace of where the fragment %zu in block %zu was malloced (%d frames):\n", frag, block ,e.used);
109     for (i = 0; i < e.used; i++)       /* no need to display "xbt_backtrace_display" */{
110       fprintf(stderr,"%d",i);fflush(NULL);
111       fprintf(stderr, "---> %s\n", e.bt_strings[i] + 4);
112     }
113   }
114 }
115
116 int mmalloc_compare_heap(xbt_mheap_t mdp1, xbt_mheap_t mdp2){
117
118   if(mdp1 == NULL && mdp2 == NULL){
119     fprintf(stderr, "Malloc descriptors null\n");
120     return 0;
121   }
122
123   int errors = mmalloc_compare_mdesc(mdp1, mdp2);
124
125   return (errors > 0);
126
127 }
128
129 int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){
130
131   int errors = 0;
132
133   /*if(mdp1->headersize != mdp2->headersize){
134     fprintf(stderr, "Different size of the file header for the mapped files\n");
135     return 1;
136   }
137
138   if(mdp1->refcount != mdp2->refcount){
139     fprintf(stderr, "Different number of processes that attached the heap\n");
140     return 1;
141   }
142
143   if(strcmp(mdp1->magic, mdp2->magic) != 0){
144     fprintf(stderr,"Different magic number\n");
145     return 1;
146   }
147
148   if(mdp1->flags != mdp2->flags){
149     fprintf(stderr,"Different flags\n");  
150     return 1;
151   }
152
153   if(mdp1->heapsize != mdp2->heapsize){
154     fprintf(stderr,"Different number of info entries\n");
155     return 1;
156   }  
157
158   if(mdp1->heapbase != mdp2->heapbase){
159     fprintf(stderr,"Different first block of the heap\n");
160     return 1;
161   }
162
163   if(mdp1->heapindex != mdp2->heapindex){
164     fprintf(stderr,"Different index for the heap table : %zu - %zu\n", mdp1->heapindex, mdp2->heapindex);
165     return 1;
166   }
167
168   if(mdp1->base != mdp2->base){
169     fprintf(stderr,"Different base address of the memory region\n");
170     return 1;
171   }
172
173   if(mdp1->breakval != mdp2->breakval){
174     fprintf(stderr,"Different current location in the memory region\n");
175     return 1;
176   }
177
178   if(mdp1->top != mdp2->top){
179     fprintf(stderr,"Different end of the current location in the memory region\n");
180     return 1;
181   }
182
183   if(mdp1->fd != mdp2->fd){
184     fprintf(stderr,"Different file descriptor for the file to which this malloc heap is mapped\n");
185     return 1;
186   }
187
188   if(mdp1->version != mdp2->version){
189     fprintf(stderr,"Different version of the mmalloc package\n");
190     return 1;
191     }*/
192
193
194   if(mdp1->heaplimit != mdp2->heaplimit){
195     fprintf(stderr,"Different limit of valid info table indices\n");
196     return 1;
197   }
198
199   void* s_heap = (char *)mmalloc_get_current_heap() - STD_HEAP_SIZE - getpagesize();
200     
201   void *heapbase1 = (char *)mdp1 + BLOCKSIZE;
202   void *heapbase2 = (char *)mdp2 + BLOCKSIZE;
203
204   void * breakval1 = (char *)mdp1 + ((char *)mdp1->breakval - (char *)s_heap);
205   void * breakval2 = (char *)mdp2 + ((char *)mdp2->breakval - (char *)s_heap);
206
207   size_t i, j;
208   void *addr_block1, *addr_block2, *addr_frag1, *addr_frag2;
209   size_t frag_size = 0;         /* FIXME: arbitrary initialization */
210
211   i = 1;
212
213   int k;
214   int distance = 0;
215   int total_distance = 0;
216
217   int pointer_align;
218   void *address_pointed1, *address_pointed2;
219
220   int block_pointed1, block_pointed2;
221   void *addr_block_pointed1, *addr_block_pointed2;
222   int frag_pointed1, frag_pointed2;
223
224   /* Check busy blocks*/
225
226   while(i < mdp1->heaplimit){
227
228     if(mdp1->heapinfo[i].type != mdp2->heapinfo[i].type){
229       fprintf(stderr,"Different type of block : %d - %d\n", mdp1->heapinfo[i].type, mdp2->heapinfo[i].type);
230       errors++;
231     }
232
233     addr_block1 = (char*)heapbase1 + ((i-1)*BLOCKSIZE);
234     xbt_assert(addr_block1 < breakval1, "Block address out of heap memory used");
235
236     addr_block2 = (char*)heapbase2 + ((i-1)*BLOCKSIZE);
237     xbt_assert(addr_block2 < breakval2, "Block address out of heap memory used");
238
239     if(mdp1->heapinfo[i].type == 0){ /* busy large block */
240
241       if(mdp1->heapinfo[i].busy_block.size != mdp2->heapinfo[i].busy_block.size){
242         fprintf(stderr,"Different size of a large cluster : %zu - %zu\n", mdp1->heapinfo[i].busy_block.size, mdp2->heapinfo[i].busy_block.size); 
243         fflush(NULL);
244         errors++;
245       } 
246
247       if(mdp1->heapinfo[i].busy_block.busy_size != mdp2->heapinfo[i].busy_block.busy_size){
248         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); 
249         fflush(NULL);
250         errors++;
251       } 
252
253   
254       /* Hamming distance on different blocks */
255       distance = 0;
256
257       //for(k=0;k<mdp1->heapinfo[i].busy_block.size * BLOCKSIZE;k++){
258       for(k=0;k<mdp1->heapinfo[i].busy_block.busy_size;k++){
259         if(memcmp(((char *)addr_block1) + k, ((char *)addr_block2) + k, 1) != 0){
260           //fprintf(stderr, "Different byte (offset=%d) (%p - %p) in block %zu\n", k, (char *)addr_block1 + k, (char *)addr_block2 + k, i); fflush(NULL);
261           pointer_align = (k / sizeof(void*)) * sizeof(void*); 
262           address_pointed1 = *((void **)((char *)addr_block1 + pointer_align));
263           address_pointed2 = *((void **)((char *)addr_block2 + pointer_align));                            
264           if(((address_pointed1 > (void *)s_heap) && (address_pointed1 < mdp1->breakval)) && ((address_pointed2 > (void *)s_heap) && (address_pointed2 < mdp2->breakval))){
265             block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1;
266             block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1;
267             //fprintf(stderr, "Blocks pointed : %d - %d\n", block_pointed1, block_pointed2);
268             if(mdp1->heapinfo[block_pointed1].type == mdp2->heapinfo[block_pointed2].type){
269               if(mdp1->heapinfo[block_pointed1].type == 0){ // Large block
270                 while(mdp1->heapinfo[block_pointed1].busy_block.size == 0)
271                   block_pointed1--;
272                 while(mdp2->heapinfo[block_pointed2].busy_block.size == 0)
273                   block_pointed2--;
274                 if(mdp1->heapinfo[block_pointed1].busy_block.busy_size == mdp2->heapinfo[block_pointed2].busy_block.busy_size){
275                   addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE);
276                   addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE);
277                   
278                   fprintf(stderr, "Memcmp between blocks %d and %d (size = %zu)\n", block_pointed1, block_pointed2,  mdp1->heapinfo[block_pointed1].busy_block.busy_size); 
279                   if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size) != 0){
280                     distance++;
281                   }else{
282                     fprintf(stderr, "False difference detected\n");
283                   }
284                 }else{
285                   distance++;
286                 }
287               }else{ // Fragmented block
288                 address_pointed1 = (char*)mdp1 + ((char*)address_pointed1 - (char*)s_heap);
289                 address_pointed2 = (char*)mdp2 + ((char*)address_pointed2 - (char*)s_heap);
290                 addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE);
291                 addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE);
292                 frag_pointed1 = 0;
293                 while(address_pointed1 > (void*)((char*)addr_block_pointed1 + ((frag_pointed1 +1 ) * frag_size))){
294                   frag_pointed1++;
295                 }
296                 frag_pointed2 = 0;
297                 while(address_pointed2 > (void*)((char*)addr_block_pointed2 + ((frag_pointed2 +1) * frag_size))){
298                   frag_pointed2++;
299                 }
300                 if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]){
301                   fprintf(stderr, "Memcmp between fragments %d (block %d) and %d (block %d) (size = %d)\n", frag_pointed1, block_pointed1, frag_pointed2, block_pointed2,  mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]); 
302                   if(memcmp((char*)addr_block_pointed1 + (frag_pointed1 * frag_size), (char*)addr_block_pointed2 + (frag_pointed2 * frag_size), mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
303                     distance++;
304                   }else{
305                     fprintf(stderr, "False difference detected\n");
306                   }
307                 }else{
308                   distance ++;
309                 }
310                   
311                   
312               }
313             }else{
314               distance++;
315             }
316           }else{
317             distance++;
318           }
319             
320         }
321       }
322
323
324       if(distance>0){
325         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);
326         fflush(NULL);
327         fprintf(stderr, "Hamming distance between blocks : %d\n", distance);
328         mmalloc_backtrace_block_display(mdp1, i);
329         mmalloc_backtrace_block_display(mdp2, i);
330         errors++; 
331         total_distance += distance;
332       }
333     
334       
335       i++;
336       
337     }else{
338       
339       if(mdp1->heapinfo[i].type > 0){ /* busy fragmented block */
340
341         if(mdp1->heapinfo[i].type != mdp2->heapinfo[i].type){
342           fprintf(stderr,"Different size of fragments in fragmented block %zu : %d - %d\n", i, mdp1->heapinfo[i].type, mdp2->heapinfo[i].type); fflush(NULL);
343           errors++;
344         }
345
346         if(mdp1->heapinfo[i].busy_frag.nfree != mdp2->heapinfo[i].busy_frag.nfree){
347           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);
348           errors++;
349         } 
350         
351         if(mdp1->heapinfo[i].busy_frag.first != mdp2->heapinfo[i].busy_frag.first){
352           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);
353           errors++;
354         } 
355
356         frag_size = pow(2, mdp1->heapinfo[i].type);
357
358         for(j=0; j< (BLOCKSIZE/frag_size); j++){
359
360           if(mdp1->heapinfo[i].busy_frag.frag_size[j] != mdp2->heapinfo[i].busy_frag.frag_size[j]){
361             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);
362             errors++;
363           }
364
365           if(mdp1->heapinfo[i].busy_frag.frag_size[j] > 0){
366             
367             addr_frag1 = (char *)addr_block1 + (j * frag_size);
368             xbt_assert(addr_frag1 < breakval1, "Fragment address out of heap memory used");
369
370             addr_frag2 = (char *)addr_block2 + (j * frag_size);
371             xbt_assert(addr_frag1 < breakval1, "Fragment address out of heap memory used");
372
373             /* Hamming distance on different blocks */
374             distance = 0;
375             //for(k=0;k<frag_size;k++){
376             for(k=0;k<mdp1->heapinfo[i].busy_frag.frag_size[j];k++){
377               if(memcmp(((char *)addr_frag1) + k, ((char *)addr_frag2) + k, 1) != 0){
378                 //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);
379                 pointer_align = (k / sizeof(void*)) * sizeof(void*);
380                 address_pointed1 = *((void **)((char *)addr_frag1 + pointer_align));
381                 address_pointed2 = *((void **)((char *)addr_frag2 + pointer_align));                               
382                 if(((address_pointed1 > (void *)s_heap) && (address_pointed1 < mdp1->breakval)) && ((address_pointed2 > (void *)s_heap) && (address_pointed2 < mdp2->breakval))){
383                   block_pointed1 = ((char*)address_pointed1 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1;
384                   block_pointed2 = ((char*)address_pointed2 - (char*)((struct mdesc*)s_heap)->heapbase) / BLOCKSIZE + 1;
385                   //fprintf(stderr, "Blocks pointed : %d - %d\n", block_pointed1, block_pointed2);
386                   if(mdp1->heapinfo[block_pointed1].type == mdp2->heapinfo[block_pointed2].type){
387                     if(mdp1->heapinfo[block_pointed1].type == 0){ // Large block
388                       while(mdp1->heapinfo[block_pointed1].busy_block.size == 0)
389                         block_pointed1--;
390                       while(mdp2->heapinfo[block_pointed2].busy_block.size == 0)
391                         block_pointed2--;
392                       if(mdp1->heapinfo[block_pointed1].busy_block.busy_size == mdp2->heapinfo[block_pointed2].busy_block.busy_size){
393                         addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE);
394                         addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE);
395                         fprintf(stderr, "Memcmp between blocks %d and %d (size = %zu)\n", block_pointed1, block_pointed2,  mdp1->heapinfo[block_pointed1].busy_block.busy_size); 
396                         if(memcmp(addr_block_pointed1, addr_block_pointed2, mdp1->heapinfo[block_pointed1].busy_block.busy_size) != 0){
397                           distance++;
398                         }else{
399                           fprintf(stderr, "False difference detected\n");
400                         }
401                       }else{
402                         distance++;
403                       }
404                     }else{ // Fragmented block
405                       address_pointed1 = (char*)mdp1 + ((char*)address_pointed1 - (char*)s_heap);
406                       address_pointed2 = (char*)mdp2 + ((char*)address_pointed2 - (char*)s_heap);
407                       addr_block_pointed1 = (char*)heapbase1 + ((block_pointed1 - 1)*BLOCKSIZE);
408                       addr_block_pointed2 = (char*)heapbase2 + ((block_pointed2 - 1)*BLOCKSIZE);
409                       frag_pointed1 = 0;
410                       while(address_pointed1 > (void*)((char*)addr_block_pointed1 + ((frag_pointed1 + 1) * frag_size))){
411                         frag_pointed1++;
412                       }
413                       frag_pointed2 = 0;
414                       while(address_pointed2 > (void*)((char*)addr_block_pointed2 + ((frag_pointed2 + 1) * frag_size))){
415                         frag_pointed2++;
416                       }
417                       if(mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1] == mdp2->heapinfo[block_pointed2].busy_frag.frag_size[frag_pointed2]){
418                         fprintf(stderr, "Memcmp between fragments %d (block %d) and %d (block %d) (size = %d)\n", frag_pointed1, block_pointed1, frag_pointed2, block_pointed2,  mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]); 
419                         if(memcmp((char*)addr_block_pointed1 + (frag_pointed1 * frag_size), (char*)addr_block_pointed2 + (frag_pointed2 * frag_size), mdp1->heapinfo[block_pointed1].busy_frag.frag_size[frag_pointed1]) != 0){
420                           distance++;
421                         }else{
422                           fprintf(stderr, "False difference detected\n");
423                         }
424                       }else{
425                         distance ++;
426                       }
427                     }
428                   }else{
429                     distance++;
430                   }
431                 }else{
432                   distance++;
433                 }
434               }
435
436             }
437             
438             if(distance > 0){
439               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);
440               fprintf(stderr, "Hamming distance between fragments : %d\n", distance);
441               mmalloc_backtrace_fragment_display(mdp1, i, j);
442               mmalloc_backtrace_fragment_display(mdp2, i, j);
443               errors++;
444               total_distance += distance;
445               
446             }
447
448           }
449         }
450
451         i++;
452
453       }else{ /* free block */
454
455         i++;
456
457       }
458       
459     }
460
461   }
462
463
464   fprintf(stderr, "Hamming distance between heap regions : %d\n", total_distance);
465
466   return (errors);
467 }
468
469
470 /* void *get_end_addr_heap(void *heap){ */
471
472 /*   FILE *fp;                     /\* File pointer to process's proc maps file *\/ */
473 /*   char *line = NULL;            /\* Temporal storage for each line that is readed *\/ */
474 /*   ssize_t read;                 /\* Number of bytes readed *\/ */
475 /*   size_t n = 0;                 /\* Amount of bytes to read by getline *\/ */
476
477 /*   fp = fopen("/proc/self/maps", "r"); */
478   
479 /*   if(fp == NULL) */
480 /*     perror("fopen failed"); */
481
482
483 /*   xbt_dynar_t lfields = NULL; */
484 /*   xbt_dynar_t start_end  = NULL; */
485 /*   void *start_addr; */
486 /*   void *end_addr; */
487
488 /*   while ((read = getline(&line, &n, fp)) != -1) { */
489
490 /*     xbt_str_trim(line, NULL); */
491 /*     xbt_str_strip_spaces(line); */
492 /*     lfields = xbt_str_split(line,NULL); */
493
494 /*     start_end = xbt_str_split(xbt_dynar_get_as(lfields, 0, char*), "-"); */
495 /*     start_addr = (void *) strtoul(xbt_dynar_get_as(start_end, 0, char*), NULL, 16); */
496 /*     end_addr = (void *) strtoul(xbt_dynar_get_as(start_end, 1, char*), NULL, 16); */
497
498 /*     if(start_addr == heap){ */
499 /*       free(line); */
500 /*       fclose(fp); */
501 /*       xbt_dynar_reset(lfields); */
502 /*       xbt_free(lfields); */
503 /*       xbt_dynar_reset(start_end); */
504 /*       xbt_free(start_end); */
505 /*       return end_addr; */
506 /*     } */
507
508 /*   } */
509
510 /*   xbt_dynar_reset(lfields); */
511 /*   xbt_free(lfields); */
512 /*   xbt_dynar_reset(start_end); */
513 /*   xbt_free(start_end); */
514 /*   free(line); */
515 /*   fclose(fp); */
516 /*   return NULL; */
517
518
519 /* } */
520
521
522 void mmalloc_display_info_heap(xbt_mheap_t h){
523
524 }
525
526
527