UTPoolAllocator.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_POOL_ALLOCATOR_H_
#define _UT_POOL_ALLOCATOR_H_


//==================================================================================================
//=== System headers
//==================================================================================================
#include <stdlib.h>


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTLists.h"
#include "UTMutex.h"


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
class Pool_t;


//==================================================================================================
//=== Types and constants
//==================================================================================================
const int c_pool_num_block_sizes = 26;
struct PoolBlockSize_t
{
    size_t  max_block_size;
    int     allocate_per_pool;
};


//==================================================================================================
class UT_EXPORT PoolAllocator_t
//==================================================================================================
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                                    PoolAllocator_t(bool auto_thread_safe);

                                    ~PoolAllocator_t();

    void*                           Allocate(size_t size);

    void                            Release(void* block);

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    Pool_t*                         CreatePool(size_t block_size);
    void                            DeleteOldestPoolIfStale();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    PoolBlockSize_t                 m_pool_size_info[c_pool_num_block_sizes];

    Mutex_t*                        m_mutex;
    OwnedBTree_t< Pool_t, Pool_t* > m_all_pools_by_addr;
    BTree_t< Pool_t, size_t >       m_avail_pools_by_size;
    LinkedList_t<Pool_t>            m_delete_pools_by_age;
    BTree_t< Pool_t, size_t >       m_delete_pools_by_size;
};


// \cond DOXYGEN_DOCUMENT_NEVER


//==================================================================================================
class Pool_t
//==================================================================================================
:   public BTreeNode_t< Pool_t, Pool_t* >,
    public BTreeNode_t< Pool_t, size_t >,
    public LinkedListNode_t<Pool_t>
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    void*           operator new( size_t size, int capacity, size_t block_size );
                    Pool_t( int capacity, size_t block_size );
                    ~Pool_t();
    void            operator delete(void* malloced_block);

    inline size_t   BlockSize() const;
    inline int      Capacity() const;
    inline bool     AllBlocksAllocated() const;
    inline bool     AllBlocksAvailable() const;
    bool            Contains(byte* block) const;
    inline void     InitDeleteCounter(int count);
    inline bool     DecrementDeleteCounter();
    byte*           Allocate();
    void            Release(byte* block);

    inline int      Compare(Pool_t* address) const;
    inline          operator Pool_t*() const;
    inline int      Compare(size_t block_size) const;
    inline          operator size_t() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    size_t          m_block_size;
    int             m_capacity;
    uint32          m_avail_bitmap;
    uint32          m_avail_bitmap_when_all_avail;
    int             m_delete_counter;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations
//===
//==================================================================================================
//==================================================================================================
inline size_t
Pool_t::BlockSize() const
{
    return m_block_size;
}


inline int
Pool_t::Capacity() const
{
    return m_capacity;
}


inline bool
Pool_t::AllBlocksAllocated() const
{
    return (m_avail_bitmap == 0);
}


inline bool
Pool_t::AllBlocksAvailable() const
{
    return (m_avail_bitmap == m_avail_bitmap_when_all_avail);
}


inline int
Pool_t::Compare(Pool_t* address) const
{
    // If this comes before other, Compare should return a negative number
    if(this < address)
        return -1;
    else if(this == address)
        return 0;
    return 1;
}


inline
Pool_t::operator Pool_t*() const
{
    return const_cast<Pool_t*>(this);
}


inline void
Pool_t::InitDeleteCounter(int count)
{
    m_delete_counter = count;
}


inline bool
Pool_t::DecrementDeleteCounter()
{
    assert(m_delete_counter > 0);
    m_delete_counter--;
    return (m_delete_counter == 0);
}


inline int
Pool_t::Compare(size_t block_size) const
{
    // If this comes before other, Compare should return a negative number
    if(m_block_size < block_size)
        return -1;
    else if(m_block_size == block_size)
        return 0;
    return 1;
}


inline
Pool_t::operator size_t() const
{
    return m_block_size;
}


// \endcond

#endif // _UT_POOL_ALLOCATOR_H_