Annotation of libaitio/inc/ampool.h, revision 1.2.2.1

1.2       misho       1: /*************************************************************************
                      2: * (C) 2012 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
                      3: *  by Michael Pounov <misho@elwix.org>
                      4: *
                      5: * $Author: misho $
1.2.2.1 ! misho       6: * $Id: ampool.h,v 1.2 2012/07/03 08:51:05 misho Exp $
1.2       misho       7: *
                      8: **************************************************************************
                      9: The ELWIX and AITNET software is distributed under the following
                     10: terms:
                     11: 
                     12: All of the documentation and software included in the ELWIX and AITNET
                     13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
                     14: 
1.2.2.1 ! misho      15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
1.2       misho      16:        by Michael Pounov <misho@elwix.org>.  All rights reserved.
                     17: 
                     18: Redistribution and use in source and binary forms, with or without
                     19: modification, are permitted provided that the following conditions
                     20: are met:
                     21: 1. Redistributions of source code must retain the above copyright
                     22:    notice, this list of conditions and the following disclaimer.
                     23: 2. Redistributions in binary form must reproduce the above copyright
                     24:    notice, this list of conditions and the following disclaimer in the
                     25:    documentation and/or other materials provided with the distribution.
                     26: 3. All advertising materials mentioning features or use of this software
                     27:    must display the following acknowledgement:
                     28: This product includes software developed by Michael Pounov <misho@elwix.org>
                     29: ELWIX - Embedded LightWeight unIX and its contributors.
                     30: 4. Neither the name of AITNET nor the names of its contributors
                     31:    may be used to endorse or promote products derived from this software
                     32:    without specific prior written permission.
                     33: 
                     34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
                     35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     37: ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     44: SUCH DAMAGE.
                     45: */
                     46: #ifndef __AMPOOL_H
                     47: #define __AMPOOL_H
                     48: 
                     49: 
1.2.2.1 ! misho      50: #include <pthread.h>
        !            51: 
        !            52: 
