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

# dkcMemoryPool.c

`#include "dkcMemoryPool.h"`

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

ソースコードを見る。

## 関数
static DKC_INLINE DKC_SAME_OBJECT_POOL * | alloc_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_POOL * | alloc_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.c の 7 行で定義されています。 参照先 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.c の 17 行で定義されています。
    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.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 }

DKC_INLINE DKC_SAME_OBJECT_POOL* WINAPI dkcAllocSameObjectPoolDynamic | ( | size_t | object_size | ) |

| dkcMemoryPool.c の 94 行で定義されています。 参照先 dkcAllocSameObjectPool(), と NULL.
    00094                                                                                          {
    00095     return dkcAllocSameObjectPool(object_size,256,NULL,NULL);
    00096 }

int WINAPI dkcFreeSameObjectPool | ( | DKC_SAME_OBJECT_POOL ** | pp | ) |

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

DKC_INLINE void* dkcSameObjectPoolAlloc | ( | DKC_SAME_OBJECT_POOL * | p | ) |

| 戻り値: dkcAllocSameObjectPool()のobject_sizeで指定したサイズのメモリ領域 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 }

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.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. 参照元 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.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 }

DKC_INLINE BOOL WINAPI dkcSameObjectPoolReserve | ( | DKC_SAME_OBJECT_POOL * | p | ) |

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

DKC_INLINE BOOL WINAPI dkcSameObjectPoolReserveFast | ( | DKC_SAME_OBJECT_POOL * | p | ) |

| 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. 参照元 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.c の 63 行で定義されています。 参照先 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.c の 13 行で定義されています。 参照先 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.c の 23 行で定義されています。
    00023                                                                                 {
    00024     if(!p){
    00025         return edk_FAILED;
    00026     }
    00027     func(p);
    00028     return edk_SUCCEEDED;
    00029 }