src/server/util/pool.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
 *
 * THE BSD LICENSE
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer. 
 * Redistributions in binary form must reproduce the above copyright notice, 
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution. 
 *
 * Neither the name of the  nor the names of its contributors may be
 * used to endorse or promote products derived from this software without 
 * specific prior written permission. 
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Generic pool handling routines.
 *
 * These routines reduce contention on the heap and guard against
 * memory leaks.
 *
 * Thread warning:
 *     This implementation is thread safe.  However, simultaneous 
 *     mallocs/frees to the same "pool" are not safe.  Do not share
 *     pools across multiple threads without providing your own
 *     synchronization.
 *
 * Mike Belshe
 * 11-20-95
 *
 */

//include "netsite.h"
//include "systems.h"
#include "systhr.h"
#include "pool_pvt.h"
//include "ereport.h"
//include "base/session.h"
//include "frame/req.h"
//include "frame/http.h"
#include "util.h"
//include "base/crit.h"

//include "base/dbtbase.h"


#include <stdlib.h>
#include <string.h>
#include <limits.h>
//define PERM_MALLOC   malloc
//define PERM_FREE     free
//define PERM_REALLOC  realloc
//define PERM_CALLOC   calloc
//define PERM_STRDUP   strdup

/* Pool configuration parameters */
static pool_config_t pool_config = POOL_CONFIG_INIT;

/* Pool global statistics */
static pool_global_stats_t pool_global_stats;

/* ucx allocator pool class */
static cx_allocator_class pool_allocator_class = {
    (void *(*)(void *,size_t )) pool_malloc,
    (void *(*)(void *,void *, size_t )) pool_realloc,
    (void *(*)(void *,size_t ,size_t  )) pool_calloc,
    (void (*)(void *, void *))pool_free
};

static int 
pool_internal_init()
{
    //if (pool_global_stats.lock == NULL) {
    //    pool_global_stats.lock = PR_NewLock(); // TODO: remove
    //}

    if (pool_config.block_size == 0) {
        //ereport(LOG_INFORM, XP_GetAdminStr(DBT_poolInitInternalAllocatorDisabled_));
    }

    return 0;
}

#define POOL_MIN_BLOCKSIZE 128

NSAPI_PUBLIC int
pool_init(pblock *pb, Session *sn, Request *rq)
{
    //char *str_block_size = pblock_findval("block-size", pb);
    //char *str_pool_disable = pblock_findval("disable", pb);
    char *str_block_size = "16384";
    char *str_pool_disable = "false";
    int n;

    //printf("standard block size: %d\n", pool_config.block_size);
    
    if (str_block_size != NULL) {
        int64_t value;
        if(!util_strtoint(str_block_size, &value)) {
            log_ereport(LOG_MISCONFIG, "pool-init: param 'block-size' is not an integer");
            return REQ_ABORTED;
        }
        if(value > INT_MAX) {
            log_ereport(LOG_MISCONFIG, "pool-init: block-size is too big");
            return REQ_ABORTED;
        }
        if(value < POOL_MIN_BLOCKSIZE) {
            log_ereport(LOG_MISCONFIG, "pool-init: block-size is too small");
            return REQ_ABORTED;
        }
        pool_config.block_size = value;
    }

    if (str_pool_disable && util_getboolean(str_pool_disable, PR_TRUE)) {
        /* We'll call PERM_MALLOC() on each pool_malloc() call */
        pool_config.block_size = 0;
        pool_config.retain_size = 0;
        pool_config.retain_num = 0;
    }

    pool_internal_init();

    return REQ_PROCEED;
}

CxAllocator* pool_allocator(pool_handle_t *pool) {
    return &((pool_t *)pool)->allocator;
}

