fixed_mem_pool< _Tp > Class Template Reference

#include <fixed_mem_pool.h>

---

Detailed Description

template<class _Tp>
class fixed_mem_pool< _Tp >

Class template to manipulate a fixed-size memory pool. Please notice that only allocate and deallocate are protected by a lock.

Parameters:

_Tp

class to use the fixed_mem_pool

Definition at line 76 of file fixed_mem_pool.h.

Public Types
typedef class_level_lock < fixed_mem_pool< _Tp > >::lock	lock
Static Public Member Functions
static void *	allocate ()
static void	deallocate (void *)
static int	deinitialize ()
static int	get_alloc_count ()
static bool	initialize (size_t __size)
static bool	is_initialized ()
Static Protected Member Functions
static bool	bad_alloc_handler ()
Static Private Member Functions
static size_t	_S_align (size_t __size)
Static Private Attributes
static int	_S_alloc_cnt = 0
static void *	_S_first_avail_ptr = NULL
static void *	_S_mem_pool_ptr = NULL

---

Member Typedef Documentation

template<class _Tp>

typedef class_level_lock<fixed_mem_pool<_Tp> >::lock fixed_mem_pool< _Tp >::lock

Definition at line 79 of file fixed_mem_pool.h.

---

Member Function Documentation

template<class _Tp>

size_t fixed_mem_pool< _Tp >::_S_align

(

size_t

__size

)

[inline, static, private]

Aligns the memory block size.

Parameters:

__size

size to be aligned

Returns:

aligned value of __size

Definition at line 236 of file fixed_mem_pool.h.

References MEM_POOL_ALIGNMENT.

Referenced by fixed_mem_pool< _Tp >::initialize().

{
    return (__size + MEM_POOL_ALIGNMENT - 1)
           / MEM_POOL_ALIGNMENT * MEM_POOL_ALIGNMENT;
}

template<class _Tp>

void * fixed_mem_pool< _Tp >::allocate

(

)

[inline, static]

Allocates a memory block from the memory pool.

Returns:

pointer to the allocated memory block

Definition at line 113 of file fixed_mem_pool.h.

References fixed_mem_pool< _Tp >::_S_alloc_cnt, fixed_mem_pool< _Tp >::_S_first_avail_ptr, and fixed_mem_pool< _Tp >::bad_alloc_handler().

{
    lock __guard;
    for (;;)
    {
        if (void* __result = _S_first_avail_ptr)
        {
            _S_first_avail_ptr = *(void**)_S_first_avail_ptr;
            ++_S_alloc_cnt;
            return __result;
        }
        else
            if (!bad_alloc_handler())
                return NULL;
    }
}

template<class _Tp>

bool fixed_mem_pool< _Tp >::bad_alloc_handler

(

)

[inline, static, protected]

Bad allocation handler. Called when there are no memory blocks available in the memory pool. If this function returns false (default behaviour if not explicitly specialized), it indicates that it can do nothing and allocate() should return NULL; if this function returns true, it indicates that it has freed some memory blocks and allocate() should try allocating again.

Definition at line 224 of file fixed_mem_pool.h.

Referenced by fixed_mem_pool< _Tp >::allocate().

{
    return false;
}

template<class _Tp>

void fixed_mem_pool< _Tp >::deallocate

(

void *

__block_ptr

)

[inline, static]

Deallocates a memory block and returns it to the memory pool.

Parameters:

__block_ptr

pointer to the memory block to return

Definition at line 136 of file fixed_mem_pool.h.

References fixed_mem_pool< _Tp >::_S_alloc_cnt, and fixed_mem_pool< _Tp >::_S_first_avail_ptr.

{
    if (__block_ptr == NULL)
        return;
    lock __guard;
    assert(_S_alloc_cnt != 0);
    --_S_alloc_cnt;
    *(void**)__block_ptr = _S_first_avail_ptr;
    _S_first_avail_ptr = __block_ptr;
}

template<class _Tp>

int fixed_mem_pool< _Tp >::deinitialize

(

)

[inline, static]

Deinitializes the memory pool.

Returns:

0 if all memory blocks are returned and the memory pool successfully freed; or a non-zero value indicating number of memory blocks still in allocation

