From 5e4e9f83ad19e0bae9c7fa0c779ce17ed4b3df4f Mon Sep 17 00:00:00 2001 From: Marion Guthmuller Date: Sun, 29 Jan 2012 14:43:21 +0100 Subject: [PATCH] model-checker : more debug informations in function mmalloc_compare_mdesc --- src/xbt/mmalloc/mm_legacy.c | 344 +++++++++++++++++++++++++++--------- 1 file changed, 265 insertions(+), 79 deletions(-) diff --git a/src/xbt/mmalloc/mm_legacy.c b/src/xbt/mmalloc/mm_legacy.c index 2f9a247a54..0a5f6d5cc2 100644 --- a/src/xbt/mmalloc/mm_legacy.c +++ b/src/xbt/mmalloc/mm_legacy.c @@ -177,115 +177,190 @@ int mmalloc_compare_heap(void *h1, void *h2){ /* Heapstats */ + int errors = 0; + struct mstats ms1 = mmstats(h1); struct mstats ms2 = mmstats(h2); if(ms1.chunks_used != ms2.chunks_used){ - XBT_DEBUG("Different chunks allocated by the user : %zu - %zu", ms1.chunks_used, ms2.chunks_used); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different chunks allocated by the user : %zu - %zu", ms1.chunks_used, ms2.chunks_used); + errors++; + }else{ + return 1; + } } if(ms1.bytes_used != ms2.bytes_used){ - XBT_DEBUG("Different byte total of user-allocated chunks : %zu - %zu", ms1.bytes_used, ms2.bytes_used); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different byte total of user-allocated chunks : %zu - %zu", ms1.bytes_used, ms2.bytes_used); + errors++; + }else{ + return 1; + } } if(ms1.bytes_free != ms2.bytes_free){ - XBT_DEBUG("Different byte total of chunks in the free list : %zu - %zu", ms1.bytes_free, ms2.bytes_free); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different byte total of chunks in the free list : %zu - %zu", ms1.bytes_free, ms2.bytes_free); + errors++; + }else{ + return 1; + } } if(ms1.chunks_free != ms2.chunks_free){ - XBT_DEBUG("Different chunks in the free list : %zu - %zu", ms1.chunks_free, ms2.chunks_free); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different chunks in the free list : %zu - %zu", ms1.chunks_free, ms2.chunks_free); + errors++; + }else{ + return 1; + } } struct mdesc *mdp1, *mdp2; mdp1 = MD_TO_MDP(h1); mdp2 = MD_TO_MDP(h2); - return mmalloc_compare_mdesc(mdp1, mdp2); + int res = mmalloc_compare_mdesc(mdp1, mdp2); + + return ((errors + res ) > 0); } int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){ + int errors = 0; + if(mdp1->headersize != mdp2->headersize){ - XBT_DEBUG("Different size of the file header for the mapped files"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different size of the file header for the mapped files"); + errors++; + }else{ + return 1; + } } if(mdp1->refcount != mdp2->refcount){ - XBT_DEBUG("Different number of processes that attached the heap"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different number of processes that attached the heap"); + errors++; + }else{ + return 1; + } } if(strcmp(mdp1->magic, mdp2->magic) != 0){ - XBT_DEBUG("Different magic number"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different magic number"); + errors++; + }else{ + return 1; + } } if(mdp1->flags != mdp2->flags){ - XBT_DEBUG("Different flags"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different flags"); + errors++; + }else{ + return 1; + } } if(mdp1->heapsize != mdp2->heapsize){ - XBT_DEBUG("Different number of info entries"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different number of info entries"); + errors++; + }else{ + return 1; + } } //XBT_DEBUG("Heap size : %zu", mdp1->heapsize); if(mdp1->heapbase != mdp2->heapbase){ - XBT_DEBUG("Different first block of the heap"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different first block of the heap"); + errors++; + }else{ + return 1; + } } if(mdp1->heapindex != mdp2->heapindex){ - XBT_DEBUG("Different index for the heap table : %zu - %zu", mdp1->heapindex, mdp2->heapindex); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different index for the heap table : %zu - %zu", mdp1->heapindex, mdp2->heapindex); + errors++; + }else{ + return 1; + } } //XBT_DEBUG("Heap index : %zu", mdp1->heapindex); if(mdp1->base != mdp2->base){ - XBT_DEBUG("Different base address of the memory region"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different base address of the memory region"); + errors++; + }else{ + return 1; + } } if(mdp1->breakval != mdp2->breakval){ - XBT_DEBUG("Different current location in the memory region"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different current location in the memory region"); + errors++; + }else{ + return 1; + } } if(mdp1->top != mdp2->top){ - XBT_DEBUG("Different end of the current location in the memory region"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different end of the current location in the memory region"); + errors++; + }else{ + return 1; + } } if(mdp1->heaplimit != mdp2->heaplimit){ - XBT_DEBUG("Different limit of valid info table indices"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different limit of valid info table indices"); + errors++; + }else{ + return 1; + } } - //XBT_DEBUG("Heap limit : %zu", mdp1->heaplimit); - - if(mdp1->fd != mdp2->fd){ - XBT_DEBUG("Different file descriptor for the file to which this malloc heap is mapped"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different file descriptor for the file to which this malloc heap is mapped"); + errors++; + }else{ + return 1; + } } if(mdp1->saved_errno != mdp2->saved_errno){ - XBT_DEBUG("Different errno"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different errno"); + errors++; + }else{ + return 1; + } } if(mdp1->version != mdp2->version){ - XBT_DEBUG("Different version of the mmalloc package"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different version of the mmalloc package"); + errors++; + }else{ + return 1; + } } @@ -309,15 +384,23 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){ } if(block_free1 != block_free2){ - XBT_DEBUG("Different first free block"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different first free block"); + errors++; + }else{ + return 1; + } } first_block_free = block_free1; if(mdp1->heapinfo[first_block_free].free.size != mdp2->heapinfo[first_block_free].free.size){ - XBT_DEBUG("Different size (in blocks) of the first free cluster"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different size (in blocks) of the first free cluster"); + errors++; + }else{ + return 1; + } } /* Check busy blocks (circular checking)*/ @@ -325,26 +408,31 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){ i = first_block_free + mdp1->heapinfo[first_block_free].free.size; if(mdp1->heapinfo[first_block_free].free.next != mdp2->heapinfo[first_block_free].free.next){ - XBT_DEBUG("Different next block free"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different next block free"); + errors++; + }else{ + return 1; + } } block_free = first_block_free; next_block_free = mdp1->heapinfo[first_block_free].free.next; - //XBT_DEBUG("First block free : %zu (size=%zu), Next block free : %zu", first_block_free, mdp1->heapinfo[block_free1].free.size, next_block_free); - if(next_block_free == 0) next_block_free = mdp1->heaplimit; - while(i != first_block_free){ while(iheapinfo[i].busy.type != mdp2->heapinfo[i].busy.type){ - XBT_DEBUG("Different type of busy block"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different type of busy block"); + errors++; + }else{ + return 1; + } }else{ addr_block1 = (char *)mdp1 + sizeof(struct mdesc) + ((i-1) * BLOCKSIZE); @@ -353,65 +441,163 @@ int mmalloc_compare_mdesc(struct mdesc *mdp1, struct mdesc *mdp2){ switch(mdp1->heapinfo[i].busy.type){ case 0 : if(mdp1->heapinfo[i].busy.info.size != mdp2->heapinfo[i].busy.info.size){ - XBT_DEBUG("Different size of a large cluster"); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different size of a large cluster"); + errors++; + }else{ + return 1; + } }else{ if(memcmp(addr_block1, addr_block2, (mdp1->heapinfo[i].busy.info.size * BLOCKSIZE)) != 0){ - XBT_DEBUG("Different data in block %zu", i); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different data in block %zu (size = %zu) (addr_block1 = %p - addr_block2 = %p)", i, mdp1->heapinfo[i].busy.info.size, addr_block1, addr_block2); + errors++; + }else{ + return 1; + } } } i = i+mdp1->heapinfo[i].busy.info.size; + break; default : if(mdp1->heapinfo[i].busy.info.frag.nfree != mdp2->heapinfo[i].busy.info.frag.nfree){ - XBT_DEBUG("Different free fragments in the fragmented block %zu", i); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different free fragments in the fragmented block %zu", i); + errors++; + }else{ + return 1; + } }else{ if(mdp1->heapinfo[i].busy.info.frag.first != mdp2->heapinfo[i].busy.info.frag.first){ - XBT_DEBUG("Different first free fragments in the block %zu", i); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different first free fragments in the block %zu", i); + errors++; + }else{ + return 1; + } }else{ frag_size = pow(2,mdp1->heapinfo[i].busy.type); for(j=0 ; j< (BLOCKSIZE/frag_size); j++){ if(memcmp((char *)addr_block1 + (j * frag_size), (char *)addr_block2 + (j * frag_size), frag_size) != 0){ - XBT_DEBUG("Different data in fragment %zu of block %zu", j + 1, i); - return 1; + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different data in fragment %zu (addr_frag1 = %p - addr_frag2 = %p) of block %zu", j + 1, (char *)addr_block1 + (j * frag_size), (char *)addr_block2 + (j * frag_size), i); + errors++; + }else{ + return 1; + } } } } } + i++; + break; } } } - if(mdp1->heapinfo[block_free].free.next != mdp2->heapinfo[block_free].free.next){ - XBT_DEBUG("Different next block free"); - return 1; - } - - block_free = mdp1->heapinfo[block_free].free.next; - next_block_free = mdp1->heapinfo[block_free].free.next; - if(i != first_block_free){ - if(block_free != 0){ - if(mdp1->heapinfo[block_free].free.size != mdp2->heapinfo[block_free].free.size){ - XBT_DEBUG("Different size of block free"); + if( i != first_block_free){ + + if(mdp1->heapinfo[block_free].free.next != mdp2->heapinfo[block_free].free.next){ + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different next block free"); + errors++; + }else{ return 1; } - i = block_free + mdp1->heapinfo[block_free].free.size; - }else{ - i = 1; } + + block_free = mdp1->heapinfo[block_free].free.next; + next_block_free = mdp1->heapinfo[block_free].free.next; + + i = block_free + mdp1->heapinfo[block_free].free.size; + + if((next_block_free == 0) && (i != mdp1->heaplimit)){ + + while(i < mdp1->heaplimit){ + + if(mdp1->heapinfo[i].busy.type != mdp2->heapinfo[i].busy.type){ + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different type of busy block"); + errors++; + }else{ + return 1; + } + }else{ + + addr_block1 = (char *)mdp1 + sizeof(struct mdesc) + ((i-1) * BLOCKSIZE); + addr_block2 = (char *)mdp2 + sizeof(struct mdesc) + ((i-1) * BLOCKSIZE); + + switch(mdp1->heapinfo[i].busy.type){ + case 0 : + if(mdp1->heapinfo[i].busy.info.size != mdp2->heapinfo[i].busy.info.size){ + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different size of a large cluster"); + errors++; + }else{ + return 1; + } + }else{ + if(memcmp(addr_block1, addr_block2, (mdp1->heapinfo[i].busy.info.size * BLOCKSIZE)) != 0){ + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different data in block %zu (addr_block1 = %p - addr_block2 = %p)", i, addr_block1, addr_block2); + errors++; + }else{ + return 1; + } + } + } + + i = i+mdp1->heapinfo[i].busy.info.size; + + break; + default : + if(mdp1->heapinfo[i].busy.info.frag.nfree != mdp2->heapinfo[i].busy.info.frag.nfree){ + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different free fragments in the fragmented block %zu", i); + errors++; + }else{ + return 1; + } + }else{ + if(mdp1->heapinfo[i].busy.info.frag.first != mdp2->heapinfo[i].busy.info.frag.first){ + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different first free fragments in the block %zu", i); + errors++; + }else{ + return 1; + } + }else{ + frag_size = pow(2,mdp1->heapinfo[i].busy.type); + for(j=0 ; j< (BLOCKSIZE/frag_size); j++){ + if(memcmp((char *)addr_block1 + (j * frag_size), (char *)addr_block2 + (j * frag_size), frag_size) != 0){ + if(XBT_LOG_ISENABLED(xbt_mm_legacy, xbt_log_priority_debug)){ + XBT_DEBUG("Different data in fragment %zu (addr_frag1 = %p - addr_frag2 = %p) of block %zu", j + 1, (char *)addr_block1 + (j * frag_size), (char *)addr_block2 + (j * frag_size), i); + errors++; + }else{ + return 1; + } + } + } + } + } + + i++; + + break; + } + } + } + + } + } - } - return 0; - - + return (errors>0); } -- 2.20.1