static block_t *
_create_block(pool_t *pool, int size)
{
    block_t *newblock;
    char *newdata;
    block_t **blk_ptr;
    long blen;

    /* Does the pool have any retained blocks on its free list? */
    for (blk_ptr = &pool->free_blocks;
         (newblock = *blk_ptr) != NULL; blk_ptr = &newblock->next) {

        /* Yes, is this block large enough? */
        blen = newblock->end - newblock->data;
        if (blen >= size) {

            /* Yes, take it off the free list */
            *blk_ptr = newblock->next;
            pool->free_size -= blen;
            --pool->free_num;

            /* Give the block to the caller */
            newblock->start = newblock->data;
            goto done;
        }
    }

    newblock = (block_t *)PERM_MALLOC(sizeof(block_t));
    newdata = (char *)PERM_MALLOC(size);
    if (newblock == NULL || (newdata == NULL && size != 0)) {
        //ereport(LOG_CATASTROPHE,
        //        XP_GetAdminStr(DBT_poolCreateBlockOutOfMemory_));
        PERM_FREE(newblock);
        PERM_FREE(newdata);
        //PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
        return NULL;
    }
    newblock->data = newdata;
    newblock->start = newblock->data;
    newblock->end   = newblock->data + size;
    newblock->next  = NULL;
    blen = size;

#ifdef POOL_GLOBAL_STATISTICS
    PR_AtomicIncrement((PRInt32 *)&pool_global_stats.blkAlloc);
#endif /* POOL_GLOBAL_STATISTICS */

  done:

#ifdef PER_POOL_STATISTICS
    ++pool->stats.blkAlloc;
#endif /* PER_POOL_STATISTICS */

    return newblock;
}

static void 
_free_block(block_t *block)
{
#ifdef POOL_ZERO_DEBUG
    long blen = block->end - block->data;
    memset(block->data, POOL_ZERO_DEBUG, blen);
#endif /* POOL_ZERO_DEBUG */

    PERM_FREE(block->data);

#ifdef POOL_ZERO_DEBUG
    memset(block, POOL_ZERO_DEBUG, sizeof(block));
#endif /* POOL_ZERO_DEBUG */

    PERM_FREE(block);

#ifdef POOL_GLOBAL_STATISTICS
    PR_AtomicIncrement((PRInt32 *)&pool_global_stats.blkFree);
#endif /* POOL_GLOBAL_STATISTICS */
}

/* ptr_in_pool()
 * Checks to see if the given pointer is in the given pool.
 * If true, returns a ptr to the block_t containing the ptr;
 * otherwise returns NULL
 */
block_t * 
_ptr_in_pool(pool_t *pool, const void *ptr)
{
    block_t *block_ptr = NULL;

    /* try to find a block which contains this ptr */

    if (POOL_PTR_IN_BLOCK(pool->curr_block, ptr)) {
        block_ptr = pool->curr_block;
    }
    else {
        for (block_ptr = pool->used_blocks; block_ptr; block_ptr = block_ptr->next) {
            if (POOL_PTR_IN_BLOCK(block_ptr, ptr))
                break;
        }
    }
    return block_ptr;
}


NSAPI_PUBLIC pool_handle_t *
pool_create()
{
    pool_t *newpool;

    newpool = (pool_t *)PERM_MALLOC(sizeof(pool_t));

    if (newpool) {
        /* Have to initialize now, as pools get created sometimes
         * before pool_init can be called...
         */
        //if (pool_global_stats.lock == NULL) { // TODO: remove
        //    pool_internal_init();
        //}
        
        newpool->allocator.cl = &pool_allocator_class;
        newpool->allocator.data = newpool;
        
        newpool->used_blocks = NULL;
        newpool->free_blocks = NULL;
        newpool->free_size = 0;
        newpool->free_num = 0;
        newpool->size = 0;
        newpool->next = NULL;

#ifdef PER_POOL_STATISTICS
        /* Initial per pool statistics */
        memset((void *)(&newpool->stats), 0, sizeof(newpool->stats));
        newpool->stats.thread = PR_GetCurrentThread();
        newpool->stats.created = PR_Now();
#endif /* PER_POOL_STATISTICS */

        /* No need to lock, since pool has not been exposed yet */
        newpool->curr_block =_create_block(newpool, pool_config.block_size);
        if (newpool->curr_block == NULL) {
            //ereport(LOG_CATASTROPHE, XP_GetAdminStr(DBT_poolCreateOutOfMemory_));
            pool_destroy((pool_handle_t *)newpool);
            //PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
            return NULL;
        }

        /* Add to known pools list */
        
        // NOTICE:
        // known pools list removed
        
        //PR_Lock(pool_global_stats.lock);
        //newpool->next = pool_global_stats.poolList;
        //pool_global_stats.poolList = newpool;
        //++pool_global_stats.createCnt;
#ifdef PER_POOL_STATISTICS
        newpool->stats.poolId = pool_global_stats.createCnt;
#endif /* PER_POOL_STATISTICS */
        //PR_Unlock(pool_global_stats.lock);

    }
    else {
        //ereport(LOG_CATASTROPHE, XP_GetAdminStr(DBT_poolCreateOutOfMemory_1));
        //PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
    }

    return (pool_handle_t *)newpool;
}

