pool.h

Go to the documentation of this file.

/* $Id$ */
/* 
 * 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__ */