Compounds | |
class | gust::PoolChunkList |
Enumerations | |
enum | Storage { dumb, place, heap, pool } |
Functions | |
void | release (void *buf, unsigned int t, unsigned int s) |
void * | reserve_global (size_t s, size_t *ret_s) |
void * | reserve_pool (size_t s, size_t *ret_s) |
GULAPI void | PoolGrow (PoolChunkList *pool) |
GULAPI void | PoolFreeAll (void) |
void * | PoolAlloc (const size_t insize, size_t *outsize) |
void | PoolFree (void *ptr, const size_t size) |
void * | PreferPoolAlloc (const size_t insize, size_t *outsize) |
void | PreferPoolFree (void *ptr, const size_t size) |
Variables | |
GULAPI PoolChunkList | Pools [6] |
const size_t | PoolTabSize = 2049 |
GULAPI PoolChunkList * | PoolTab [2049] |
|
Definition at line 42 of file gust_new.h.
|
|
|
|
Definition at line 101 of file gust_pool.cpp.
00102 { 00103 void *ch, *next_ch; 00104 int nPools = sizeof(Pools)/sizeof(PoolChunkList), i; 00105 PoolChunkList *pool; 00106 00107 for( i = 0; i < nPools; i++ ) 00108 { 00109 pool = &Pools[i]; 00110 00111 ch = pool->chunks; 00112 while( ch ) 00113 { 00114 next_ch = *((void **)ch); 00115 free( ch ); 00116 ch = next_ch; 00117 } 00118 pool->head = 0; 00119 pool->chunks = 0; 00120 } 00121 } |
|
Definition at line 74 of file gust_pool.cpp.
00075 { 00076 size_t nelems,elemsize; 00077 char *chunk,*start,*end,*p; 00078 00079 nelems = pool->growrate; 00080 pool->growrate = nelems * 3/2; 00081 elemsize = pool->elemsize; 00082 00083 /* important: sizeof(char) has to be ONE !!!!!!!!!!! */ 00084 00085 chunk = (char *)malloc( POOL_ALIGNMENT + nelems * elemsize ); 00086 if( chunk == NULL ) return; 00087 00088 start = chunk + POOL_ALIGNMENT; 00089 end = start + (nelems-1)*elemsize; 00090 00091 for( p = start; p < end; p += elemsize ) 00092 *((void **)p) = p + elemsize; 00093 00094 *((void **)end) = NULL; 00095 00096 pool->head = start; 00097 *((void **)chunk) = pool->chunks; 00098 pool->chunks = chunk; 00099 } |
|
Definition at line 175 of file gust_pool.h. Referenced by gul::pool_bytealloc::allocate(), and gul::pool_object::operator new().
00176 { 00177 PoolChunkList *pool; 00178 void *head; 00179 00180 if( !insize ) 00181 { 00182 *outsize = 0; 00183 return 0; 00184 } 00185 00186 if( insize >= PoolTabSize ) 00187 { 00188 *outsize = insize; 00189 00190 void *p = malloc(insize); 00191 #ifdef POOLDBG 00192 new pooldbg( p, insize, *outsize ); 00193 #endif 00194 return p; 00195 } 00196 00197 pool = PoolTab[insize]; 00198 00199 head = pool->head; 00200 00201 if( head == NULL ) 00202 { 00203 PoolGrow( pool ); 00204 head = pool->head; 00205 } 00206 00207 pool->head = *((void **)head); 00208 *outsize = pool->elemsize; 00209 #ifdef POOLDBG 00210 new pooldbg( (void *)head, insize, *outsize ); 00211 #endif 00212 return((void *)head); 00213 } |
|
Definition at line 215 of file gust_pool.h. Referenced by gul::pool_bytealloc::deallocate(), gul::poolalloc::deallocate(), and gul::pool_object::operator delete().
00216 { 00217 if( !ptr || !size ) return; 00218 00219 if( size >= PoolTabSize ) 00220 { 00221 free(ptr); 00222 #ifdef POOLDBG 00223 pooldbg::remove( ptr ); 00224 #endif 00225 return; 00226 } 00227 00228 PoolChunkList *pool = PoolTab[size]; 00229 00230 *((void **)ptr) = pool->head; 00231 pool->head = ptr; 00232 #ifdef POOLDBG 00233 pooldbg::remove( ptr ); 00234 #endif 00235 } |
|
Definition at line 50 of file gust_new.h.
00051 { 00052 if( (t <= place) || (buf == NULL) ) return; 00053 if( t == heap ) { free(buf); return; } 00054 PreferPoolFree( buf, s ); 00055 } |
|
Definition at line 57 of file gust_new.h. Referenced by gul::Ptr< EP >::reserve_global().
00058 { 00059 void *p = malloc( s ); 00060 if( p == NULL ) throw gul::AllocError(); 00061 *ret_s = s; 00062 return(p); 00063 } |
|
Definition at line 65 of file gust_new.h. Referenced by gul::Ptr< EP >::reserve_pool().
00066 { 00067 void *p = PreferPoolAlloc( s, ret_s); 00068 if( p == NULL ) throw gul::AllocError(); 00069 return(p); 00070 } |
|
Initial value: { { 0, 0, 4, 256 }, { 0, 0, 8, 128 }, { 0, 0, 16, 64 }, { 0, 0, 64, 32 }, { 0, 0, 256, 16 }, { 0, 0, 2048, 4 } } Definition at line 60 of file gust_pool.cpp. Referenced by gul_halt(). |
|
Definition at line 25 of file gust_pooltbl.h. |
|
Definition at line 39 of file gust_pool.h. |