+ mdp -> heapstats.bytes_used += 1 << log;
+ mdp -> heapstats.chunks_free--;
+ mdp -> heapstats.bytes_free -= 1 << 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); // does not return NULL
+
+ /* Link all fragments but the first into the free list, and mark their requested size to 0. */
+ block = BLOCK(result);
+ for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i) {
+ mdp->heapinfo[block].busy_frag.frag_size[i] = 0;
+ 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;
+ }
+ }
+ mdp->heapinfo[block].busy_frag.frag_size[0] = requested_size;
+ xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_frag.bt[0],XBT_BACKTRACE_SIZE);
+
+ /* Initialize the nfree and first counters for this block. */
+ mdp->heapinfo[block].type = log;
+ mdp->heapinfo[block].busy_frag.nfree = i - 1;
+ mdp->heapinfo[block].busy_frag.first = i - 1;
+
+ mdp -> heapstats.chunks_free += (BLOCKSIZE >> log) - 1;
+ mdp -> heapstats.bytes_free += BLOCKSIZE - (1 << log);
+ mdp -> heapstats.bytes_used -= BLOCKSIZE - (1 << log);
+ }
+ } 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_block.size < blocks) {
+ if (mdp->heapinfo[block].type >=0) { // Don't trust xbt_die and friends in malloc-level library, you fool!
+ fprintf(stderr,"Internal error: found a free block not marked as such (block=%lu type=%lu). Please report this bug.\n",(unsigned long)block,(unsigned long)mdp->heapinfo[block].type);
+ abort();
+ }
+
+ block = mdp->heapinfo[block].free_block.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_block.prev;
+ lastblocks = mdp->heapinfo[block].free_block.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_block.prev;
+
+ mdp->heapinfo[block].free_block.size += (blocks - lastblocks);
+ continue;
+ }
+ result = register_morecore(mdp, blocks * BLOCKSIZE);
+
+ block = BLOCK(result);
+ for (it=0;it<blocks;it++)
+ mdp->heapinfo[block+it].type = 0;
+ mdp->heapinfo[block].busy_block.size = blocks;
+ mdp->heapinfo[block].busy_block.busy_size = requested_size;
+ mdp->heapinfo[block].busy_block.bt_size=xbt_backtrace_no_malloc(mdp->heapinfo[block].busy_block.bt,XBT_BACKTRACE_SIZE);
+ mdp -> heapstats.chunks_used++;
+ mdp -> heapstats.bytes_used += blocks * BLOCKSIZE;
+ return result;
+ }
+ /* Need large block(s), but found some in the existing heap */