/*
 * pool_mark - get mark for subsequent recycle
 *
 * This function returns a value that can be used to free all pool
 * memory which is subsequently allocated, without freeing memory
 * that has already been allocated when pool_mark() is called.
 * The pool_recycle() function is used to free the memory allocated
 * since pool_mark() was called.
 *
 * This function may be called several times before pool_recycle()
 * is called, but some care must be taken not to pass an invalid
 * mark value to pool_recycle(), which would cause all pool memory
 * to be freed.  A mark value becomes invalid when pool_recycle is
 * called with a previously returned mark value.
 */
NSAPI_PUBLIC void *
pool_mark(pool_handle_t *pool_handle)
{
    pool_t *pool = (pool_t *)pool_handle;

    //PR_ASSERT(pool != NULL);

    if (pool == NULL)
        return NULL;

#ifdef PER_POOL_STATISTICS
    pool->stats.thread = PR_GetCurrentThread();
#endif /* PER_POOL_STATISTICS */

    /* Never return end as it points outside the block */
    if (pool->curr_block->start == pool->curr_block->end)
        return pool->curr_block;

    return (void *)(pool->curr_block->start);
}

/*
 * pool_recycle - recycle memory in a pool
 *
 * This function returns all the allocated memory for a pool back to
 * a free list associated with the pool. It is like pool_destroy() in
 * the sense that all data structures previously allocated from the
 * pool are freed, but it keeps the memory associated with the pool,
 * and doesn't actually destroy the pool.
 *
 * The "mark" argument can be a value previously returned by
 * pool_mark(), in which case the pool is returned to the state it
 * was in when pool_mark() was called, or it can be NULL, in which
 * case the pool is completely recycled.
 */
NSAPI_PUBLIC void
pool_recycle(pool_handle_t *pool_handle, void *mark)
{
    pool_t *pool = (pool_t *)pool_handle;
    block_t *tmp_blk;
    unsigned long blen;

    //PR_ASSERT(pool != NULL);

    if (pool == NULL)
        return;

    /* Fix up curr_block.  There should always be a curr_block. */
    tmp_blk = pool->curr_block;
    //PR_ASSERT(tmp_blk != NULL);

    /* Start with curr_block, then scan blocks on used_blocks list */
    for (;;) {

        /* Check if the mark is at the end of this block */
        if (tmp_blk == mark) {
            pool->curr_block = tmp_blk;
            break;
        }

        /* Look for a block containing the mark */
        if (POOL_PTR_IN_BLOCK(tmp_blk, mark)) {

            /* Reset block start pointer to marked spot */
            if (tmp_blk == pool->curr_block) {
                blen = tmp_blk->start - (char *)mark;
            } else {
                blen = tmp_blk->end - (char *)mark;
            }
            pool->size -= blen;
            //PR_ASSERT(pool->size >= 0);
            tmp_blk->start = (char *)mark;
            pool->curr_block = tmp_blk;
            break;
        }

        /* Reset block start pointer to base of block */
        if (tmp_blk == pool->curr_block) {
            /* Count just the allocated length in the current block */
            blen = tmp_blk->start - tmp_blk->data;
        }
        else {
            /* Count the entire size of a used_block */
            blen = tmp_blk->end - tmp_blk->data;
        }
        tmp_blk->start = tmp_blk->data;
        pool->size -= blen;
        //PR_ASSERT(pool->size >= 0);

        /*
         * If there are no more used blocks after this one, then set
         * this block up as the current block and return.
         */
        if (pool->used_blocks == NULL) {
            //PR_ASSERT(mark == NULL);
            pool->curr_block = tmp_blk;
            break;
        }

        /* Otherwise free this block one way or another */

        /* Add block length to total retained length and check limit */
        if ((pool->free_size + blen) <= pool_config.retain_size &&
            pool->free_num < pool_config.retain_num) {

            /* Retain block on pool free list */
            /*
             * XXX hep - could sort blocks on free list in order
             * ascending size to get "best fit" allocation in
             * _create_block(), but the default block size is large
             * enough that fit should rarely be an issue.
             */
            tmp_blk->next = pool->free_blocks;
            pool->free_blocks = tmp_blk;
            pool->free_size += blen;
            ++pool->free_num;
        }
        else {
            /* Limit exceeded - free block */
            _free_block(tmp_blk);
        }

#ifdef PER_POOL_STATISTICS
        //++pool->stats.blkFree;
#endif /* PER_POOL_STATISTICS */

        /* Remove next block from used blocks list */
        tmp_blk = pool->used_blocks;
        pool->used_blocks = tmp_blk->next;
    }
}

