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

|
||||||||||||
|
プール領域(数珠繋ぎのやつ)に新規プールを追加
dkcMemoryPool.c の 260 行で定義されています。 参照先 BOOL, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcmNOT_ASSERT, FALSE, dkc_SameObjectPoolNode::next, dkc_SameObjectPool::now_num, NULL, dkc_SameObjectPoolNode::pool, dkc_SameObjectPool::root, と TRUE. 参照元 dkcSameObjectPoolReserve().
00260 {
00261
00262 DKC_SAME_OBJECT_POOL_NODE *t;
00263 dkcmNOT_ASSERT(NULL==node->pool);
00264
00265 //後ろに繋げる場合は多分これでいいと思うのだが・・・
00266
00267 /*if(ptr->mNext)
00268 {//次へのポインタがあった場合
00269 t = ptr->mNext;//保存。
00270 ptr->mNext = nextp;//ぶち込む。
00271 nextp->mNext = t;//保存していたのをぶち込む
00272
00273 }else
00274 {//次へのポインタがなかった場合。
00275 ptr->mNext = nextp;//すぐぶち込む。
00276 }*/
00277 /*if(0==p->now_num){
00278 p->root = node;
00279 p->tail = node;
00280 node->next = NULL;
00281 }else{
00282 t = p->tail;
00283 dkcmNOT_ASSERT(p->tail->next != NULL);
00284 p->tail->next = node;
00285 node->next = NULL;
00286 t = node;
00287 }*/
00288
00289 //ここらへん状態遷移が激しい。
00290 t = p->root;
00291 p->root = node;
00292 node->next = t;
00293
00294
00295
00296 //数をインクリメント
00297 if(UINT_MAX==p->now_num){
00298 return FALSE;
00299 }
00300 p->now_num++;
00301 return TRUE;
00302 }
|
|
|
DKC_SAME_OBJECT_POOLの本体を確保します。.
dkcMemoryPool.c の 29 行で定義されています。 参照先 BYTE, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcAllocate(), dkcAllocateFill(), dkcFree(), FALSE, dkc_SameObjectPool::flag, NULL, と dkc_SameObjectPool::recycle_pool.
00029 {
00030 DKC_SAME_OBJECT_POOL *p = dkcAllocate(sizeof(DKC_SAME_OBJECT_POOL));
00031 if(NULL==p){
00032 return NULL;
00033 }
00034
00035 p->recycle_pool = (DKC_SAME_OBJECT_POOL_NODE **)
00036 dkcAllocate(sizeof(DKC_SAME_OBJECT_POOL_NODE *) * recycle_size);
00037
00038 if(NULL==p->recycle_pool){
00039 goto InitError;
00040 }
00041 //dkcmNOT_ASSERT(sizeof(p->flag) != sizeof(BYTE));
00042 p->flag = (BYTE *)dkcAllocateFill(sizeof(BYTE) * recycle_size,FALSE);
00043 if(NULL==p->flag){
00044 goto InitError;
00045 }
00046
00047 return p;
00048 InitError:
00049 dkcFree((void **)&(p->recycle_pool));
00050 dkcFree(&p);
00051 return NULL;
00052 }
|
|
|
DKC_SAME_OBJECT_POOL_NODEの本体を確保します.
dkcMemoryPool.c の 4 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL_NODE, dkcAllocateFast(), dkcFree(), dkc_SameObjectPoolNode::next, NULL, と dkc_SameObjectPoolNode::pool. 参照元 dkcAllocSameObjectPool(), と dkcSameObjectPoolReserve().
00004 {
00005 DKC_SAME_OBJECT_POOL_NODE *a;
00006 a = (DKC_SAME_OBJECT_POOL_NODE *)dkcAllocateFast(sizeof(DKC_SAME_OBJECT_POOL_NODE));
00007 if(NULL==a){
00008 return NULL;
00009 }
00010 a->pool = dkcAllocateFast(object_size);
00011 if(NULL==a->pool){
00012 goto Error;
00013 }
00014 a->next = NULL;
00015 return a;
00016 Error:
00017 dkcFree(&a);
00018 return NULL;
00019 }
|
|
||||||||||||||||
|
dkcMemoryPool.c の 61 行で定義されています。 参照先 alloc_sameobjectpool(), alloc_sop_node(), DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcFreeSameObjectPool(), dkc_SameObjectPool::max_num, dkc_SameObjectPoolNode::next, dkc_SameObjectPool::now_num, NULL, dkc_SameObjectPool::obj_size, dkc_SameObjectPool::recycle_size, と dkc_SameObjectPool::root. 参照元 dkcAllocSameObjectPoolDynamic().
00063 {
00064 DKC_SAME_OBJECT_POOL *p;
00065 DKC_SAME_OBJECT_POOL_NODE *t,*a;
00066 size_t i;
00067
00068 if(0==recycle_size){
00069 recycle_size = max_num / 4;
00070 if(0==recycle_size){
00071 recycle_size = 1;
00072 }
00073 }
00074 p = alloc_sameobjectpool(recycle_size);
00075
00076 if(NULL==p){
00077 return NULL;
00078 }
00079
00080 //set
00081 p->obj_size = object_size;
00082 p->root = NULL;
00083 //p->tail = NULL;
00084 p->max_num = max_num;
00085
00086 p->recycle_size = recycle_size;
00087
00088
00089 t = alloc_sop_node(object_size);
00090 if(NULL==t){
00091 goto Error;
00092 }
00093 //p->root = p->tail = t;
00094 p->root = t;
00095
00096 a = t;
00097 for(i = 0;i<max_num;i++){
00098 t = alloc_sop_node(object_size);
00099 if(NULL==t){
00100 goto Error;
00101 }
00102 //前確保したNodeの次はt;
00103 a->next = t;
00104
00105 a = t;
00106 }
00107 //update state
00108 //p->tail = a;
00109 p->now_num = max_num;
00110 return p;
00111 Error:
00112 dkcFreeSameObjectPool(&p);
00113 return NULL;
00114
00115 }
|
|
|
dkcMemoryPool.c の 118 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, と dkcAllocSameObjectPool().
00118 {
00119 return dkcAllocSameObjectPool(object_size,1024,256);
00120 }
|
|
|
dkcAllocSameObjectPool()で確保した領域を開放
dkcMemoryPool.c の 140 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, edk_FAILED, free_sameobjectpool(), free_sop_node(), free_sop_recycle(), dkc_SameObjectPoolNode::next, NULL, と dkc_SameObjectPool::root.
00140 {
00141 DKC_SAME_OBJECT_POOL *p = (*pp);
00142 DKC_SAME_OBJECT_POOL_NODE *n,*t;
00143 if(NULL==pp || NULL==p){
00144 return edk_FAILED;
00145 }
00146 //ノードを開放
00147 n = p->root;
00148
00149 while(NULL != n){
00150 t = n->next;
00151 free_sop_node(n);
00152 n = t;
00153 }
00154 //最後もお忘れなく・・・
00155 //free_sop_node( p->tail );
00156
00157 //リサイクル領域を開放
00158 free_sop_recycle(p);
00159
00160 //最終領域を開放
00161 return free_sameobjectpool(p);
00162 }
|
|
|
dkcAllocSameObjectPool()のobject_sizeで指定したサイズのメモリ領域
dkcMemoryPool.c の 211 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcmNOT_ASSERT, dkcSameObjectPoolReserve(), FALSE, free_sop_node(), insert_sop_recycle(), dkc_SameObjectPoolNode::next, dkc_SameObjectPool::now_num, NULL, dkc_SameObjectPoolNode::pool, と dkc_SameObjectPool::root.
00211 {
00212 DKC_SAME_OBJECT_POOL_NODE *n = p->root;
00213 void *r = n->pool;
00214 //dkcmNOT_ASSERT(0==p->now_num && n == p->tail);
00215 if(0==p->now_num){
00216 if(FALSE==dkcSameObjectPoolReserve(p)){
00217 return NULL;
00218 }
00219 return dkcSameObjectPoolAlloc(p);
00220 }
00221
00222 //rootの更新
00223 p->root = n->next;
00224
00225 //使用済みなのでNULL
00226 n->pool = NULL;
00227 n->next = NULL;
00228
00229 //未使用領域に入れる。
00230 if(FALSE==insert_sop_recycle(p,n)){
00231 //n->pool自体はNULLにしているのでpoolまで開放されない
00232 free_sop_node(n);
00233 }
00234 //マイナス
00235 p->now_num--;
00236
00237
00238 #if 0
00239 if(0==p->now_num /*&& p->root == NULL*/)
00240 {
00241 dkcmNOT_ASSERT(p->root != NULL);
00242 p->tail = NULL;
00243
00244 }
00245 #endif
00246
00247 return r;
00248 }
|
|
||||||||||||
|
dkcSameObjectPoolAlloc()で確保したメモリ領域を再利用する為に返す関数(使用は奨励しません)
dkcMemoryPool.c の 252 行で定義されています。 参照先 DKC_EXTERN, DKC_SAME_OBJECT_POOL, dkcSameObjectPoolFree, FALSE, と insert_sop_recycle_memory().
00252 {
00253 if(FALSE==insert_sop_recycle_memory(p,pv))
00254 {//失敗したら廃棄処分
00255 dkcSameObjectPoolFree(pv);
00256 }
00257 }
|
|
|
dkcMemoryPool.c の 304 行で定義されています。 参照先 add_sop_pool(), alloc_sop_node(), BOOL, BYTE, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcAllocateFast(), FALSE, dkc_SameObjectPool::flag, free_sop_node(), dkc_SameObjectPool::max_num, dkc_SameObjectPool::now_num, NULL, dkc_SameObjectPool::obj_size, dkc_SameObjectPoolNode::pool, dkc_SameObjectPool::recycle_pool, dkc_SameObjectPool::recycle_size, と TRUE.
00304 {
00305 size_t i,nel = p->recycle_size;
00306
00307 DKC_SAME_OBJECT_POOL_NODE *rp = *(p->recycle_pool);
00308 BYTE *flag = p->flag;
00309 BOOL r = FALSE;
00310
00311 for(i=0;i<nel;i++){
00312 if(TRUE==flag[i])
00313 {//リサイクル領域にリサイクルすべき領域を発見
00314 if(NULL==rp->pool)
00315 {//リサイクルすべき領域のプールには何も入っていなかった。
00316 //なので確保。
00317 rp->pool = dkcAllocateFast(p->obj_size);
00318 }
00319 if(FALSE==add_sop_pool(p,rp))
00320 {//もう入らないらしい。
00321
00322 //ここではfreeしなくてOK。
00323 return FALSE;
00324 }
00325
00326 //update
00327 r = TRUE;
00328 flag[i] = FALSE;
00329 }
00330 }
00331
00332 if(p->max_num > p->now_num)
00333 {//足りない・・・
00334 for(;;){
00335 //rpの再利用
00336 rp = alloc_sop_node(p->obj_size);
00337 if(NULL==rp)
00338 {//メモリが確保できない・・・アホPCめ!!!
00339 return FALSE;
00340 }
00341
00342 if(FALSE==add_sop_pool(p,rp))
00343 {//もう入らないらしい。(多分無いけど・・・)
00344
00345 //ここでこの関数を忘れてはいけない。
00346 free_sop_node(rp);
00347 return FALSE;
00348 }
00349
00350
00351 if(p->max_num <= p->now_num){
00352 break;
00353 }
00354 }//end of for
00355 r = TRUE;
00356
00357 }
00358 return r;
00359 }
|
|
|
dkcMemoryPool.c の 195 行で定義されています。 参照先 BOOL, BYTE, DKC_SAME_OBJECT_POOL, FALSE, dkc_SameObjectPool::flag, dkc_SameObjectPool::recycle_size, と TRUE.
|
|
|
DKC_SAME_OBJECT_POOL本体を開放します。.
dkcMemoryPool.c の 55 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL, dkcFree(), dkc_SameObjectPool::flag, と dkc_SameObjectPool::recycle_pool.
00055 {
00056 dkcFree(&(p->flag));
00057 dkcFree((void **)&(p->recycle_pool));
00058 return dkcFree(&p);
00059 }
|
|
|
DKC_SAME_OBJECT_POOL_NODEの本体を開放します。.
dkcMemoryPool.c の 22 行で定義されています。 参照先 DKC_SAME_OBJECT_POOL_NODE, dkcFree(), と dkc_SameObjectPoolNode::pool. 参照元 dkcFreeSameObjectPool(), dkcSameObjectPoolAlloc(), と dkcSameObjectPoolReserve().
|
|
|
dkcMemoryPool.c の 124 行で定義されています。 参照先 BYTE, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, dkcFree(), edk_SUCCEEDED, dkc_SameObjectPool::flag, dkc_SameObjectPool::recycle_pool, dkc_SameObjectPool::recycle_size, と TRUE.
00124 {
00125 DKC_SAME_OBJECT_POOL_NODE **np = p->recycle_pool;
00126 BYTE *flag = p->flag;
00127 size_t i;
00128 for(i = 0;i < p->recycle_size;i++)
00129 {
00130 if(TRUE==flag[i]){
00131 //内部でifチェック
00132 dkcFree(&(np[i]->pool));
00133 dkcFree(&(np[i]));
00134 }
00135 }
00136 return edk_SUCCEEDED;
00137 }
|
|
||||||||||||
|
リサイクル領域に使用済みノードを登録
dkcMemoryPool.c の 165 行で定義されています。 参照先 BOOL, BYTE, DKC_SAME_OBJECT_POOL, DKC_SAME_OBJECT_POOL_NODE, FALSE, dkc_SameObjectPool::flag, dkc_SameObjectPool::recycle_pool, dkc_SameObjectPool::recycle_size, と TRUE.
00165 {
00166 size_t i,nel = p->recycle_size;
00167 BYTE *flag = p->flag;
00168 for(i= 0;i<nel;i++){
00169 if(FALSE==flag[i]){
00170 p->recycle_pool[i] = node;
00171 flag[i] = TRUE;
00172 return TRUE;
00173 }
00174 }
00175 return FALSE;
00176 }
|
|
||||||||||||
|
リサイクル領域の使用済みノードの中のpoolメンバにメモリを格納
dkcMemoryPool.c の 179 行で定義されています。 参照先 BOOL, BYTE, DKC_SAME_OBJECT_POOL, FALSE, dkc_SameObjectPool::flag, dkc_SameObjectPoolNode::pool, dkc_SameObjectPool::recycle_pool, dkc_SameObjectPool::recycle_size, と TRUE. 参照元 dkcSameObjectPoolRecycle().
00179 {
00180 size_t i,nel = p->recycle_size;
00181 BYTE *flag = p->flag;
00182 for(i= 0;i<nel;i++){
00183 if(TRUE==flag[i]){
00184 if(p->recycle_pool[i]->pool){
00185 break;
00186 }
00187 p->recycle_pool[i]->pool = mem;
00188 return TRUE;
00189 }
00190 }
00191 return FALSE;
00192 }
|
1.3.6