我写的一个简单的内存管理器

template< int ALIGN > class MemPage {
public:
    inline MemPage( UINT _size, MemPage *oldPage ) {
        UINT    asize = MAX( _size, MEMORY_PAGE_SIZE );
        head = _mm_malloc( asize, ALIGN );
        page = (BYTE *) head;
        _next = oldPage;
        size = asize;
    }
    inline MemPage( void *ptr, UINT _size, MemPage *oldPage ) {
        head = NULL;
        page = (BYTE *) ptr;
        _next = oldPage;
        size = _size;
    }
    inline ~MemPage() {
        if( head )
            _mm_free( head );
    }
    inline UINT    available() {
        return size;
    }
    inline void    *alloc( UINT _size ) {
        void *ptr = page;
        page += _size;
        size -= _size;
        return ptr;
    }
    inline MemPage    *next() {
        return _next;
    }
private:
    union {
        struct {
            void        *head;
            BYTE        *page;
            MemPage        *_next;
            UINT        size;
        };
        __m128            aligned;
    };
};

template < typename T, int ALIGN > class MemPool {
public:
    inline MemPool() {
        thePage = NULL;
        theChunk = NULL;
        allocated = 0;
        inited = 0;
    }
    inline void init() {
        thePage = NULL;
        theChunk = NULL;
        allocated = 0;
        inited ++;
    }
    inline void destory() {
        if( inited == 1 ) {
            MemPage< ALIGN >    *cPage;
            while( ( cPage = thePage ) != NULL ) {
                thePage = cPage->next();
                delete cPage;
            }
        }
        inited --;
    }
    inline void    *alloc( UINT size ) {
        void    *ptr;
        if( theChunk == NULL || size > theChunk->available() ) {
            if( thePage == NULL || size > thePage->available() ) {
                if( !inited )
                    init();
                thePage = new MemPage< ALIGN > ( size, thePage );
            }
            ptr = thePage->alloc( size );
        } else {
            MemPage< ALIGN >    *cPage = theChunk;
            ptr = cPage->alloc( size );
            theChunk = cPage->next();
        }
        allocated ++;
        return ptr;
    }
    inline void    dealloc( void * ptr ) {
        allocated --;
        if( allocated == 0 )
            destory();
    }
    inline void    dealloc( void * ptr, UINT size ) {
        if( size > sizeof(MemPage< ALIGN >) )
            theChunk = new (ptr) MemPage< ALIGN > ( (BYTE *)ptr + sizeof(MemPage< ALIGN >),
                                                    size - sizeof(MemPage< ALIGN >), theChunk );
        allocated --;
        if( allocated == 0 )
            destory();
    }
private:
    MemPage< ALIGN >    *thePage, *theChunk;
    UINT                inited, allocated;
};

用我的渲染器测试了一下，速度还是很快的。。。