klish/lub/partition/partition_realloc.c

/*
 * partition_realloc.c
 */
#include <string.h>

#include "private.h"

/*--------------------------------------------------------- */
void
lub_partition_stop_here(lub_heap_status_t status,
                        char             *old_ptr,
                        size_t            new_size)
{
    /* This is provided as a debug aid */
    status   = status;
    old_ptr  = old_ptr;
    new_size = new_size;
}
/*--------------------------------------------------------- */
void
lub_partition_time_to_die(lub_partition_t *this)
{
    bool_t           time_to_die = BOOL_TRUE;
    lub_heap_stats_t stats;
    lub_heap_t      *local_heap = lub_partition__get_local_heap(this);
    if(local_heap)
    {
        lub_heap__get_stats(local_heap,&stats);
        if(stats.alloc_blocks)
        {
            time_to_die = BOOL_FALSE;
        }
    }
    if(BOOL_FALSE == time_to_die)
    {
        lub_partition_lock(this);
        lub_heap__get_stats(this->m_global_heap,&stats);
        lub_partition_unlock(this);
        if(stats.alloc_blocks)
        {
            time_to_die = BOOL_FALSE;
        }
    }
    if(BOOL_TRUE == time_to_die)
    {
        /* and so the time has come... */
        lub_partition_destroy(this);
    }
}
/*--------------------------------------------------------- */
lub_heap_status_t
lub_partition_global_realloc(lub_partition_t *this,
                             char           **ptr,
                             size_t           size,
                             lub_heap_align_t alignment)
{
    lub_heap_status_t status = LUB_HEAP_FAILED;
    lub_partition_lock(this);
    if(!this->m_global_heap)
    {
        /*
         * Create the global heap
         */
        size_t required     = size;
        void  *segment      = lub_partition_segment_alloc(this,&required);
        this->m_global_heap = lub_heap_create(segment,required);
    }
    if(this->m_global_heap)
    {
        status = lub_heap_realloc(this->m_global_heap,ptr,size,alignment);
        if(LUB_HEAP_FAILED == status)
        {
            /* expand memory and try again */
            if(lub_partition_extend_memory(this,size))
            {
                status = lub_heap_realloc(this->m_global_heap,
                                          ptr,size,alignment);
            }
        }
    }
    lub_partition_unlock(this);
    return status;
}
/*--------------------------------------------------------- */
lub_heap_status_t
lub_partition_realloc(lub_partition_t *this,
                      char           **ptr,
                      size_t           size,
                      lub_heap_align_t alignment)
{
    lub_heap_status_t status         = LUB_HEAP_FAILED;
    size_t            requested_size = size;
    lub_heap_t       *local_heap;
    
    if((0 == size) && (0 == *ptr))
    {
        /* simple optimisation */
        return LUB_HEAP_OK;
    }
    if(this->m_dying)
    {
        local_heap = lub_partition__get_local_heap(this);
        if(size)
        {
            /* don't allocate any new memory when dying */
            size = 0;
        }
    }
    else
    {
        local_heap = lub_partition_findcreate_local_heap(this);
    }
    if(local_heap)
    {
        /* try the fast local heap first */
        status = lub_heap_realloc(local_heap,ptr,size,alignment);
    }
    if((LUB_HEAP_FAILED == status) || (LUB_HEAP_INVALID_POINTER == status))
    {
        char *old_ptr = 0;
        
        if(local_heap && (LUB_HEAP_FAILED == status) && size)
        {
            /* we need to reallocate from the global and copy from the local */
            old_ptr = *ptr;
            *ptr    = 0;
        }
        /* time to use the slower global heap */
        status = lub_partition_global_realloc(this,ptr,size,alignment);
        if(old_ptr && (LUB_HEAP_OK == status))
        {
            /* copy from the local to the global */
            memcpy(*ptr,old_ptr,size);

            /* and release the local block */
            status = lub_heap_realloc(local_heap,&old_ptr,0,alignment);
        }
    }
    if(LUB_HEAP_OK != status)
    {
        lub_partition_stop_here(status,*ptr,size);
    }
    /* allow the partion to destroy itself if necessary */
    if(this->m_dying)
    {
        lub_partition_time_to_die(this);
        if(requested_size)
        {
            /* we don't allocate memory whilst dying */
            status = LUB_HEAP_FAILED;
        }
    }
    return status;
}
/*-------------------------------------------------------- */