#include "dkcOSIndependent.h"dkcMemoryPool.hのインクルード依存関係図

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

構成 | |
| struct | dkc_SameObjectPoolNode |
| struct | dkc_SameObjectPool |
マクロ定義 | |
| #define | dkcSameObjectPoolFree(p) dkcFree((void **)&(p)) |
| dkcSameObjectPoolAlloc()で確保したメモリ領域を即行free()してしまう。 | |
型定義 | |
| typedef dkc_SameObjectPoolNode | DKC_SAME_OBJECT_POOL_NODE |
| typedef dkc_SameObjectPool | DKC_SAME_OBJECT_POOL |
関数 | |
| DKC_EXTERN DKC_SAME_OBJECT_POOL *WINAPI | dkcAllocSameObjectPool (size_t object_size, size_t max_num, DKC_ALLOC_FUNC_TYPE alloc_f, DKC_FREE_FUNC_TYPE free_f) |
| DKC_EXTERN DKC_SAME_OBJECT_POOL *WINAPI | dkcAllocSameObjectPoolAuto (size_t object_size) |
| DKC_EXTERN int WINAPI | dkcFreeSameObjectPool (DKC_SAME_OBJECT_POOL **p) |
| dkcAllocSameObjectPool()で確保した領域を開放 | |
| DKC_EXTERN void * | dkcSameObjectPoolAlloc (DKC_SAME_OBJECT_POOL *p) |
| dkcAllocSameObjectPool()のobject_sizeで指定したサイズのメモリ領域 | |
| DKC_EXTERN void WINAPI | dkcSameObjectPoolRecycle (DKC_SAME_OBJECT_POOL *p, void *pv) |
| dkcSameObjectPoolAlloc()で確保したメモリ領域を再利用する為に返す関数(使用は奨励しません) | |
| DKC_EXTERN int WINAPI | dkcSameObjectPoolReserve (DKC_SAME_OBJECT_POOL *p) |
|
|
dkcSameObjectPoolAlloc()で確保したメモリ領域を即行free()してしまう。
dkcMemoryPool.h の 78 行で定義されています。 |
|
|
|
参照元 dkcSameObjectPoolAlloc(), dkcSameObjectPoolRecycle(), dkcSameObjectPoolReserve(), dkcSameObjectPoolReserveFast(), と dkcSameObjectPoolUninit(). |
|
||||||||||||||||||||
|
dkcMemoryPool.c の 74 行で定義されています。 参照先 alloc_sameobjectpool(), DKC_ALLOC_FUNC_TYPE, DKC_FREE_FUNC_TYPE, DKC_SAME_OBJECT_POOL, dkcSameObjectPoolInit(), dkcSameObjectPoolReserve(), FALSE, free_sameobjectpool(), と NULL. 参照元 dkcAlloc2TreeRoot(), と dkcAllocSameObjectPoolDynamic().
00076 {
00077 DKC_SAME_OBJECT_POOL *p = alloc_sameobjectpool();
00078 if(NULL==p) return NULL;
00079
00080 if(DKUTIL_FAILED(dkcSameObjectPoolInit(p,object_size,max_num,alloc_f,free_f)))
00081 {
00082 goto Error;
00083 }
00084 if(FALSE==dkcSameObjectPoolReserve(p)){
00085 goto Error;
00086 }
00087 return p;
00088 Error:
00089 free_sameobjectpool(p);
00090 return NULL;
00091 }
|
|
|
|
|
|
dkcAllocSameObjectPool()で確保した領域を開放
dkcMemoryPool.c の 101 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, dkcSameObjectPoolUninit(), free_sameobjectpool(), と NULL. 参照元 dkcAlloc2TreeRoot(), と free_2tree_root().
00101 {
00102 DKC_SAME_OBJECT_POOL *p = (*pp);
00103 if(NULL==pp || NULL==p){
00104 return edk_FAILED;
00105 }
00106 //ノードを開放
00107 dkcSameObjectPoolUninit(p);
00108
00109
00110 //最終領域を開放
00111 return free_sameobjectpool(p);
00112 }
|
|
|
dkcAllocSameObjectPool()のobject_sizeで指定したサイズのメモリ領域
dkcMemoryPool.c の 162 行で定義されています。 参照先 dkc_SameObjectPool::alloc_f, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcMallocAdapter(), dkcmNOT_ASSERT, dkcSameObjectPoolReserve(), dkcSameObjectPoolReserveFast(), FALSE, dkc_SameObjectPoolNode::next, dkc_SameObjectPool::now_num, NULL, と dkc_SameObjectPool::root. 参照元 alloc_2tree_node().
00162 {
00163 DKC_SAME_OBJECT_POOL_NODE *n = p->root;
00164 int tr;
00165
00166 if(0==p->now_num){
00167 dkcmNOT_ASSERT(p->root != NULL);
00168 if(p->alloc_f == dkcMallocAdapter){
00169 tr = dkcSameObjectPoolReserveFast(p);
00170 }else{
00171 tr = dkcSameObjectPoolReserve(p);
00172 }
00173 if(FALSE==tr){
00174 return NULL;
00175 }
00176 return dkcSameObjectPoolAlloc(p);
00177 }
00178
00179
00180 p->root = n->next;
00181
00182 //マイナス
00183 p->now_num--;
00184
00185 return n;
00186 }
|
|
||||||||||||
|
dkcSameObjectPoolAlloc()で確保したメモリ領域を再利用する為に返す関数(使用は奨励しません)
dkcMemoryPool.c の 203 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkc_SameObjectPool::now_num, と dkc_SameObjectPool::root. 参照元 alloc_2tree_node(), と free_2tree_node().
00203 {
00204 /*
00205 DKC_SAME_OBJECT_POOL_NODE* head = pv;
00206 head->next = p->root;
00207 p->root = head;
00208 p->now_num ++;
00209 */
00210 *((DKC_SAME_OBJECT_POOL_NODE **)pv) = (DKC_SAME_OBJECT_POOL_NODE *)p->root;
00211 p->root = (DKC_SAME_OBJECT_POOL_NODE *)pv;
00212 p->now_num++;
00213
00214 }
|
|
|
dkcMemoryPool.c の 217 行で定義されています。 参照先 dkc_SameObjectPool::alloc_f, BOOL, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcmNOT_ASSERT, FALSE, dkc_SameObjectPool::max_num, dkc_SameObjectPoolNode::next, dkc_SameObjectPool::now_num, NULL, dkc_SameObjectPool::obj_size, dkc_SameObjectPool::root, dkc_SameObjectPool::tail, と TRUE. 参照元 dkcAllocSameObjectPool(), と dkcSameObjectPoolAlloc().
00217 {
00218 size_t max = p->max_num,now = p->now_num ;
00219 size_t size = (p->obj_size > sizeof(DKC_SAME_OBJECT_POOL_NODE *))
00220 ? p->obj_size : sizeof(DKC_SAME_OBJECT_POOL_NODE *);
00221 DKC_SAME_OBJECT_POOL_NODE* runner;
00222 size_t i;
00223
00224 if(max <= now){
00225 return FALSE;
00226 }
00227
00228 if(!p->root){
00229 //runner = dkcAllocateFast(size);
00230 runner = p->alloc_f(size);
00231 runner->next = NULL;
00232 p->root = runner;
00233 dkcmNOT_ASSERT(0!=now);
00234 now++;
00235 for (i = now;i<max ; i++) {
00236 //runner->next = dkcAllocateFast(size);
00237 runner->next = p->alloc_f(size);
00238 runner = runner->next;
00239 now++;
00240 }
00241
00242 }else{
00243
00244 dkcmNOT_ASSERT(max < now);
00245 runner = p->tail;
00246 max -= now;
00247 for(i = 0;i<max;i++){
00248 //runner->next = dkcAllocateFast(size);
00249 runner->next = p->alloc_f(size);
00250 runner = runner->next;
00251 now++;
00252 }
00253
00254 }
00255 runner->next = NULL;
00256 p->tail = runner;
00257 p->now_num = now;
00258 return TRUE;
00259 }
|
1.3.6