X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/72a8adff27c51a64b9e2e95e561d8d6950310568..08d324beef1e0fa723013987a98ed7740d2f8343:/src/xbt/mmalloc/mfree.c diff --git a/src/xbt/mmalloc/mfree.c b/src/xbt/mmalloc/mfree.c index 41eefb106d..f452a9ef1b 100644 --- a/src/xbt/mmalloc/mfree.c +++ b/src/xbt/mmalloc/mfree.c @@ -15,7 +15,8 @@ /* Return memory to the heap. Like `mfree' but don't call a mfree_hook if there is one. */ -void __mmalloc_free(struct mdesc *mdp, void *ptr) +/* Return memory to the heap. */ +void mfree(struct mdesc *mdp, void *ptr) { int type; size_t block; @@ -23,20 +24,33 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) struct list *prev, *next; int it; + if (ptr == NULL) + return; + block = BLOCK(ptr); if ((char *) ptr < (char *) mdp->heapbase || block > mdp->heapsize) { - printf("Ouch, this pointer is not mine. I refuse to free it.\n"); - return; + fprintf(stderr,"Ouch, this pointer is not mine. I refuse to free it. I refuse it to death!!\n"); + abort(); } type = mdp->heapinfo[block].type; - if (type<0) - THROWF(arg_error,0,"Asked to free a fragment in a block that is already free. I'm puzzled"); switch (type) { + case -1: /* Already free */ + 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; + /* 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. */ @@ -59,8 +73,14 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) /* Coalesce this block with its predecessor. */ mdp->heapinfo[i].free_block.size += mdp->heapinfo[block].busy_block.size; /* Mark all my ex-blocks as free */ - for (it=0; itheapinfo[block].busy_block.size; it++) - mdp->heapinfo[block+it].type = -1; + for (it=0; itheapinfo[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); + abort(); + } + mdp->heapinfo[block+it].type = -1; + } block = i; } else { @@ -71,9 +91,16 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) mdp->heapinfo[block].free_block.prev = i; mdp->heapinfo[i].free_block.next = block; mdp->heapinfo[mdp->heapinfo[block].free_block.next].free_block.prev = block; + mdp -> heapstats.chunks_free++; /* Mark all my ex-blocks as free */ - for (it=0; itheapinfo[block].free_block.size; it++) - mdp->heapinfo[block+it].type = -1; + for (it=0; itheapinfo[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); + abort(); + } + mdp->heapinfo[block+it].type = -1; + } } /* Now that the block is linked in, see if we can coalesce it @@ -82,38 +109,46 @@ void __mmalloc_free(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; break; 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; + + /* 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) { @@ -127,11 +162,17 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) if (next != NULL) { next->prev = prev->prev; } - /* pretend the block is used and free it so that it gets properly coalesced with adjacent free blocks */ + /* pretend that this block is used and free it so that it gets properly coalesced with adjacent free blocks */ mdp->heapinfo[block].type = 0; mdp->heapinfo[block].busy_block.size = 1; mdp->heapinfo[block].busy_block.busy_size = 0; - + + /* Keep the statistics accurate. */ + mdp -> heapstats.chunks_used++; + mdp -> heapstats.bytes_used += BLOCKSIZE; + mdp -> heapstats.chunks_free -= BLOCKSIZE >> type; + mdp -> heapstats.bytes_free -= BLOCKSIZE; + mfree((void *) mdp, (void *) ADDRESS(block)); } else if (mdp->heapinfo[block].busy_frag.nfree != 0) { /* If some fragments of this block are free, link this @@ -148,11 +189,11 @@ void __mmalloc_free(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; @@ -163,11 +204,3 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) break; } } - -/* Return memory to the heap. */ - -void mfree(xbt_mheap_t mdp, void *ptr) -{ - if (ptr != NULL) - __mmalloc_free(mdp, ptr); -}