void umm_free( void *ptr ) {
unsigned short int c;
/* If we're being asked to free a NULL pointer, well that's just silly! */
if( (void *)0 == ptr ) {
DBGLOG_DEBUG( "free a null pointer -> do nothing\n" );
return;
}
/*
* FIXME: At some point it might be a good idea to add a check to make sure
* that the pointer we're being asked to free up is actually within
* the umm_heap!
*
* NOTE: See the new umm_info() function that you can use to see if a ptr is
* on the free list!
*/
/* Protect the critical section... */
UMM_CRITICAL_ENTRY();
/* Figure out which block we're in. Note the use of truncated division... */
c = (((char *)ptr)-(char *)(&(umm_heap[0])))/sizeof(umm_block);
DBGLOG_DEBUG( "Freeing block %6i\n", c );
/* Now let's assimilate this block with the next one if possible. */
umm_assimilate_up( c );
/* Then assimilate with the previous block if possible */
if( UMM_NBLOCK(UMM_PBLOCK(c)) & UMM_FREELIST_MASK ) {
DBGLOG_DEBUG( "Assimilate down to next block, which is FREE\n" );
c = umm_assimilate_down(c, UMM_FREELIST_MASK);
} else {
/*
* The previous block is not a free block, so add this one to the head
* of the free list
*/
DBGLOG_DEBUG( "Just add to head of free list\n" );
UMM_PFREE(UMM_NFREE(0)) = c;
UMM_NFREE(c) = UMM_NFREE(0);
UMM_PFREE(c) = 0;
UMM_NFREE(0) = c;
UMM_NBLOCK(c) |= UMM_FREELIST_MASK;
}
/* Release the critical section... */
UMM_CRITICAL_EXIT();
}
void umm_init_x( size_t size ) {
uint32_t UMM_MALLOC_CFG_HEAP_SIZE = (size / sizeof(size_t)) * sizeof(size_t);
if (UMM_MALLOC_CFG_HEAP_SIZE < (sizeof(umm_block) * 128)) fb_alloc_fail();
if (UMM_MALLOC_CFG_HEAP_SIZE > (sizeof(umm_block) * 32768)) UMM_MALLOC_CFG_HEAP_SIZE = sizeof(umm_block) * 32768;
void *UMM_MALLOC_CFG_HEAP_ADDR = fb_alloc(UMM_MALLOC_CFG_HEAP_SIZE);
/* init heap pointer and size, and memset it to 0 */
umm_heap = (umm_block *)UMM_MALLOC_CFG_HEAP_ADDR;
umm_numblocks = (UMM_MALLOC_CFG_HEAP_SIZE / sizeof(umm_block));
memset(umm_heap, 0x00, UMM_MALLOC_CFG_HEAP_SIZE);
/* setup initial blank heap structure */
{
/* index of the 0th `umm_block` */
const unsigned short int block_0th = 0;
/* index of the 1st `umm_block` */
const unsigned short int block_1th = 1;
/* index of the latest `umm_block` */
const unsigned short int block_last = UMM_NUMBLOCKS - 1;
/* setup the 0th `umm_block`, which just points to the 1st */
UMM_NBLOCK(block_0th) = block_1th;
UMM_NFREE(block_0th) = block_1th;
UMM_PFREE(block_0th) = block_1th;
/*
* Now, we need to set the whole heap space as a huge free block. We should
* not touch the 0th `umm_block`, since it's special: the 0th `umm_block`
* is the head of the free block list. It's a part of the heap invariant.
*
* See the detailed explanation at the beginning of the file.
*/
/*
* 1th `umm_block` has pointers:
*
* - next `umm_block`: the latest one
* - prev `umm_block`: the 0th
*
* Plus, it's a free `umm_block`, so we need to apply `UMM_FREELIST_MASK`
*
* And it's the last free block, so the next free block is 0.
*/
UMM_NBLOCK(block_1th) = block_last | UMM_FREELIST_MASK;
UMM_NFREE(block_1th) = 0;
UMM_PBLOCK(block_1th) = block_0th;
UMM_PFREE(block_1th) = block_0th;
/*
* latest `umm_block` has pointers:
*
* - next `umm_block`: 0 (meaning, there are no more `umm_blocks`)
* - prev `umm_block`: the 1st
*
* It's not a free block, so we don't touch NFREE / PFREE at all.
*/
UMM_NBLOCK(block_last) = 0;
UMM_PBLOCK(block_last) = block_1th;
}
}
static void umm_disconnect_from_free_list( unsigned short int c ) {
// Disconnect this block from the FREE list
UMM_NFREE(UMM_PFREE(c)) = UMM_NFREE(c);
UMM_PFREE(UMM_NFREE(c)) = UMM_PFREE(c);
// And clear the free block indicator
UMM_NBLOCK(c) &= (~UMM_FREELIST_MASK);
}
void *umm_malloc( size_t size ) {
unsigned short int blocks;
unsigned short int blockSize = 0;
unsigned short int bestSize;
unsigned short int bestBlock;
unsigned short int cf;
// the very first thing we do is figure out if we're being asked to allocate
// a size of 0 - and if we are we'll simply return a null pointer. if not
// then reduce the size by 1 byte so that the subsequent calculations on
// the number of blocks to allocate are easier...
if( 0 == size ) {
DBG_LOG_DEBUG( "malloc a block of 0 bytes -> do nothing\n" );
return( (void *)NULL );
}
// Protect the critical section...
//
UMM_CRITICAL_ENTRY();
blocks = umm_blocks( size );
// Now we can scan through the free list until we find a space that's big
// enough to hold the number of blocks we need.
//
// This part may be customized to be a best-fit, worst-fit, or first-fit
// algorithm
cf = UMM_NFREE(0);
bestBlock = UMM_NFREE(0);
bestSize = 0x7FFF;
while( UMM_NFREE(cf) ) {
blockSize = (UMM_NBLOCK(cf) & UMM_BLOCKNO_MASK) - cf;
DBG_LOG_TRACE( "Looking at block %6i size %6i\n", cf, blockSize );
#if defined UMM_FIRST_FIT
// This is the first block that fits!
if( (blockSize >= blocks) )
break;
#elif defined UMM_BEST_FIT
if( (blockSize >= blocks) && (blockSize < bestSize) ) {
bestBlock = cf;
bestSize = blockSize;
}
#endif
cf = UMM_NFREE(cf);
}
if( 0x7FFF != bestSize ) {
cf = bestBlock;
blockSize = bestSize;
}
if( UMM_NBLOCK(cf) & UMM_BLOCKNO_MASK ) {
// This is an existing block in the memory heap, we just need to split off
// what we need, unlink it from the free list and mark it as in use, and
// link the rest of the block back into the freelist as if it was a new
// block on the free list...
if( blockSize == blocks ) {
// It's an exact fit and we don't neet to split off a block.
DBG_LOG_DEBUG( "Allocating %6d blocks starting at %6d - exact\n", blocks, cf );
// Disconnect this block from the FREE list
umm_disconnect_from_free_list( cf );
} else {
// It's not an exact fit and we need to split off a block.
DBG_LOG_DEBUG( "Allocating %6d blocks starting at %6d - existing\n", blocks, cf );
umm_make_new_block( cf, blockSize-blocks, UMM_FREELIST_MASK );
cf += blockSize-blocks;
}
} else {
// We're at the end of the heap - allocate a new block, but check to see if
// there's enough memory left for the requested block! Actually, we may need
// one more than that if we're initializing the umm_heap for the first
// time, which happens in the next conditional...
if( UMM_NUMBLOCKS <= cf+blocks+1 ) {
DBG_LOG_WARNING( "Can't allocate %5d blocks at %5d\n", blocks, cf );
// Release the critical section...
//
UMM_CRITICAL_EXIT();
return( (void *)NULL );
}
// Now check to see if we need to initialize the free list...this assumes
// that the BSS is set to 0 on startup. We should rarely get to the end of
// the free list so this is the "cheapest" place to put the initialization!
if( 0 == cf ) {
DBG_LOG_DEBUG( "Initializing malloc free block pointer\n" );
UMM_NBLOCK(0) = 1;
UMM_NFREE(0) = 1;
cf = 1;
}
DBG_LOG_DEBUG( "Allocating %6d blocks starting at %6d - new \n", blocks, cf );
UMM_NFREE(UMM_PFREE(cf)) = cf+blocks;
memcpy( &UMM_BLOCK(cf+blocks), &UMM_BLOCK(cf), sizeof(umm_block) );
UMM_NBLOCK(cf) = cf+blocks;
UMM_PBLOCK(cf+blocks) = cf;
}
// Release the critical section...
//
UMM_CRITICAL_EXIT();
return( (void *)&UMM_DATA(cf) );
}
void umm_free( void *ptr ) {
unsigned short int c;
// If we're being asked to free a NULL pointer, well that's just silly!
if( (void *)0 == ptr ) {
DBG_LOG_DEBUG( "free a null pointer -> do nothing\n" );
return;
}
// FIXME: At some point it might be a good idea to add a check to make sure
// that the pointer we're being asked to free up is actually within
// the umm_heap!
//
// NOTE: See the new umm_info() function that you can use to see if a ptr is
// on the free list!
// Protect the critical section...
//
UMM_CRITICAL_ENTRY();
// Figure out which block we're in. Note the use of truncated division...
c = (ptr-(void *)(&(umm_heap[0])))/sizeof(umm_block);
DBG_LOG_DEBUG( "Freeing block %6d\n", c );
// Now let's assimilate this block with the next one if possible.
umm_assimilate_up( c );
// Then assimilate with the previous block if possible
if( UMM_NBLOCK(UMM_PBLOCK(c)) & UMM_FREELIST_MASK ) {
DBG_LOG_DEBUG( "Assimilate down to next block, which is FREE\n" );
c = umm_assimilate_down(c, UMM_FREELIST_MASK);
} else {
// The previous block is not a free block, so add this one to the head
// of the free list
DBG_LOG_DEBUG( "Just add to head of free list\n" );
UMM_PFREE(UMM_NFREE(0)) = c;
UMM_NFREE(c) = UMM_NFREE(0);
UMM_PFREE(c) = 0;
UMM_NFREE(0) = c;
UMM_NBLOCK(c) |= UMM_FREELIST_MASK;
}
#if(0)
// The following is experimental code that checks to see if the block we just
// freed can be assimilated with the very last block - it's pretty convoluted in
// terms of block index manipulation, and has absolutely no effect on heap
// fragmentation. I'm not sure that it's worth including but I've left it
// here for posterity.
if( 0 == UMM_NBLOCK(UMM_NBLOCK(c) & UMM_BLOCKNO_MASK ) ) {
if( UMM_PBLOCK(UMM_NBLOCK(c) & UMM_BLOCKNO_MASK) != UMM_PFREE(UMM_NBLOCK(c) & UMM_BLOCKNO_MASK) ) {
UMM_NFREE(UMM_PFREE(UMM_NBLOCK(c) & UMM_BLOCKNO_MASK)) = c;
UMM_NFREE(UMM_PFREE(c)) = UMM_NFREE(c);
UMM_PFREE(UMM_NFREE(c)) = UMM_PFREE(c);
UMM_PFREE(c) = UMM_PFREE(UMM_NBLOCK(c) & UMM_BLOCKNO_MASK);
}
UMM_NFREE(c) = 0;
UMM_NBLOCK(c) = 0;
}
#endif
// Release the critical section...
//
UMM_CRITICAL_EXIT();
}
void *umm_info( void *ptr, int force ) {
unsigned short int blockNo = 0;
// Protect the critical section...
//
UMM_CRITICAL_ENTRY();
// Clear out all of the entries in the heapInfo structure before doing
// any calculations..
//
memset( &heapInfo, 0, sizeof( heapInfo ) );
DBG_LOG_FORCE( force, "\n\nDumping the umm_heap...\n" );
DBG_LOG_FORCE( force, "|0x%08x|B %5d|NB %5d|PB %5d|Z %5d|NF %5d|PF %5d|\n",
&UMM_BLOCK(blockNo),
blockNo,
UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
UMM_PBLOCK(blockNo),
(UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK )-blockNo,
UMM_NFREE(blockNo),
UMM_PFREE(blockNo) );
// Now loop through the block lists, and keep track of the number and size
// of used and free blocks. The terminating condition is an nb pointer with
// a value of zero...
blockNo = UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK;
while( UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK ) {
++heapInfo.totalEntries;
heapInfo.totalBlocks += (UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK )-blockNo;
// Is this a free block?
if( UMM_NBLOCK(blockNo) & UMM_FREELIST_MASK ) {
++heapInfo.freeEntries;
heapInfo.freeBlocks += (UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK )-blockNo;
DBG_LOG_FORCE( force, "|0x%08x|B %5d|NB %5d|PB %5d|Z %5d|NF %5d|PF %5d|\n",
&UMM_BLOCK(blockNo),
blockNo,
UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
UMM_PBLOCK(blockNo),
(UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK )-blockNo,
UMM_NFREE(blockNo),
UMM_PFREE(blockNo) );
// Does this block address match the ptr we may be trying to free?
if( ptr == &UMM_BLOCK(blockNo) ) {
// Release the critical section...
//
UMM_CRITICAL_EXIT();
return( ptr );
}
} else {
++heapInfo.usedEntries;
unsigned usedBlocks = (UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK )-blockNo;
heapInfo.usedBlocks += usedBlocks;
DBG_LOG_FORCE( force, "|0x%08x|B %5d|NB %5d|PB %5d|Z %5d|\n",
&UMM_BLOCK(blockNo),
blockNo,
UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
UMM_PBLOCK(blockNo),
(UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK )-blockNo );
MIOS32_MIDI_SendDebugHexDump((unsigned char *)&UMM_BLOCK(blockNo), usedBlocks * sizeof(umm_block));
}
blockNo = UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK;
}
// Update the accounting totals with information from the last block, the
// rest must be free!
heapInfo.freeBlocks += UMM_NUMBLOCKS-blockNo;
heapInfo.totalBlocks += UMM_NUMBLOCKS-blockNo;
DBG_LOG_FORCE( force, "|0x%08x|B %5d|NB %5d|PB %5d|Z %5d|NF %5d|PF %5d|\n",
&UMM_BLOCK(blockNo),
blockNo,
UMM_NBLOCK(blockNo) & UMM_BLOCKNO_MASK,
UMM_PBLOCK(blockNo),
UMM_NUMBLOCKS-blockNo,
UMM_NFREE(blockNo),
UMM_PFREE(blockNo) );
DBG_LOG_FORCE( force, "Total Entries %5d Used Entries %5d Free Entries %5d\n",
heapInfo.totalEntries,
heapInfo.usedEntries,
heapInfo.freeEntries );
DBG_LOG_FORCE( force, "Total Blocks %5d Used Blocks %5d Free Blocks %5d\n",
heapInfo.totalBlocks,
heapInfo.usedBlocks,
heapInfo.freeBlocks );
DBG_LOG_FORCE( force, "Size of umm_heap is %d bytes, used: %d bytes, free: %d bytes\n",
sizeof(umm_heap),
heapInfo.usedBlocks*sizeof(umm_block),
heapInfo.freeBlocks*sizeof(umm_block));
// Release the critical section...
//
UMM_CRITICAL_EXIT();
return( NULL );
}
void *umm_malloc( size_t size ) {
unsigned short int blocks;
unsigned short int blockSize = 0;
unsigned short int bestSize;
unsigned short int bestBlock;
unsigned short int cf;
if (umm_heap == NULL) {
umm_init();
}
/*
* the very first thing we do is figure out if we're being asked to allocate
* a size of 0 - and if we are we'll simply return a null pointer. if not
* then reduce the size by 1 byte so that the subsequent calculations on
* the number of blocks to allocate are easier...
*/
if( 0 == size ) {
DBGLOG_DEBUG( "malloc a block of 0 bytes -> do nothing\n" );
return( (void *)NULL );
}
/* Protect the critical section... */
UMM_CRITICAL_ENTRY();
blocks = umm_blocks( size );
/*
* Now we can scan through the free list until we find a space that's big
* enough to hold the number of blocks we need.
*
* This part may be customized to be a best-fit, worst-fit, or first-fit
* algorithm
*/
cf = UMM_NFREE(0);
bestBlock = UMM_NFREE(0);
bestSize = 0x7FFF;
while( cf ) {
blockSize = (UMM_NBLOCK(cf) & UMM_BLOCKNO_MASK) - cf;
DBGLOG_TRACE( "Looking at block %6i size %6i\n", cf, blockSize );
#if defined UMM_BEST_FIT
if( (blockSize >= blocks) && (blockSize < bestSize) ) {
bestBlock = cf;
bestSize = blockSize;
}
#elif defined UMM_FIRST_FIT
/* This is the first block that fits! */
if( (blockSize >= blocks) )
break;
#else
# error "No UMM_*_FIT is defined - check umm_malloc_cfg.h"
#endif
cf = UMM_NFREE(cf);
}
if( 0x7FFF != bestSize ) {
cf = bestBlock;
blockSize = bestSize;
}
if( UMM_NBLOCK(cf) & UMM_BLOCKNO_MASK && blockSize >= blocks ) {
/*
* This is an existing block in the memory heap, we just need to split off
* what we need, unlink it from the free list and mark it as in use, and
* link the rest of the block back into the freelist as if it was a new
* block on the free list...
*/
if( blockSize == blocks ) {
/* It's an exact fit and we don't neet to split off a block. */
DBGLOG_DEBUG( "Allocating %6i blocks starting at %6i - exact\n", blocks, cf );
/* Disconnect this block from the FREE list */
umm_disconnect_from_free_list( cf );
} else {
/* It's not an exact fit and we need to split off a block. */
DBGLOG_DEBUG( "Allocating %6i blocks starting at %6i - existing\n", blocks, cf );
/*
* split current free block `cf` into two blocks. The first one will be
* returned to user, so it's not free, and the second one will be free.
*/
umm_split_block( cf, blocks, UMM_FREELIST_MASK /*new block is free*/ );
/*
* `umm_split_block()` does not update the free pointers (it affects
* only free flags), but effectively we've just moved beginning of the
* free block from `cf` to `cf + blocks`. So we have to adjust pointers
* to and from adjacent free blocks.
*/
/* previous free block */
UMM_NFREE( UMM_PFREE(cf) ) = cf + blocks;
UMM_PFREE( cf + blocks ) = UMM_PFREE(cf);
/* next free block */
UMM_PFREE( UMM_NFREE(cf) ) = cf + blocks;
UMM_NFREE( cf + blocks ) = UMM_NFREE(cf);
}
} else {
/* Out of memory */
DBGLOG_DEBUG( "Can't allocate %5i blocks\n", blocks );
/* Release the critical section... */
UMM_CRITICAL_EXIT();
return( (void *)NULL );
}
/* Release the critical section... */
UMM_CRITICAL_EXIT();
return( (void *)&UMM_DATA(cf) );
}