NSAPI_PUBLIC void
pool_destroy(pool_handle_t *pool_handle)
{
    pool_t *pool = (pool_t *)pool_handle;
    block_t *tmp_blk;

    //PR_ASSERT(pool != NULL);

    if (pool == NULL)
        return;

    if (pool->curr_block)
        _free_block(pool->curr_block);

    while(pool->used_blocks) {
        tmp_blk = pool->used_blocks;
        pool->used_blocks = tmp_blk->next;
        _free_block(tmp_blk);
    }

    while(pool->free_blocks) {
        tmp_blk = pool->free_blocks;
        pool->free_blocks = tmp_blk->next;
        _free_block(tmp_blk);
    }

    {
        //pool_t **ppool;

        /* Remove from the known pools list */
        // NOTICE: known pools list removed
        /*
        PR_Lock(pool_global_stats.lock);
        for (ppool = &pool_global_stats.poolList;
             *ppool; ppool = &(*ppool)->next) {
            if (*ppool == pool) {
                ++pool_global_stats.destroyCnt;
                *ppool = pool->next;
                break;
            }
        }
        PR_Unlock(pool_global_stats.lock);
        */
    }

#ifdef POOL_ZERO_DEBUG
    memset(pool, POOL_ZERO_DEBUG, sizeof(pool));
#endif /* POOL_ZERO_DEBUG */

    PERM_FREE(pool);

    return;
}


NSAPI_PUBLIC void *
pool_malloc(pool_handle_t *pool_handle, size_t size)
{
    pool_t *pool = (pool_t *)pool_handle;
    block_t *curr_block;
    long reqsize, blocksize;
    char *ptr;

    if (pool == NULL)
        return PERM_MALLOC(size);

    reqsize = ALIGN(size);
    if (reqsize == 0) {
        /* Assign a unique address to each 0-byte allocation */
        reqsize = WORD_SIZE;
    }

    curr_block = pool->curr_block;
    ptr = curr_block->start;
    curr_block->start += reqsize;

    /* does this fit into the last allocated block? */
    if (curr_block->start > curr_block->end) {

        /* Did not fit; time to allocate a new block */

        curr_block->start -= reqsize;  /* keep structs in tact */

        /* Count unallocated bytes in current block in pool size */
        pool->size += curr_block->end - curr_block->start;
        //PR_ASSERT(pool->size >= 0);
#ifdef PER_POOL_STATISTICS
        if (pool->size > pool->stats.maxAlloc) {
            pool->stats.maxAlloc = pool->size;
        }
#endif /* PER_POOL_STATISTICS */

        /* Move current block to used block list */
        curr_block->next = pool->used_blocks;
        pool->used_blocks = curr_block;

        /* Allocate a chunk of memory which is at least block_size bytes */
        blocksize = reqsize;
        if (blocksize < pool_config.block_size)
            blocksize = pool_config.block_size;

        curr_block = _create_block(pool, blocksize);
        pool->curr_block = curr_block;

        if (curr_block == NULL) {
            //ereport(LOG_CATASTROPHE,
            //        XP_GetAdminStr(DBT_poolMallocOutOfMemory_));
            //PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
            return NULL;
        }

        ptr = curr_block->start;
        curr_block->start += reqsize;
    }

    pool->size += reqsize;
    //PR_ASSERT(pool->size >= 0);

#ifdef PER_POOL_STATISTICS
    if (pool->size > pool->stats.maxAlloc) {
        pool->stats.maxAlloc = pool->size;
    }
    ++pool->stats.allocCnt;
    pool->stats.thread = PR_GetCurrentThread();
#endif /* PER_POOL_STATISTICS */

    return ptr;
}

