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

|
|
DKC_SAME_OBJECT_POOLの本体を確保します。.
dkcMemoryPool.c の 7 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, と dkcAllocate().
00007 {
00008 return dkcAllocate(sizeof(DKC_SAME_OBJECT_POOL));
00009
00010 }
|
|
|
dkcMemoryPool.c の 17 行で定義されています。 参照先 DKC_ALLOC_FUNC_TYPE, と DKC_SAME_OBJECT_POOL.
00017 {
00018 /*if(NULL==func){
00019 return alloc_sameobjectpool();
00020 }*/
00021 return func(sizeof(DKC_SAME_OBJECT_POOL));
00022 }
|
|
||||||||||||||||||||
|
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 }
|
|
|
dkcMemoryPool.c の 94 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, dkcAllocSameObjectPool(), と NULL.
00094 {
00095 return dkcAllocSameObjectPool(object_size,256,NULL,NULL);
00096 }
|
|
|
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 }
|
|
||||||||||||||||||||||||
|
dkcMemoryPool.c の 33 行で定義されています。 参照先 dkc_SameObjectPool::alloc_f, BOOL, DKC_ALLOC_FUNC_TYPE, DKC_FREE_FUNC_TYPE, DKC_SAME_OBJECT_POOL, dkcFreeAdapter(), dkcMallocAdapter(), dkc_SameObjectPool::free_f, dkc_SameObjectPool::max_num, dkc_SameObjectPool::now_num, NULL, と dkc_SameObjectPool::obj_size.
00036 {
00037 BOOL af,ff;
00038 if(NULL==p){
00039 return edk_FAILED;
00040 }
00041 af = (NULL==alloc_f);
00042 ff = (NULL==free_f);
00043 if(af && ff){//二つともNULLだったらでふぉるとアロケータを入れる。
00044 alloc_f = dkcMallocAdapter;
00045 free_f = dkcFreeAdapter;
00046 goto PROC;
00047 }
00048 if(NULL==alloc_f || NULL==free_f){
00049 return edk_ArgumentException;
00050 }
00051 PROC:
00052
00053 p->alloc_f = alloc_f;
00054 p->free_f = free_f;
00055
00056 p->max_num = max_num;
00057 p->now_num = 0;
00058 p->obj_size = object_size;
00059 return edk_SUCCEEDED;
00060 }
|
|
||||||||||||
|
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 }
|
|
|
dkcMemoryPool.c の 115 行で定義されています。 参照先 BOOL, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcAllocateFast(), 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.
00116 {
00117 size_t max = p->max_num,now = p->now_num ;
00118 size_t size = (p->obj_size > sizeof(DKC_SAME_OBJECT_POOL_NODE *))
00119 ? p->obj_size : sizeof(DKC_SAME_OBJECT_POOL_NODE *);
00120 DKC_SAME_OBJECT_POOL_NODE* runner;
00121 size_t i;
00122
00123 if(max <= now){
00124 return FALSE;
00125 }
00126
00127 if(!p->root){
00128 runner = dkcAllocateFast(size);
00129 //runner = p->alloc_f(size);
00130 runner->next = NULL;
00131 p->root = runner;
00132 dkcmNOT_ASSERT(0!=now);
00133 now++;
00134 for (i = now;i<max ; i++) {
00135 runner->next = dkcAllocateFast(size);
00136 //runner->next = p->alloc_f(size);
00137 runner = runner->next;
00138 now++;
00139 }
00140
00141 }else{
00142
00143 dkcmNOT_ASSERT(max < now);
00144 runner = p->tail;
00145 max -= now;
00146 for(i = 0;i<max;i++){
00147 runner->next = dkcAllocateFast(size);
00148 //runner->next = p->alloc_f(size);
00149 runner = runner->next;
00150 now++;
00151 }
00152
00153 }
00154 runner->next = NULL;
00155 p->tail = runner;
00156 p->now_num = now;
00157 return TRUE;
00158 }
|
|
|
dkcFreeSameObjectPool()内で呼ばれている DKC_SAME_OBJECT_POOL 構造体の使用後の後始末関数
dkcMemoryPool.c の 63 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkc_SameObjectPool::free_f, dkc_SameObjectPoolNode::next, NULL, と dkc_SameObjectPool::root.
|
|
|
DKC_SAME_OBJECT_POOL本体を開放します。.
dkcMemoryPool.c の 13 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, と dkcFree(). 参照元 dkcAllocSameObjectPool(), と dkcFreeSameObjectPool().
00013 {
00014 return dkcFree(&p);
00015 }
|
|
||||||||||||
|
dkcMemoryPool.c の 23 行で定義されています。 参照先 DKC_FREE_FUNC_TYPE.
00023 {
00024 if(!p){
00025 return edk_FAILED;
00026 }
00027 func(p);
00028 return edk_SUCCEEDED;
00029 }
|
1.3.6