学步园

 

/**//**************************************************
 *
 * 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: