メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcMemoryPool.c

#include "dkcMemoryPool.h"

dkcMemoryPool.cのインクルード依存関係図

ソースコードを見る。

関数

static DKC_INLINE DKC_SAME_OBJECT_POOLalloc_sameobjectpool ()
 DKC_SAME_OBJECT_POOLの本体を確保します。
static DKC_INLINE int free_sameobjectpool (DKC_SAME_OBJECT_POOL *p)
 DKC_SAME_OBJECT_POOL本体を開放します。
static DKC_INLINE DKC_SAME_OBJECT_POOLalloc_sameobjectpool_outer (DKC_ALLOC_FUNC_TYPE func)
static DKC_INLINE int free_sameobjectpool_outer (void *p, DKC_FREE_FUNC_TYPE func)
DKC_INLINE int WINAPI dkcSameObjectPoolInit (DKC_SAME_OBJECT_POOL *p, size_t object_size, size_t max_num, DKC_ALLOC_FUNC_TYPE alloc_f, DKC_FREE_FUNC_TYPE free_f)
DKC_INLINE void WINAPI dkcSameObjectPoolUninit (DKC_SAME_OBJECT_POOL *p)
 dkcFreeSameObjectPool()内で呼ばれている DKC_SAME_OBJECT_POOL 構造体の使用後の後始末関数
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_INLINE DKC_SAME_OBJECT_POOL
*WINAPI 
dkcAllocSameObjectPoolDynamic (size_t object_size)
int WINAPI dkcFreeSameObjectPool (DKC_SAME_OBJECT_POOL **pp)
 dkcAllocSameObjectPool()で確保した領域を開放
DKC_INLINE BOOL WINAPI dkcSameObjectPoolReserveFast (DKC_SAME_OBJECT_POOL *p)
DKC_INLINE void * dkcSameObjectPoolAlloc (DKC_SAME_OBJECT_POOL *p)
DKC_INLINE void WINAPI dkcSameObjectPoolRecycle (DKC_SAME_OBJECT_POOL *p, void *pv)
 dkcSameObjectPoolAlloc()で確保したメモリ領域を再利用する為に返す関数(使用は奨励しません)
DKC_INLINE BOOL WINAPI dkcSameObjectPoolReserve (DKC_SAME_OBJECT_POOL *p)


関数

static DKC_INLINE DKC_SAME_OBJECT_POOL* alloc_sameobjectpool  )  [static]
 

DKC_SAME_OBJECT_POOLの本体を確保します。

dkcMemoryPool.c7 行で定義されています。

参照先 dkcAllocate().

参照元 dkcAllocSameObjectPool().

00007                                                               {
00008     return dkcAllocate(sizeof(DKC_SAME_OBJECT_POOL));
00009 
00010 }

static DKC_INLINE DKC_SAME_OBJECT_POOL* alloc_sameobjectpool_outer DKC_ALLOC_FUNC_TYPE  func  )  [static]
 

dkcMemoryPool.c17 行で定義されています。

00017                                                                                             {
00018     /*if(NULL==func){
00019         return alloc_sameobjectpool();
00020     }*/
00021     return func(sizeof(DKC_SAME_OBJECT_POOL));
00022 }

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
 

dkcMemoryPool.c74 行で定義されています。

参照先 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 }

DKC_INLINE DKC_SAME_OBJECT_POOL* WINAPI dkcAllocSameObjectPoolDynamic size_t  object_size  ) 
 

dkcMemoryPool.c94 行で定義されています。

参照先 dkcAllocSameObjectPool(), と NULL.

00094                                                                                          {
00095     return dkcAllocSameObjectPool(object_size,256,NULL,NULL);
00096 }

int WINAPI dkcFreeSameObjectPool DKC_SAME_OBJECT_POOL **  pp  ) 
 

dkcAllocSameObjectPool()で確保した領域を開放

dkcMemoryPool.c101 行で定義されています。

参照先 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 }

DKC_INLINE void* dkcSameObjectPoolAlloc DKC_SAME_OBJECT_POOL p  ) 
 

戻り値:
dkcAllocSameObjectPool()のobject_sizeで指定したサイズのメモリ領域

dkcMemoryPool.c162 行で定義されています。

参照先 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 }

DKC_INLINE int WINAPI dkcSameObjectPoolInit DKC_SAME_OBJECT_POOL p,
size_t  object_size,
size_t  max_num,
DKC_ALLOC_FUNC_TYPE  alloc_f,
DKC_FREE_FUNC_TYPE  free_f
 

dkcMemoryPool.c33 行で定義されています。

参照先 dkc_SameObjectPool::alloc_f, dkcFreeAdapter(), dkcMallocAdapter(), dkc_SameObjectPool::free_f, dkc_SameObjectPool::max_num, dkc_SameObjectPool::now_num, NULL, と dkc_SameObjectPool::obj_size.

参照元 dkcAllocSameObjectPool().

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 }                                                                           

DKC_INLINE void WINAPI dkcSameObjectPoolRecycle DKC_SAME_OBJECT_POOL p,
void *  pv
 

dkcSameObjectPoolAlloc()で確保したメモリ領域を再利用する為に返す関数(使用は奨励しません)

覚え書き:
この関数の仕様は奨励しません。 なぜならpvに入れるメモリアドレスを少しでも間違ったらエラーに直結するからです。 素直にdkcSameObjectPoolReserve()とdkcSameObjectPoolFree()で対応した方が無難です。

dkcMemoryPool.c203 行で定義されています。

参照先 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 }

DKC_INLINE BOOL WINAPI dkcSameObjectPoolReserve DKC_SAME_OBJECT_POOL p  ) 
 

dkcMemoryPool.c217 行で定義されています。

参照先 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 }

DKC_INLINE BOOL WINAPI dkcSameObjectPoolReserveFast DKC_SAME_OBJECT_POOL p  ) 
 

dkcMemoryPool.c115 行で定義されています。

参照先 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.

参照元 dkcSameObjectPoolAlloc().

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 }

DKC_INLINE void WINAPI dkcSameObjectPoolUninit DKC_SAME_OBJECT_POOL p  ) 
 

dkcFreeSameObjectPool()内で呼ばれている DKC_SAME_OBJECT_POOL 構造体の使用後の後始末関数

dkcMemoryPool.c63 行で定義されています。

参照先 dkc_SameObjectPool::free_f, dkc_SameObjectPoolNode::next, NULL, と dkc_SameObjectPool::root.

参照元 dkcFreeSameObjectPool().

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 }

static DKC_INLINE int free_sameobjectpool DKC_SAME_OBJECT_POOL p  )  [static]
 

DKC_SAME_OBJECT_POOL本体を開放します。

dkcMemoryPool.c13 行で定義されています。

参照先 dkcFree().

参照元 dkcAllocSameObjectPool(), と dkcFreeSameObjectPool().

00013                                                                   {
00014     return dkcFree(&p);
00015 }

static DKC_INLINE int free_sameobjectpool_outer void *  p,
DKC_FREE_FUNC_TYPE  func
[static]
 

dkcMemoryPool.c23 行で定義されています。

00023                                                                                 {
00024     if(!p){
00025         return edk_FAILED;
00026     }
00027     func(p);
00028     return edk_SUCCEEDED;
00029 }


dkutil_cに対してSat Sep 10 09:24:35 2005に生成されました。  doxygen 1.4.4