proto/Source/pool.h

Go to the documentation of this file.

#ifndef _POOL_H
#define _POOL_H

#include <cassert>
#include <map>

namespace ace {


template<class _Type>
class MemoryBlock {
    const size_t _unit_size;
    _Type *_memory;
    _Type *_free;
    _Type *_upper_bound;

protected:
    // TODO: Block assignments between derived classes?
    MemoryBlock<_Type>(const MemoryBlock<_Type>& mpb);
    MemoryBlock<_Type>& operator=(const MemoryBlock<_Type>& mpb);

public: 
    MemoryBlock(size_t block_size): _unit_size(sizeof(_Type)), _memory(NULL), _free(NULL), _upper_bound(NULL) {
        _free = _memory = static_cast<_Type *>(operator new(block_size*_unit_size));
        _upper_bound = _memory + block_size;
    }
    virtual ~MemoryBlock(void) throw() {
        operator delete(_memory);
    }
    inline _Type * assigned_mem_bound(void) const throw() { return _free; }
    inline size_t count_free_memory(void) const throw() { return (_free != NULL) ? (_upper_bound - _free) : 0; }
    inline bool is_full(void) const throw() { return ( (_memory != NULL) && (_free == _upper_bound) ); }
    _Type * get_memory(size_t mem_size = 1) throw() {
        if ( (_memory == NULL) || (count_free_memory() < mem_size) ) {
            // Also catches when mem_size == 0.
            return NULL;
        }
        _Type *alloc = _free;
        // Advance internal free memory pointer by `mem_size`!
        _free += mem_size;
        return alloc;
    }
    inline _Type * lower_bound(void) const throw() { return _memory; }
    inline _Type * upper_bound(void) const throw() { return _upper_bound; }
    inline size_t unit_size(void) const throw() { return _unit_size; }
};


template<class _Type, template<typename _Type> class _Block>
class MemoryPool {
    size_t _block_size;

protected:

    virtual _Block<_Type> * create_new_block(void) = 0;

public:
    MemoryPool(size_t block_size) throw(): _block_size(block_size) {}
    virtual ~MemoryPool(void) throw() {}
    inline size_t block_size(void) const throw() { return _block_size; }
    virtual void clear(void) throw() = 0;
    virtual _Type * get_memory(size_t mem_size) = 0;
};


template<class _Type>
class RandomSizedMemoryPool: public MemoryPool<_Type, MemoryBlock> {
protected:
    typedef MemoryBlock<_Type> _block_type;

    // TODO: Remember the pool with maximum free memory (heap-like approach)?
    typedef typename std::multimap<size_t, _block_type *> _blocks_free_sizes_map;
    _block_type *_recently_used_block;
    _blocks_free_sizes_map _mem_blocks;

protected:
    virtual _block_type * create_new_block(void) {
        // Get new block with desired size and return.
        return new _block_type(this->block_size()); // This may throw!
    }

public:     
    RandomSizedMemoryPool(size_t block_size) throw(): MemoryPool<_Type, MemoryBlock>(block_size), _recently_used_block(NULL), _mem_blocks() {}
    virtual ~RandomSizedMemoryPool(void) throw() {
        this->clear();
    }
    virtual void clear(void) throw() {
        // Call delete on every memory block.
        for ( typename _blocks_free_sizes_map::iterator i_pool = _mem_blocks.begin(); i_pool != _mem_blocks.end(); ++i_pool ) {
            delete i_pool->second;
        }
        // Clear pools map.
        _mem_blocks.clear();
    }
    virtual _Type * get_memory(size_t mem_size) {
        
        if ( mem_size > this->block_size() ) {
            // No way to get so much memory...
            return NULL;
        }
        
        _block_type *mb = NULL;
        
        // So, which block to use (which has enough of memory?)
        if ( _recently_used_block == NULL ) {
            // First block to be created within the pool.
            mb = _recently_used_block = this->create_new_block(); // This may throw!
        } else if ( mem_size <= _recently_used_block->count_free_memory() ) {
            // There is enough memory in recently used block.
            mb = _recently_used_block;
        } else {
            // Recently used block has not enough free memory.
            if ( !_mem_blocks.empty() && (mem_size <= _mem_blocks.rbegin()->first) ) {          
                // There must be already allocated block with enough free memory.
                // Find the smallest one.
                typename _blocks_free_sizes_map::iterator i_pools = _mem_blocks.lower_bound(mem_size);
                // Following must be always true.
                assert(i_pools != _mem_blocks.end());
                // Get the block.
                mb = i_pools->second;
                // After memory retrieval this mapping will not be up-to-date anymore, so:
                _mem_blocks.erase(i_pools);
            } else {
                // No allocated block within pool has enough memory.
                // Get brand new block.
                mb = create_new_block(); // This may throw!
            }
            // Recently used memory block will be no longer "recently used",
            // so store it inside the memory blocks map.
            _mem_blocks.insert(typename _blocks_free_sizes_map::value_type(_recently_used_block->count_free_memory(), _recently_used_block));
            // Store for future use:
            _recently_used_block = mb;
        }
        // Return pointer to desired memory:
        return mb->get_memory(mem_size);
    }
};

class VoidPool: public RandomSizedMemoryPool<char> {
public:
    VoidPool(size_t block_size) throw(): RandomSizedMemoryPool<char>(block_size) {}
    virtual ~VoidPool(void) throw() {}

    virtual void * get_raw_memory(size_t mem_size) {
        return this->get_memory(mem_size);
    }

};

} // namespace ace

#endif

---