#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 } |