- /* At this point we have found a suitable free list entry.
- Figure out how to remove what we need from the list. */
- result = ADDRESS(block);
- if (mdp -> heapinfo[block].free.size > blocks)
- {
- /* The block we found has a bit left over,
- so relink the tail end back into the free list. */
- mdp -> heapinfo[block + blocks].free.size
- = mdp -> heapinfo[block].free.size - blocks;
- mdp -> heapinfo[block + blocks].free.next
- = mdp -> heapinfo[block].free.next;
- mdp -> heapinfo[block + blocks].free.prev
- = mdp -> heapinfo[block].free.prev;
- mdp -> heapinfo[mdp -> heapinfo[block].free.prev].free.next
- = mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev
- = mdp -> heapindex = block + blocks;
- }
- else
- {
- /* The block exactly matches our requirements,
- so just remove it from the list. */
- mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev
- = mdp -> heapinfo[block].free.prev;
- mdp -> heapinfo[mdp -> heapinfo[block].free.prev].free.next
- = mdp -> heapindex = mdp -> heapinfo[block].free.next;
- mdp -> heapstats.chunks_free--;
- }
-
- mdp -> heapinfo[block].busy.type = 0;
- mdp -> heapinfo[block].busy.info.size = blocks;
- mdp -> heapstats.chunks_used++;
- mdp -> heapstats.bytes_used += blocks * BLOCKSIZE;
- mdp -> heapstats.bytes_free -= blocks * BLOCKSIZE;
+ /* Look in the fragment lists for a
+ free fragment of the desired size. */
+ next = mdp->fraghead[log].next;
+ if (next != NULL) {
+ /* There are free fragments of this size.
+ Pop a fragment out of the fragment list and return it.
+ Update the block's nfree and first counters. */
+ result = (void *) next;
+ next->prev->next = next->next;
+ if (next->next != NULL) {
+ next->next->prev = next->prev;
+ }
+ block = BLOCK(result);
+ if (--mdp->heapinfo[block].busy.info.frag.nfree != 0) {
+ mdp->heapinfo[block].busy.info.frag.first =
+ RESIDUAL(next->next, BLOCKSIZE) >> log;
+ }
+
+ } else {
+ /* No free fragments of the desired size, so get a new block
+ and break it into fragments, returning the first. */
+ //printf("(%s) No free fragment...",xbt_thread_self_name());
+ result = mmalloc(mdp, BLOCKSIZE);
+ //printf("(%s) Fragment: %p...",xbt_thread_self_name(),result);
+ if (result == NULL) {
+ return (NULL);
+ }
+
+ /* Link all fragments but the first into the free list. */
+ for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i) {
+ next = (struct list *) ((char *) result + (i << log));
+ next->next = mdp->fraghead[log].next;
+ next->prev = &mdp->fraghead[log];
+ next->prev->next = next;
+ if (next->next != NULL) {
+ next->next->prev = next;
+ }
+ }
+
+ /* Initialize the nfree and first counters for this block. */
+ block = BLOCK(result);
+ mdp->heapinfo[block].busy.type = log;
+ mdp->heapinfo[block].busy.info.frag.nfree = i - 1;
+ mdp->heapinfo[block].busy.info.frag.first = i - 1;
+ }
+ } else {
+ /* Large allocation to receive one or more blocks.
+ Search the free list in a circle starting at the last place visited.
+ If we loop completely around without finding a large enough
+ space we will have to get more memory from the system. */
+ blocks = BLOCKIFY(size);
+ start = block = MALLOC_SEARCH_START;
+ while (mdp->heapinfo[block].free.size < blocks) {
+ block = mdp->heapinfo[block].free.next;
+ if (block == start) {
+ /* Need to get more from the system. Check to see if
+ the new core will be contiguous with the final free
+ block; if so we don't need to get as much. */
+ block = mdp->heapinfo[0].free.prev;
+ lastblocks = mdp->heapinfo[block].free.size;
+ if (mdp->heaplimit != 0 &&
+ block + lastblocks == mdp->heaplimit &&
+ mmorecore(mdp, 0) == ADDRESS(block + lastblocks) &&
+ (register_morecore(mdp, (blocks - lastblocks) * BLOCKSIZE)) != NULL) {
+ /* Which block we are extending (the `final free
+ block' referred to above) might have changed, if
+ it got combined with a freed info table. */
+ block = mdp->heapinfo[0].free.prev;
+
+ mdp->heapinfo[block].free.size += (blocks - lastblocks);
+ continue;
+ }
+ result = register_morecore(mdp, blocks * BLOCKSIZE);
+ if (result == NULL) {
+ return (NULL);
+ }
+ block = BLOCK(result);
+ mdp->heapinfo[block].busy.type = 0;
+ mdp->heapinfo[block].busy.info.block.size = blocks;
+ mdp->heapinfo[block].busy.info.block.busy_size = size;
+ return (result);
+ }