MemMan 3 beta

/**//**************************************************
 *
 * MemMan 3.0.0.0 beta
 *
 * Copyright (C) 2007 - 2008 by Len3d
 * All rights reserved.
 *
 *************************************************/

#ifndef __MEM_MAN__
#define __MEM_MAN__

#include <vector>
#include <algorithm>
#include <malloc.h>

#pragma pack(push,1)

namespace mem {

    #define mem_inline        __forceinline

    #define    mem_page_size    ( 1 << 18 )
    #define mem_align_size    16
    #define mem_align        __declspec( align( mem_align_size ) )

    typedef unsigned int    prior_type;
    typedef unsigned long    time_type;
    typedef unsigned long    size_type;
    typedef unsigned char    byte;

    #define mem_max( a, b )    ( ( (a) > (b) ) ? (a) : (b) )
    #define mem_min( a, b )    ( ( (a) < (b) ) ? (a) : (b) )

    enum {
        ENTRY_PRIORITY = 0,
    };

    class heap {
    public:
        mem_inline heap( size_type max_size )
        {
            allocated_size = 0;
            available_size = max_size;
        }

        mem_inline ~heap()
        {
        }

        mem_inline void *alloc( size_type size )
        {
            if( size == 0 )
                return NULL;

            allocated_size += size;
            available_size -= size;

            return sys_alloc( size );
        }

        mem_inline void dealloc( void *ptr, size_type size )
        {
            if( ptr && size != 0 )
            {
                sys_dealloc( ptr );

                allocated_size -= size;
                available_size += size;
            }
        }

        mem_inline void *aligned_alloc( size_type size )
        {
            if( size == 0 )
                return NULL;

            allocated_size += size;
            available_size -= size;

            return sys_aligned_alloc( size );
        }

        mem_inline void aligned_dealloc( void *ptr, size_type size )
        {
            if( ptr && size != 0 )
            {
                sys_aligned_dealloc( ptr );

                allocated_size -= size;
                available_size += size;
            }
        }

        mem_inline size_type available()
        {
            return available_size;
        }

    private:
        mem_inline void *sys_alloc( size_type size )
        {
            return malloc( size );
        }

        mem_inline void sys_dealloc( void *ptr )
        {
            free( ptr );
        }

        mem_inline void *sys_aligned_alloc( size_type size )
        {
            return _aligned_malloc( size, mem_align_size );
        }

        mem_inline void sys_aligned_dealloc( void *ptr )
        {
            _aligned_free( ptr );
        }

    private:
        size_type        allocated_size, 
                        available_size;
    };

    extern heap        *g_heap;

    class allocator {
    public:
        mem_inline void *alloc( size_type size )
        {
            return g_heap->alloc( size );
        }

        mem_inline void dealloc( void *ptr, size_type size )
        {
            g_heap->dealloc( ptr, size );
        }

        mem_inline size_type available()
        {
            return g_heap->available();
        }
    };

    class aligned_allocator {
    public:
        mem_inline void *alloc( size_type size )
        {
            return g_heap->aligned_alloc( size );
        }

        mem_inline void dealloc( void *ptr, size_type size )
        {
            g_heap->aligned_dealloc( ptr, size );
        }

        mem_inline size_type available()
        {
            return g_heap->available();
        }
    };

    template < typename ALLOC = allocator > class pool;

    template < typename ALLOC = allocator >
    class entry {
    public:
        mem_inline entry()
        {
            priority = ENTRY_PRIORITY;
            last_use_time = pl.get_current_time();
            locked = false;
        }
        
        mem_inline virtual ~entry()
        {
        }

        mem_inline void *alloc( size_type size )
        {
            return pl.alloc( size, this );
        }

        mem_inline void dealloc( void *ptr, size_type size )
        {
            pl.dealloc( ptr, size, this );
        }

        mem_inline void stream_begin()
        {
            locked = true;
            stream_in();
            last_use_time = pl.get_current_time();
        }

        mem_inline void stream_end()
        {
            locked = false;
        }

        mem_inline bool is_locked()
        {
            return locked;
        }

        mem_inline bool operator < ( const entry< ALLOC > & right ) const
        {
            if( priority == right.priority )
                return ( last_use_time < right.last_use_time );
            else
                return ( priority < right.priority );
        }

    public:
#ifdef _DEBUG
        virtual void stream_in() = 0;
#endif

        virtual bool stream_out( void * & ptr, size_type size ) = 0;

    public:
        static pool< ALLOC >    pl;
        prior_type                priority;
        time_type                last_use_time;
        bool                    locked;
    };

    template < typename ALLOC >
    mem_inline bool compare_entry( const entry< ALLOC > *left, const entry< ALLOC > *right )
    {
        return ( *left < *right );
    }

    template < typename ALLOC >
    class pool {
    private:
        class page {
        public:
            mem_inline page( size_type _size, page *old )
            {
                size = _size;
                base = get_base();
                next = old;
                prev = NULL;
                if( next )
                    next->prev = this;
            }

            mem_inline ~page()
            {
            }

            mem_inline void recycle( page *old )
            {
                void    *ptr = NULL;

                for( std::vector< entry< ALLOC > * >::iterator i = ents.begin();
                        i != ents.end(); ++i )
                {
                    (*i)->stream_out( ptr, 0 );
                }

                ents.clear();

                size = get_size();
                base = get_base();
                next = old;
                prev = NULL;
                if( next )
                    next->prev = this;
            }

            mem_inline byte *get_base()
            {
                return (byte *) this + sizeof(page);
            }

