klish/lub/heap/heap_static_alloc.c

#include "cache.h"

/*--------------------------------------------------------- */
size_t
lub_heap__get_block_overhead(lub_heap_t *this,
                             const void *block)
{
    size_t                   overhead;
    lub_heap_cache_bucket_t *bucket = 0;
    if(this->cache)
    {
        bucket = lub_heap_cache_find_bucket_from_address(this->cache,block);
    }
    if(bucket)
    {
        overhead = lub_heap_cache_bucket__get_block_overhead(bucket,block);
    }
    else
    {
        overhead = sizeof(lub_heap_alloc_block_t);
    }
    return overhead;
}
/*--------------------------------------------------------- */
size_t
lub_heap__get_block_size(lub_heap_t *this,
                         const void *block)
{
    size_t                   bytes = 0;
    lub_heap_cache_bucket_t *bucket = 0;
    if(this->cache)
    {
        bucket = lub_heap_cache_find_bucket_from_address(this->cache,block);
    }
    if(bucket)
    {
        bytes = lub_heap_cache_bucket__get_block_size(bucket,block);
    }
    else
    {
        const lub_heap_tag_t *header = block;
        --header;
        bytes = (header->words << 2);
        bytes -= sizeof(lub_heap_alloc_block_t);
    }
    return bytes;
}
/*--------------------------------------------------------- */
void *
lub_heap_static_alloc(lub_heap_t *this,
                      size_t      requested_size)
{
    void                  *result = NULL;
    lub_heap_free_block_t *free_block;
    /* round up to native alignment */
    words_t                words;
    lub_heap_key_t         key;
    size_t                 size = requested_size;
    
    size  = (size + (LUB_HEAP_ALIGN_NATIVE-1))/LUB_HEAP_ALIGN_NATIVE; 
    size *= LUB_HEAP_ALIGN_NATIVE; 
    words = (size >> 2);
    
    /* initialise the search key */
    key.words   = words;
    key.block   = 0;
    
    /* search for the start of a segment which is large enough for the request */
    while( (free_block = lub_bintree_findnext(&this->free_tree,&key)) )
    {
        lub_heap_tag_t *tail = lub_heap_block__get_tail((lub_heap_block_t*)free_block);
        
        /* is this free block at the start of a segment? */
        if(1 == tail->segment)
        {
            /* yes this is the end of a segment */
            break;
        }
        /* update the search key */
        lub_heap_block_getkey(free_block,(lub_bintree_key_t*)&key);
    }
    if(NULL != free_block)
    {
        /* remove this block from the free tree */
        lub_bintree_remove(&this->free_tree,free_block);
        
        /* 
         * get some memory from the bottom of this free block 
         */
        result = lub_heap_slice_from_top(this,
                                         &free_block,
                                         &words,
                                         BOOL_TRUE);

        if(NULL != free_block)
        {
            /* put the free block back into the tree */
            lub_bintree_insert(&this->free_tree,free_block);
        }
        if(NULL != result)
        {
            size_t allocated_size = (words << 2);
            /* update the stats */
            ++this->stats.static_blocks;
            this->stats.static_bytes    += size;
            this->stats.static_overhead += (allocated_size - size); 
        }
    }
    return result;
}
/*--------------------------------------------------------- */