X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/87817af89b2262a403386b38a0ec95388a6df5ad..1e117c3744cf64c0bc5d05340b6933e593ba52d0:/src/xbt/mmalloc/mfree.c diff --git a/src/xbt/mmalloc/mfree.c b/src/xbt/mmalloc/mfree.c index db57be44c5..f452a9ef1b 100644 --- a/src/xbt/mmalloc/mfree.c +++ b/src/xbt/mmalloc/mfree.c @@ -15,27 +15,42 @@ /* 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; register size_t i; 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. */ @@ -54,16 +69,38 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) /* Determine how to link this block into the free list. */ if (block == i + mdp->heapinfo[i].free_block.size) { + /* 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++) { + 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 { + //fprintf(stderr,"Free block %d to %d (as a new chunck)\n",block,block+mdp->heapinfo[block].busy_block.size); /* Really link this block back into the free list. */ mdp->heapinfo[block].free_block.size = mdp->heapinfo[block].busy_block.size; mdp->heapinfo[block].free_block.next = mdp->heapinfo[i].free_block.next; 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++) { + 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 @@ -72,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) { @@ -117,10 +162,17 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) if (next != NULL) { next->prev = prev->prev; } + /* 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 @@ -135,13 +187,13 @@ void __mmalloc_free(struct mdesc *mdp, void *ptr) } ++mdp->heapinfo[block].busy_frag.nfree; } else { - /* No fragments of this block are free, so link this - fragment into the fragment list and announce that - it is the first free fragment of this block. */ + /* 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. */ 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; @@ -152,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); -}