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

# dkcMemoryPool.h

`#include "dkcOSIndependent.h"`

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

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

ソースコードを見る。

## 構成
struct | dkc_SameObjectPoolNode
struct | dkc_SameObjectPool
## マクロ定義
#define | dkcSameObjectPoolFree(p) dkcFree((void **)&(p))
| dkcSameObjectPoolAlloc()で確保したメモリ領域を即行free()してしまう。
## 型定義
typedef dkc_SameObjectPoolNode | DKC_SAME_OBJECT_POOL_NODE
typedef dkc_SameObjectPool | DKC_SAME_OBJECT_POOL
## 関数
DKC_EXTERN 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_EXTERN DKC_SAME_OBJECT_POOL *WINAPI | dkcAllocSameObjectPoolAuto (size_t object_size)
DKC_EXTERN int WINAPI | dkcFreeSameObjectPool (DKC_SAME_OBJECT_POOL **p)
| dkcAllocSameObjectPool()で確保した領域を開放
DKC_EXTERN void * | dkcSameObjectPoolAlloc (DKC_SAME_OBJECT_POOL *p)
DKC_EXTERN void WINAPI | dkcSameObjectPoolRecycle (DKC_SAME_OBJECT_POOL *p, void *pv)
| dkcSameObjectPoolAlloc()で確保したメモリ領域を再利用する為に返す関数(使用は奨励しません）
DKC_EXTERN int WINAPI | dkcSameObjectPoolReserve (DKC_SAME_OBJECT_POOL *p)

## マクロ定義

#define dkcSameObjectPoolFree | ( | p |  | ) | dkcFree((void **)&(p))

| dkcSameObjectPoolAlloc()で確保したメモリ領域を即行free()してしまう。 dkcMemoryPool.h の 83 行で定義されています。

## 型定義

typedef struct dkc_SameObjectPool DKC_SAME_OBJECT_POOL

typedef struct dkc_SameObjectPoolNode DKC_SAME_OBJECT_POOL_NODE

## 関数

DKC_EXTERN 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
| ) |

  | 引数:
  | object_size[in] | オブジェクトのサイズ（例：struct hogeのプールを確保したければ sizeof(struct hoge)を入れる）
  | max_num[in] | プールの最大数　間違ってもUINT_MAXとかはしないように
  | alloc_f[in] | malloc関数を入れる。NULLだと内部でデフォルトのメモリアローケート関数セット使用される
  | free_f[in] | free関数を入れる。NULLの場合の動作はalloc_fと同
dkcMemoryPool.c の 74 行で定義されています。 参照先 alloc_sameobjectpool(), dkcSameObjectPoolInit(), dkcSameObjectPoolReserve(), FALSE, free_sameobjectpool(), と NULL. 参照元 dkcAlloc2TreeRoot(), dkcAllocRedBlackTreeRoot(), と 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_EXTERN DKC_SAME_OBJECT_POOL* WINAPI dkcAllocSameObjectPoolAuto | ( | size_t | object_size | ) |

  | 引数:
  | object_size[in] | プールしておく一個単位のメモリのサイズ とりあえず、dkcAllocSameObjectPool()の引数説明を読むのが面倒ならこれを呼んでおくべし。

DKC_EXTERN int WINAPI dkcFreeSameObjectPool | ( | DKC_SAME_OBJECT_POOL ** | p | ) |

| dkcAllocSameObjectPool()で確保した領域を開放 dkcMemoryPool.c の 101 行で定義されています。 参照先 dkcSameObjectPoolUninit(), free_sameobjectpool(), と NULL. 参照元 dkcAlloc2TreeRoot(), dkcFreeRedBlackTreeRoot(), と 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_EXTERN 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(), dkcRedBlackTree_insertNode(), と 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_EXTERN 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(), dkcRedBlackTree_deleteNode(), と 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_EXTERN int 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 }