pool.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
 
#include <pj/list.h>
 
/* See if we use pool's alternate API.
 * The alternate API is used e.g. to implement pool debugging.
 */
#if PJ_HAS_POOL_ALT_API
#  include <pj/pool_alt.h>
#endif
 
 
#ifndef __PJ_POOL_H__
#define __PJ_POOL_H__
 
PJ_BEGIN_DECL
 
typedef void pj_pool_callback(pj_pool_t *pool, pj_size_t size);
 
typedef struct pj_pool_block
{
    PJ_DECL_LIST_MEMBER(struct pj_pool_block);  
    unsigned char    *buf;                      
    unsigned char    *cur;                      
    unsigned char    *end;                      
} pj_pool_block;
 
 
struct pj_pool_t
{
    PJ_DECL_LIST_MEMBER(struct pj_pool_t);  
    char            obj_name[PJ_MAX_OBJ_NAME];
 
    pj_pool_factory *factory;
 
    void            *factory_data;
 
    pj_size_t       capacity;
 
    pj_size_t       increment_size;
 
    pj_pool_block   block_list;
 
    pj_pool_callback *callback;
 
};
 
 
#define PJ_POOL_SIZE            (sizeof(struct pj_pool_t))
 
#ifndef PJ_POOL_ALIGNMENT
#   define PJ_POOL_ALIGNMENT    4
#endif
 
PJ_IDECL(pj_pool_t*) pj_pool_create(pj_pool_factory *factory, 
                                    const char *name,
                                    pj_size_t initial_size, 
                                    pj_size_t increment_size,
                                    pj_pool_callback *callback);
 
PJ_IDECL(void) pj_pool_release( pj_pool_t *pool );
 
 
PJ_IDECL(void) pj_pool_safe_release( pj_pool_t **ppool );
 
 
PJ_IDECL(void) pj_pool_secure_release( pj_pool_t **ppool );
 
 
PJ_IDECL(const char *) pj_pool_getobjname( const pj_pool_t *pool );
 
PJ_DECL(void) pj_pool_reset( pj_pool_t *pool );
 
 
PJ_IDECL(pj_size_t) pj_pool_get_capacity( pj_pool_t *pool );
 
PJ_IDECL(pj_size_t) pj_pool_get_used_size( pj_pool_t *pool );
 
PJ_IDECL(void*) pj_pool_alloc( pj_pool_t *pool, pj_size_t size);
 
PJ_IDECL(void*) pj_pool_calloc( pj_pool_t *pool, pj_size_t count, 
                                pj_size_t elem);
 
 
PJ_INLINE(void*) pj_pool_zalloc(pj_pool_t *pool, pj_size_t size)
{
    return pj_pool_calloc(pool, 1, size);
}
 
 
#define PJ_POOL_ALLOC_T(pool,type) \
            ((type*)pj_pool_alloc(pool, sizeof(type)))
 
#define PJ_POOL_ZALLOC_T(pool,type) \
            ((type*)pj_pool_zalloc(pool, sizeof(type)))
 
/*
 * Internal functions
 */
PJ_IDECL(void*) pj_pool_alloc_from_block(pj_pool_block *block, pj_size_t size);
PJ_DECL(void*) pj_pool_allocate_find(pj_pool_t *pool, pj_size_t size);
 
 
        
/* **************************************************************************/
/* We unfortunately don't have support for factory policy options as now,
   so we keep this commented at the moment.
enum PJ_POOL_FACTORY_OPTION
{
    PJ_POOL_FACTORY_SERIALIZE = 1
};
*/
 
typedef struct pj_pool_factory_policy
{
    void* (*block_alloc)(pj_pool_factory *factory, pj_size_t size);
 
    void (*block_free)(pj_pool_factory *factory, void *mem, pj_size_t size);
 
    pj_pool_callback *callback;
 
    unsigned flags;
 
} pj_pool_factory_policy;
 
PJ_DECL_DATA(int) PJ_NO_MEMORY_EXCEPTION;
 
PJ_DECL(int) pj_NO_MEMORY_EXCEPTION(void);
 
PJ_DECL_DATA(pj_pool_factory_policy) pj_pool_factory_default_policy;
 
 
PJ_DECL(const pj_pool_factory_policy*) pj_pool_factory_get_default_policy(void);
 
 
struct pj_pool_factory
{
    pj_pool_factory_policy policy;
 
    pj_pool_t*  (*create_pool)( pj_pool_factory *factory,
                                const char *name,
                                pj_size_t initial_size, 
                                pj_size_t increment_size,
                                pj_pool_callback *callback);
 
    void (*release_pool)( pj_pool_factory *factory, pj_pool_t *pool );
 
    void (*dump_status)( pj_pool_factory *factory, pj_bool_t detail );
 
    pj_bool_t (*on_block_alloc)(pj_pool_factory *factory, pj_size_t size);
 
    void (*on_block_free)(pj_pool_factory *factory, pj_size_t size);
 
};
 
PJ_DECL(pj_pool_t*) pj_pool_create_int( pj_pool_factory *factory, 
                                        const char *name,
                                        pj_size_t initial_size, 
                                        pj_size_t increment_size,
                                        pj_pool_callback *callback);
 
PJ_DECL(void) pj_pool_init_int( pj_pool_t *pool, 
                                const char *name,
                                pj_size_t increment_size,
                                pj_pool_callback *callback);
 
PJ_DECL(void) pj_pool_destroy_int( pj_pool_t *pool );
 
 
PJ_INLINE(void) pj_pool_factory_dump( pj_pool_factory *pf,
                                      pj_bool_t detail )
{
    (*pf->dump_status)(pf, detail);
}
 
/* **************************************************************************/
 
#define PJ_CACHING_POOL_ARRAY_SIZE      16
 
struct pj_caching_pool 
{
    pj_pool_factory factory;
 
    pj_size_t       capacity;
 
    pj_size_t       max_capacity;
 
    pj_size_t       used_count;
 
    pj_size_t       used_size;
 
    pj_size_t       peak_used_size;
 
    pj_list         free_list[PJ_CACHING_POOL_ARRAY_SIZE];
 
    pj_list         used_list;
 
    char            pool_buf[256 * (sizeof(size_t) / 4)];
 
    pj_lock_t      *lock;
};
 
 
 
PJ_DECL(void) pj_caching_pool_init( pj_caching_pool *ch_pool, 
                                    const pj_pool_factory_policy *policy,
                                    pj_size_t max_capacity);
 
 
PJ_DECL(void) pj_caching_pool_destroy( pj_caching_pool *ch_pool );
 
#  if PJ_FUNCTIONS_ARE_INLINED
#    include "pool_i.h"
#  endif
 
PJ_END_DECL
    
#endif  /* __PJ_POOL_H__ */