            mem_inline size_type get_size()
            {
                return static_cast<size_type>( base - get_base() + size );
            }

            mem_inline size_type available()
            {
                return size;
            }

            mem_inline void *alloc( size_type req_size, entry< ALLOC > *obj )
            {
                void    *ptr = (void *) base;

                base += req_size;
                size -= req_size;

                ents.push_back( obj );
            
                return ptr;
            }

            mem_inline time_type priority() const
            {
                time_type    last_use_time = 0;

                for( std::vector< entry< ALLOC > * >::const_iterator i = ents.begin();
                        i != ents.end(); ++i )
                {
                    last_use_time += (*i)->last_use_time;
                }

                last_use_time /= static_cast<time_type>( ents.size() );

                return last_use_time;
            }

            mem_inline bool operator < ( const page & right ) const
            {
                return ( priority() < right.priority() );
            }

        public:
            mem_align struct {
                byte                            *base;
                page                            *next;
                page                            *prev;
                size_type                        size;
                std::vector< entry< ALLOC > * >    ents;
            };
        };
        
        class chunk {
        public:
            mem_inline chunk( size_type _size, chunk *old )
            {
                size = _size;
                next = old;
                prev = NULL;
                if( next )
                    next->prev = this;
            }

            mem_inline size_type available()
            {
                return size;
            }

        public:
            chunk                    *next;
            chunk                    *prev;
            size_type                size;
        };

    public:
        mem_inline pool()
        {
            current_time = 0;
            pages = NULL;
            chunks = NULL;
            allocated = 0;
        }

        mem_inline ~pool()
        {
            destory();
        }

        mem_inline time_type get_current_time()
        {
            return ( ++ current_time );
        }

        mem_inline void *alloc( size_type size, entry< ALLOC > *obj )
        {
            void    *ptr = NULL;

            ++ allocated;

            if( search_chunk( ptr, size ) )
                return ptr;
            else if( search_page( ptr, size, obj ) )
                return ptr;
            else if( (size + sizeof(page)) > al.available() )
            {
                if( search_entry( ptr, size, obj ) )
                    return ptr;
                else
                {
                    recycle_page( size );

                    if( search_page( ptr, size, obj ) )
                        return ptr;
                    else
                        return NULL;
                }
            }
            else
            {
                allocate_page( size );

                if( search_page( ptr, size, obj ) )
                    return ptr;
                else
                    return NULL;
            }
        }

        mem_inline void dealloc( void *ptr, size_type size, entry< ALLOC > *obj )
        {
            -- allocated;

            for( std::vector< entry< ALLOC > * >::iterator i = g_ents.begin();
                    i != g_ents.end(); ++i )
            {
                if( obj == *i )
                {
                    g_ents.erase( i );
                    break;
                }
            }

            if( size >= sizeof(chunk) )
                chunks = new (ptr) chunk( size, chunks );
        
            if( allocated == 0 )
                destory();
        }

    private:
        mem_inline void destory()
        {
            page    *p = pages;
        
            while( p )
            {
                pages = p->next;
                p->~page();
                al.dealloc( p, p->get_size() );
                p = pages;
            }

            chunks = NULL;

            g_ents.clear();
        }

        mem_inline bool search_chunk( void * & ptr, size_type size )
        {
            chunk    *p = chunks;
            
            while( p )
            {
                if( size <= p->available() )
                {
                    ptr = (void *) p;
                    
                    if( p->prev )
                        p->prev->next = p->next;
                    if( p->next )
                        p->next->prev = p->prev;
                    
                    return true;
                }

                p = p->next;
            }

            return false;
        }

        mem_inline bool search_page( void * & ptr, size_type size, entry< ALLOC > *obj )
        {
            page    *p = pages;
            
            while( p )
            {
                if( size <= p->available() )
                {
                    ptr = p->alloc( size, obj );

                    g_ents.push_back( obj );
                    
                    if( p->prev )
                        p->prev->next = p->next;
                    if( p->next )
                        p->next->prev = p->prev;
                    
                    return true;
                }

                p = p->next;
            }

            return false;
        }

        mem_inline bool search_entry( void * & ptr, size_type size, entry< ALLOC > *obj )
        {
            std::sort( g_ents.begin(), g_ents.end(), compare_entry< ALLOC > );

            for( std::vector< entry< ALLOC > * >::iterator i = g_ents.begin();
                    i != g_ents.end(); ++i )
            {
                if( !(*i)->is_locked() && (*i)->stream_out( ptr, size ) )
                {
                    *i = obj;
                    return true;
                }
            }

            return false;
        }

        mem_inline void recycle_page( size_type size )
        {
            if( pages )
            {
                page    *p, *old;

                old = pages;
                p = pages->next;

                while( p )
                {
                    if( *p < *old )
                        old = p;

                    p = p->next;
                }

                if( old->prev )
                    old->prev->next = old->next;
                if( old->next )
                    old->next->prev = old->prev;

                old->recycle( pages );
                pages = old;
            }
        }

        mem_inline void allocate_page( size_type size )
        {
            size_type    asize = mem_min( mem_max( sizeof(page) + size, mem_page_size ), al.available() );

            pages = new (al.alloc( asize )) page( asize - sizeof(page), pages );
        }

    private:
        time_type                        current_time;
        time_type                        allocated;
        ALLOC                            al;
        std::vector< entry< ALLOC > * >    g_ents;
        page                            *pages;
        chunk                            *chunks;
    };

}    //    namespace mem


#pragma pack(pop)


#endif    //    __MEM_MAN__