Definition at line 182 of file fixed_mem_pool.h.

References fixed_mem_pool< _Tp >::_S_alloc_cnt, fixed_mem_pool< _Tp >::_S_first_avail_ptr, fixed_mem_pool< _Tp >::_S_mem_pool_ptr, mem_pool_base::dealloc_sys(), and fixed_mem_pool< _Tp >::is_initialized().

{
    if (_S_alloc_cnt != 0)
        return _S_alloc_cnt;
    assert(is_initialized());
    mem_pool_base::dealloc_sys(_S_mem_pool_ptr);
    _S_mem_pool_ptr = NULL;
    _S_first_avail_ptr = NULL;
    return 0;
}

template<class _Tp>

int fixed_mem_pool< _Tp >::get_alloc_count

(

)

[inline, static]

Gets the allocation count.

Returns:

the number of memory blocks still in allocation

Definition at line 199 of file fixed_mem_pool.h.

References fixed_mem_pool< _Tp >::_S_alloc_cnt.

{
    return _S_alloc_cnt;
}

template<class _Tp>

bool fixed_mem_pool< _Tp >::initialize

(

size_t

__size

)

[inline, static]

Initializes the memory pool.

Parameters:

__size

number of memory blocks to put in the memory pool

Returns:

true if successful; false if memory insufficient

Definition at line 154 of file fixed_mem_pool.h.

References fixed_mem_pool< _Tp >::_S_align(), fixed_mem_pool< _Tp >::_S_first_avail_ptr, fixed_mem_pool< _Tp >::_S_mem_pool_ptr, mem_pool_base::alloc_sys(), and fixed_mem_pool< _Tp >::is_initialized().

{
    size_t __block_size = _S_align(sizeof(_Tp));
    assert(!is_initialized());
    assert(__size > 0 && __block_size >= sizeof(void*));
    _S_mem_pool_ptr = mem_pool_base::alloc_sys(__size * __block_size);
    _S_first_avail_ptr = _S_mem_pool_ptr;
    if (_S_mem_pool_ptr == NULL)
        return false;
    char* __block = (char*)_S_mem_pool_ptr;
    while (--__size != 0)
    {
        char* __next = __block + __block_size;
        *(void**)__block = __next;
        __block = __next;
    }
    *(void**)__block = NULL;
    return true;
}

template<class _Tp>

bool fixed_mem_pool< _Tp >::is_initialized

(

)

[inline, static]

Is the memory pool initialized?

Returns:

true if it is successfully initialized; false otherwise

Definition at line 210 of file fixed_mem_pool.h.

References fixed_mem_pool< _Tp >::_S_mem_pool_ptr.

Referenced by fixed_mem_pool< _Tp >::deinitialize(), and fixed_mem_pool< _Tp >::initialize().

{
    return _S_mem_pool_ptr != NULL;;
}

---

Field Documentation

template<class _Tp>

int fixed_mem_pool< _Tp >::_S_alloc_cnt = 0 [inline, static, private]

Count of allocations.

Definition at line 92 of file fixed_mem_pool.h.

Referenced by fixed_mem_pool< _Tp >::allocate(), fixed_mem_pool< _Tp >::deallocate(), fixed_mem_pool< _Tp >::deinitialize(), and fixed_mem_pool< _Tp >::get_alloc_count().

template<class _Tp>

void * fixed_mem_pool< _Tp >::_S_first_avail_ptr = NULL [inline, static, private]

Pointer to the first available memory block.

Definition at line 91 of file fixed_mem_pool.h.

Referenced by fixed_mem_pool< _Tp >::allocate(), fixed_mem_pool< _Tp >::deallocate(), fixed_mem_pool< _Tp >::deinitialize(), and fixed_mem_pool< _Tp >::initialize().

template<class _Tp>

void * fixed_mem_pool< _Tp >::_S_mem_pool_ptr = NULL [inline, static, private]

Pointer to the allocated chunk of memory.

Definition at line 90 of file fixed_mem_pool.h.

Referenced by fixed_mem_pool< _Tp >::deinitialize(), fixed_mem_pool< _Tp >::initialize(), and fixed_mem_pool< _Tp >::is_initialized().

---

The documentation for this class was generated from the following file:

• fixed_mem_pool.h