#include "dkcMemoryPool.h"
dkcMemoryPool.cのインクルード依存関係図
|
DKC_SAME_OBJECT_POOLの本体を確保します。
dkcMemoryPool.c の 7 行で定義されています。 参照先 dkcAllocate(). 00007 { 00008 return dkcAllocate(sizeof(DKC_SAME_OBJECT_POOL)); 00009 00010 }
|
|
dkcMemoryPool.c の 17 行で定義されています。 00017 { 00018 /*if(NULL==func){ 00019 return alloc_sameobjectpool(); 00020 }*/ 00021 return func(sizeof(DKC_SAME_OBJECT_POOL)); 00022 }
|
|
dkcMemoryPool.c の 74 行で定義されています。 参照先 alloc_sameobjectpool(), 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 行で定義されています。 参照先 dkcAllocSameObjectPool(), と NULL. 00094 { 00095 return dkcAllocSameObjectPool(object_size,256,NULL,NULL); 00096 }
|
|
dkcAllocSameObjectPool()で確保した領域を開放
dkcMemoryPool.c の 101 行で定義されています。 参照先 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 }
|
|
dkcMemoryPool.c の 162 行で定義されています。 参照先 dkc_SameObjectPool::alloc_f, dkcMallocAdapter(), dkcmNOT_ASSERT, dkcSameObjectPoolAlloc(), dkcSameObjectPoolReserve(), dkcSameObjectPoolReserveFast(), FALSE, dkc_SameObjectPoolNode::next, dkc_SameObjectPool::now_num, NULL, と dkc_SameObjectPool::root. 参照元 alloc_2tree_node(), と dkcSameObjectPoolAlloc(). 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, 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_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, 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 行で定義されています。 参照先 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_SameObjectPool::free_f, dkc_SameObjectPoolNode::next, NULL, と dkc_SameObjectPool::root. 00064 { 00065 DKC_SAME_OBJECT_POOL_NODE *t; 00066 for(;p->root != NULL;){ 00067 t = p->root->next; 00068 p->free_f(p->root); 00069 p->root = t; 00070 } 00071 }
|
|
DKC_SAME_OBJECT_POOL本体を開放します。
dkcMemoryPool.c の 13 行で定義されています。 参照先 dkcFree(). 参照元 dkcAllocSameObjectPool(), と dkcFreeSameObjectPool(). 00013 { 00014 return dkcFree(&p); 00015 }
|
|
dkcMemoryPool.c の 23 行で定義されています。 00023 { 00024 if(!p){ 00025 return edk_FAILED; 00026 } 00027 func(p); 00028 return edk_SUCCEEDED; 00029 }
|