NSAPI_PUBLIC void
pool_free(pool_handle_t *pool_handle, void *ptr)
{
    pool_t *pool = (pool_t *)pool_handle;

    if (ptr == NULL)
        return;

    if (pool == NULL) {
        PERM_FREE(ptr);
        return;
    }

    //PR_ASSERT(_ptr_in_pool(pool, ptr));

#ifdef PER_POOL_STATISTICS

    ++pool->stats.freeCnt;
    pool->stats.thread = PR_GetCurrentThread();

#endif /* PER_POOL_STATISTICS */

    return;
}

NSAPI_PUBLIC void *
pool_calloc(pool_handle_t *pool_handle, size_t nelem, size_t elsize)
{
    void *ptr;

    if (pool_handle == NULL)
        return calloc(1, elsize * nelem);

    ptr = pool_malloc(pool_handle, elsize * nelem);
    if (ptr)
        memset(ptr, 0, elsize * nelem);
    return ptr;
}

NSAPI_PUBLIC void *
pool_realloc(pool_handle_t *pool_handle, void *ptr, size_t size)
{
    pool_t *pool = (pool_t *)pool_handle;
    void *newptr;
    block_t *block_ptr;
    size_t oldsize;

    if (pool == NULL)
        return PERM_REALLOC(ptr, size);

    if ( (newptr = pool_malloc(pool_handle, size)) == NULL) 
        return NULL;

    /* With our structure we don't know exactly where the end
     * of the original block is.  But we do know an upper bound
     * which is a valid ptr.  Search the outstanding blocks
     * for the block which contains this ptr, and copy...
     */

    if ( !(block_ptr = _ptr_in_pool(pool, ptr)) ) {
        /* User is trying to realloc nonmalloc'd space! */
        return newptr;
    }

    oldsize = block_ptr->end - (char *)ptr ;
    if (oldsize > size)
        oldsize = size;
    memmove((char *)newptr, (char *)ptr, oldsize);

    return newptr;
}

NSAPI_PUBLIC char *
pool_strdup(pool_handle_t *pool_handle, const char *orig_str)
{
    char *new_str;
    int len = strlen(orig_str);

    if (pool_handle == NULL)
        return PERM_STRDUP(orig_str);

    new_str = (char *)pool_malloc(pool_handle, len+1);

    if (new_str) 
        memcpy(new_str, orig_str, len+1);

    return new_str;
}

NSAPI_PUBLIC long
pool_space(pool_handle_t *pool_handle)
{
    pool_t *pool = (pool_t *)pool_handle;

    return pool->size;
}

NSAPI_PUBLIC int pool_enabled()
{
    if (getThreadMallocKey() == -1)
        return 0;

    if (!systhread_getdata(getThreadMallocKey()))
        return 0;

    return 1;
}

#ifdef DEBUG
NSAPI_PUBLIC void INTpool_assert(pool_handle_t *pool_handle, const void *ptr)
{
    pool_t *pool = (pool_t *)pool_handle;

    if (pool == NULL)
        return;

    //PR_ASSERT(_ptr_in_pool(pool, ptr));
}
#endif

NSAPI_PUBLIC pool_config_t *pool_getConfig(void)
{
    return &pool_config;
}

#ifdef POOL_GLOBAL_STATISTICS
NSAPI_PUBLIC pool_global_stats_t *pool_getGlobalStats(void)
{
    return &pool_global_stats;
}
#endif /* POOL_GLOBAL_STATISTICS */

#ifdef PER_POOL_STATISTICS
NSAPI_PUBLIC pool_stats_t *pool_getPoolStats(pool_handle_t *pool_handle)
{
    pool_t *pool = (pool_t *)pool_handle;

    if (pool == NULL)
        return NULL;

    return &pool->stats;
}
#endif /* PER_POOL_STATISTICS */

// new
cxmutstr cx_strdup_pool(pool_handle_t *pool, cxmutstr s) {
    cxmutstr newstring;
    newstring.ptr = (char*)pool_malloc(pool, s.length + 1);
    if (newstring.ptr != NULL) {
        newstring.length = s.length;
        newstring.ptr[newstring.length] = 0;

        memcpy(newstring.ptr, s.ptr, s.length);
    }

    return newstring;
}