root/ext/mysqlnd/mysqlnd_block_alloc.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. mysqlnd_mempool_free_chunk
  2. mysqlnd_mempool_resize_chunk
  3. mysqlnd_mempool_get_chunk
  4. mysqlnd_mempool_create
  5. mysqlnd_mempool_destroy

/*
  +----------------------------------------------------------------------+
  | PHP Version 5                                                        |
  +----------------------------------------------------------------------+
  | Copyright (c) 2006-2015 The PHP Group                                |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.php.net/license/3_01.txt                                  |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Authors: Georg Richter <georg@mysql.com>                             |
  |          Andrey Hristov <andrey@mysql.com>                           |
  |          Ulf Wendel <uwendel@mysql.com>                              |
  +----------------------------------------------------------------------+
*/

/* $Id$ */

#include "php.h"
#include "mysqlnd.h"
#include "mysqlnd_block_alloc.h"
#include "mysqlnd_debug.h"
#include "mysqlnd_priv.h"


/* {{{ mysqlnd_mempool_free_chunk */
static void
mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk TSRMLS_DC)
{
        MYSQLND_MEMORY_POOL * pool = chunk->pool;
        DBG_ENTER("mysqlnd_mempool_free_chunk");
        if (chunk->from_pool) {
                /* Try to back-off and guess if this is the last block allocated */
                if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) {
                        /*
                                This was the last allocation. Lucky us, we can free
                                a bit of memory from the pool. Next time we will return from the same ptr.
                        */
                        pool->free_size += chunk->size;
                }
                pool->refcount--;
        } else {
                mnd_free(chunk->ptr);
        }
        mnd_free(chunk);
        DBG_VOID_RETURN;
}
/* }}} */


/* {{{ mysqlnd_mempool_resize_chunk */
static enum_func_status
mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC)
{
        DBG_ENTER("mysqlnd_mempool_resize_chunk");
        if (chunk->from_pool) {
                MYSQLND_MEMORY_POOL * pool = chunk->pool;
                /* Try to back-off and guess if this is the last block allocated */
                if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) {
                        /*
                                This was the last allocation. Lucky us, we can free
                                a bit of memory from the pool. Next time we will return from the same ptr.
                        */
                        if ((chunk->size + pool->free_size) < size) {
                                zend_uchar *new_ptr;
                                new_ptr = mnd_malloc(size);
                                if (!new_ptr) {
                                        DBG_RETURN(FAIL);
                                }
                                memcpy(new_ptr, chunk->ptr, chunk->size);
                                chunk->ptr = new_ptr;
                                pool->free_size += chunk->size;
                                chunk->size = size;
                                chunk->pool = NULL; /* now we have no pool memory */
                                pool->refcount--;
                        } else {
                                /* If the chunk is > than asked size then free_memory increases, otherwise decreases*/
                                pool->free_size += (chunk->size - size);
                        }
                } else {
                        /* Not last chunk, if the user asks for less, give it to him */
                        if (chunk->size >= size) {
                                ; /* nop */
                        } else {
                                zend_uchar *new_ptr;
                                new_ptr = mnd_malloc(size);
                                if (!new_ptr) {
                                        DBG_RETURN(FAIL);
                                }
                                memcpy(new_ptr, chunk->ptr, chunk->size);
                                chunk->ptr = new_ptr;
                                chunk->size = size;
                                chunk->pool = NULL; /* now we have non-pool memory */
                                pool->refcount--;
                        }
                }
        } else {
                zend_uchar *new_ptr = mnd_realloc(chunk->ptr, size);
                if (!new_ptr) {
                        DBG_RETURN(FAIL);
                }
                chunk->ptr = new_ptr;
        }
        DBG_RETURN(PASS);
}
/* }}} */


/* {{{ mysqlnd_mempool_get_chunk */
static
MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, unsigned int size TSRMLS_DC)
{
        MYSQLND_MEMORY_POOL_CHUNK *chunk = NULL;
        DBG_ENTER("mysqlnd_mempool_get_chunk");

        chunk = mnd_malloc(sizeof(MYSQLND_MEMORY_POOL_CHUNK));
        if (chunk) {
                chunk->free_chunk = mysqlnd_mempool_free_chunk;
                chunk->resize_chunk = mysqlnd_mempool_resize_chunk;
                chunk->size = size;
                /*
                  Should not go over MYSQLND_MAX_PACKET_SIZE, since we
                  expect non-arena memory in mysqlnd_wireprotocol.c . We
                  realloc the non-arena memory.
                */
                chunk->pool = pool;
                if (size > pool->free_size) {
                        chunk->from_pool = FALSE;
                        chunk->ptr = mnd_malloc(size);
                        if (!chunk->ptr) {
                                chunk->free_chunk(chunk TSRMLS_CC);
                                chunk = NULL;
                        }
                } else {
                        chunk->from_pool = TRUE;
                        ++pool->refcount;
                        chunk->ptr = pool->arena + (pool->arena_size - pool->free_size);
                        /* Last step, update free_size */
                        pool->free_size -= size;
                }
        }
        DBG_RETURN(chunk);
}
/* }}} */


/* {{{ mysqlnd_mempool_create */
PHPAPI MYSQLND_MEMORY_POOL *
mysqlnd_mempool_create(size_t arena_size TSRMLS_DC)
{
        /* We calloc, because we free(). We don't mnd_calloc()  for a reason. */
        MYSQLND_MEMORY_POOL * ret = mnd_calloc(1, sizeof(MYSQLND_MEMORY_POOL));
        DBG_ENTER("mysqlnd_mempool_create");
        if (ret) {
                ret->get_chunk = mysqlnd_mempool_get_chunk;
                ret->free_size = ret->arena_size = arena_size ? arena_size : 0;
                ret->refcount = 0;
                /* OOM ? */
                ret->arena = mnd_malloc(ret->arena_size);
                if (!ret->arena) {
                        mysqlnd_mempool_destroy(ret TSRMLS_CC);
                        ret = NULL;
                }
        }
        DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_mempool_destroy */
PHPAPI void
mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool TSRMLS_DC)
{
        DBG_ENTER("mysqlnd_mempool_destroy");
        /* mnd_free will reference LOCK_access and might crash, depending on the caller...*/
        mnd_free(pool->arena);
        mnd_free(pool);
        DBG_VOID_RETURN;
}
/* }}} */


/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim600: noet sw=4 ts=4 fdm=marker
 * vim<600: noet sw=4 ts=4
 */

/* [<][>][^][v][top][bottom][index][help] */