1.2       misho      53: /* Memory pool */
                     54: 
                     55: #define MEM_BUCKETS    28      /* 32 bits - 4 bits = 28 items in bucket array */
                     56: 
                     57: struct tagAlloc {
                     58:        char                    alloc_name[64];
                     59: 
                     60:        unsigned int            *alloc_mem;
                     61: 
                     62:        TAILQ_ENTRY(tagAlloc)   alloc_node;
                     63: };
                     64: typedef TAILQ_HEAD(, tagAlloc) mpool_bucket_t;
                     65: 
                     66: typedef struct _tagMPool {
                     67:        pthread_mutex_t pool_mtx;
                     68: 
                     69:        struct {
                     70:                unsigned long alloc;
                     71:                unsigned long free;
                     72:                unsigned long cache;
                     73:        } pool_calls;
                     74:        struct {
                     75:                unsigned long alloc;
                     76:                unsigned long free;
                     77:                unsigned long cache;
                     78:        } pool_bytes;
                     79:        struct {
                     80:                unsigned long max;
                     81:                unsigned long curr;
                     82:        } pool_quota;
                     83: 
                     84:        /* pool buckets */
                     85:        mpool_bucket_t  pool_active[MEM_BUCKETS];
                     86:        mpool_bucket_t  pool_inactive[MEM_BUCKETS];
                     87: } mpool_t;
                     88: #define mpool_lock(x)  (assert((x)), pthread_mutex_lock(&(x)->pool_mtx))
                     89: #define mpool_unlock(x)        (assert((x)), pthread_mutex_unlock(&(x)->pool_mtx))
                     90: 
                     91: typedef void (*mpool_stat_cb)(unsigned int, unsigned int, unsigned int);
                     92: 
                     93: /* mpool functions */
                     94: 
                     95: /*
                     96:  * mpool_init() - Init memory pool
                     97:  *
                     98:  * @maxmem = If !=0 set maximum memory quota
                     99:  * return: =NULL error or !=NULL new allocated pool
                    100:  */
                    101: mpool_t *mpool_init(unsigned long maxmem);
                    102: /*
                    103:  * mpool_destroy() - Destroy memory pool
                    104:  *
                    105:  * @mp = Memory pool
                    106:  * return: none
                    107:  */
                    108: void mpool_destroy(mpool_t ** __restrict mp);
                    109: /*
                    110:  * mpool_purge() - Purge memory block cache and release resources
                    111:  *
                    112:  * @mp = Memory pool
                    113:  * @atmost = Free at most in buckets
                    114:  * return: -1 error or 0 ok
                    115:  */
                    116: int mpool_purge(mpool_t * __restrict mp, unsigned int atmost);
                    117: /*
                    118:  * mpool_malloc() - Memory allocation
                    119:  *
                    120:  * @mp = Memory pool
                    121:  * @size = Size
                    122:  * @memname = Optional memory block name
                    123:  * return: NULL error or !=NULL ok allocated memory
                    124:  */
                    125: void *mpool_malloc(mpool_t * __restrict mp, unsigned int size, const char *memname);
                    126: /*
                    127:  * mpool_free() Free allocated memory with mpool_alloc()
                    128:  *
                    129:  * @mp = Memory pool
                    130:  * @data = Allocated memory data
                    131:  * @purge = if !=0 force release memory block
                    132:  * return: <0 error or 0 ok released memory block
                    133:  */
                    134: int mpool_free(mpool_t * __restrict mp, void * __restrict data, int purge);
                    135: /*
                    136:  * mpool_free2() Free allocated memory with mpool_alloc() by size and memory name
                    137:  *
                    138:  * @mp = Memory pool
                    139:  * @size = Allocated memory data size
                    140:  * @memname = Memory name
                    141:  * @purge = if !=0 force release memory block
                    142:  * return: <0 error or 0 ok released memory block
                    143:  */
                    144: int mpool_free2(mpool_t * __restrict mp, unsigned int size, const char *memname, int purge);
                    145: /*
                    146:  * mpool_realloc() Reallocate memory block with new size
                    147:  *
                    148:  * @mp = Memory pool
                    149:  * @data = Allocated memory data
                    150:  * @newsize = New size of memory block
                    151:  * @memname = Optional new memory block name
                    152:  * return: NULL error or !=NULL new reallocated memory block
                    153:  */
                    154: void *mpool_realloc(mpool_t * __restrict mp, void * __restrict data, 
                    155:                unsigned int newsize, const char *memname);
                    156: /*
                    157:  * mpool_strdup() - String duplicate
                    158:  *
                    159:  * @mp = Memory pool
                    160:  * @str = String
                    161:  * @memname = Memory name
                    162:  * return: NULL error or !=NULL new string
                    163:  */
                    164: char *mpool_strdup(mpool_t * __restrict mp, const char *str, const char *memname);
                    165: /*
                    166:  * mpool_getmembynam() Find allocated memory block by size and memory name
                    167:  *
                    168:  * @mp = Memory pool
                    169:  * @size = Memory size
                    170:  * @memname = Memory name
                    171:  * return: NULL error or not found and !=NULL allocated memory 
                    172:  */
                    173: inline struct tagAlloc *mpool_getmembynam(mpool_t * __restrict mp, unsigned int size, const char *memname);
                    174: /*
                    175:  * mpool_getsizebyaddr() - Get size of allocated memory block by address
                    176:  *
                    177:  * @data = allocated memory from mpool_malloc()
                    178:  * return: usable size of allocated memory block
                    179:  */
                    180: inline unsigned int mpool_getsizebyaddr(void * __restrict data);
                    181: /*
                    182:  * mpool_chkaddr() - Check validity of given address
                    183:  *
                    184:  * @data = allocated memory from mpool_malloc()
                    185:  * return: -1 bad address, 1 corrupted address or 0 ok
                    186:  */
                    187: inline int mpool_chkaddr(void * __restrict data);
                    188: /*
                    189:  * mpool_setquota() - Change maximum memory quota
                    190:  *
                    191:  * @mp = Memory pool
                    192:  * @maxmem = New max quota size
                    193:  * return: old maximum memory quota size
                    194:  */
                    195: inline unsigned long mpool_setquota(mpool_t * __restrict mp, unsigned long maxmem);
                    196: /*
                    197:  * mpool_getquota() - Get memory quota
                    198:  *
                    199:  * @mp = Memory pool
                    200:  * @currmem = Return current memory
                    201:  * @maxmem = Return max quota size
                    202:  * return: none
                    203:  */
                    204: inline void mpool_getquota(mpool_t * __restrict mp, unsigned long *currmem, 
                    205:                unsigned long *maxmem);
                    206: /*
                    207:  * mpool_statistics() - Dump statistics from memory pool buckets
                    208:  *
                    209:  * @mp = Memory pool
                    210:  * @cb = Export statistics to callback
                    211:  * return: none
                    212:  */
                    213: void mpool_statistics(mpool_t * __restrict mp, mpool_stat_cb cb);
                    214: 
                    215: 
                    216: /* Wrappers */
                    217: 
                    218: /*
                    219:  * mpool_xmalloc() - malloc wrapper
                    220:  *
                    221:  * @size = Size
                    222:  * return: NULL error or !=NULL ok allocated memory
                    223:  */
                    224: void *mpool_xmalloc(size_t size);
                    225: /*
                    226:  * mpool_xcalloc() - calloc wrapper
                    227:  *
                    228:  * @num = number of elements
                    229:  * @size = Size of element
                    230:  * return: NULL error or !=NULL ok allocated memory
                    231:  */
                    232: void *mpool_xcalloc(size_t num, size_t size);
                    233: /*
                    234:  * mpool_xrealloc() - realloc wrapper
                    235:  *
                    236:  * @data = Allocated memory data
                    237:  * @newsize = New size of memory block
                    238:  * return: NULL error or !=NULL new reallocated memory block
                    239:  */
                    240: void *mpool_xrealloc(void * __restrict data, size_t newsize);
                    241: /*
                    242:  * mpool_xfree() - free wrapper
                    243:  *
                    244:  * @data = Allocated memory data
                    245:  * return: none
                    246:  */
                    247: void mpool_xfree(void * __restrict data);
                    248: /*
                    249:  * mpool_xstrdup() - strdup wrapper
                    250:  *
                    251:  * @str = string
                    252:  * return: =NULL error or !=NULL new allocated string
                    253:  */
                    254: char *mpool_xstrdup(const char *str);
                    255: 
                    256: 
                    257: #endif

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>