/**************************************************
* * MemMan 3.0.0.0 beta * * Copyright (C) 2007 - 2008 by Len3d * All rights reserved. *
*************************************************/
#ifndef __MEMMAN__#define __MEMMAN__#include <malloc.h>#pragma pack(push,1)namespace mem {
#define mem_inline __forceinline #define mem_pool_pad 16 #define mem_page_pad 48 #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; }; template < typename ALLOC > class pool { private: class page { public: mem_inline page( size_type _size, page *old ) { base = get_base(); _next = old; size = _size; } 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 _size ) { byte *ptr = base; base += _size; size -= _size; return ptr; } mem_inline page *next() { return _next; } private: mem_align union { struct { byte *base; page *_next; size_type size; }; byte pad[mem_pool_pad]; }; }; class chunk { public: mem_inline chunk( size_type _size, chunk *old ) { next = old; size = _size; } mem_inline size_type available() { return size; } public: chunk *next; size_type size; }; public: mem_inline pool() { pages = NULL; chunks = NULL; allocated = 0; } mem_inline ~pool() { destory(); } mem_inline void destory() { page *p; while( ( p = pages ) != NULL ) { pages = p->next(); al.dealloc( p, p->get_size() ); } pages = NULL; chunks = NULL; } mem_inline bool search_chunk( void * & ptr, size_type size ) { if( chunks && ( size <= chunks->available() ) ) { ptr = (void *) chunks; chunks = chunks->next; return true; } else return false; } mem_inline bool search_page( void * & ptr, size_type size ) { if( pages && ( size <= pages->available() ) ) { ptr = pages->alloc( size ); return true; } else return false; } mem_inline void allocate_page( size_type size ) { size_type asize = mem_max( size, mem_page_size ); pages = new (al.alloc( sizeof(page) + asize )) page( asize, pages ); } mem_inline void *alloc( size_type size ) { void *ptr; ++ allocated; if( search_chunk( ptr, size ) ) return ptr; else if( search_page( ptr, size ) ) return ptr; else { allocate_page( size ); if( search_page( ptr, size ) ) return ptr; else return NULL; } } mem_inline void dealloc( void *ptr, size_type size ) { -- allocated; if( size >= sizeof(chunk) ) chunks = new (ptr) chunk( size, chunks ); if( allocated == 0 ) destory(); } private: page *pages; chunk *chunks; size_type allocated; ALLOC al; }; template < typename ALLOC > class cache { public: class node; class entry { public: mem_inline entry() { priority = ENTRY_PRIORITY; last_use_time = pl.get_current_time(); locked = false; node_ptr = NULL; } 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 & 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 cache< ALLOC > pl; prior_type priority; time_type last_use_time; bool locked; node *node_ptr; }; class node { public: mem_inline node( entry *obj, node *old, node *g_old, node *phead, node *g_phead ) { ptr = obj; obj->node_ptr = this; next = old; prev = phead; g_next = g_old; g_prev = g_phead; if( next ) next->prev = this; if( prev ) prev->next = this; if( g_next ) g_next->g_prev = this; if( g_prev ) g_prev->g_next = this; } mem_inline node() { ptr = NULL; next = NULL; prev = NULL; g_next = NULL; g_prev = NULL; } mem_inline ~node() { void *p = NULL; stream_out( p, 0 ); } mem_inline time_type get_last_use_time() { if( ptr ) return ptr->last_use_time; else return 0; } mem_inline bool is_locked() { if( ptr ) return ptr->is_locked(); else return false; } mem_inline bool stream_out( void * & p, size_type size ) { if( ptr ) { bool bret = ptr->stream_out( p, size ); if( bret ) ptr->node_ptr = NULL; return bret; } else return false; } mem_inline void detach() { if( prev ) prev->next = next; if( next ) next->prev = prev; if( g_prev ) g_prev->g_next = g_next; if( g_next ) g_next->g_prev = g_prev; } public: entry *ptr; node *next, *prev; node *g_next, *g_prev; }; 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; num_nodes = 0; } mem_inline ~page() { node *p = head.next; while( p ) { head.next = p->next; p->detach(); delete p; p = head.next; } } mem_inline void recycle( page *old ) { node *p = head.next; while( p ) { head.next = p->next; p->detach(); delete p; p = head.next; } head.next = NULL; size = get_size(); base = get_base(); next = old; prev = NULL; if( next ) next->prev = this; num_nodes = 0; } 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 ) { void *ptr = (void *) base; base += req_size; size -= req_size; return ptr; } mem_inline time_type priority() const { time_type last_use_time = 0; node *p = head.next; while( p ) { last_use_time += p->get_last_use_time(); p = p->next; } if( num_nodes != 0 ) last_use_time /= static_cast<time_type>( num_nodes ); return last_use_time; } mem_inline bool operator < ( const page & right ) const { return ( priority() < right.priority() ); } public: mem_align union { struct { byte *base; page *next; page *prev; size_type size; node head; size_type num_nodes; }; byte pad[mem_page_pad]; }; }; 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 cache() { current_time = 0; pages = NULL; chunks = NULL; allocated = 0; } mem_inline ~cache() { destory(); } mem_inline time_type get_current_time() { return ( ++ current_time ); } mem_inline void *alloc( size_type size, entry *obj ) { void *ptr = NULL; ++ allocated; obj->node_ptr = NULL; 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 *obj ) { -- allocated; if( obj->node_ptr ) { obj->node_ptr->detach(); obj->node_ptr->~node(); node_pool.dealloc( obj->node_ptr, sizeof(node) ); obj->node_ptr = NULL; } 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; } 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 *obj ) { page *p = pages; while( p ) { if( size <= p->available() ) { ptr = p->alloc( size ); new (node_pool.alloc( sizeof(node) )) node( obj, p->head.next, g_head.g_next, &p->head, &g_head ); ++ p->num_nodes; return true; } p = p->next; } return false; } mem_inline node *node_sort( node *p ) { return p; } mem_inline bool search_entry( void * & ptr, size_type size, entry *obj ) { g_head.g_next = node_sort( g_head.g_next ); node *p = g_head.g_next; while( p ) { if( !p->is_locked() && p->stream_out( ptr, size ) ) { p->ptr = obj; obj->node_ptr = p; return true; } p = p->g_next; } 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 != pages ) { 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; node g_head; page *pages; chunk *chunks; pool< ALLOC > node_pool; }; class man { public: mem_inline man() { m_heap = NULL; upl = NULL; apl = NULL; } mem_inline ~man() { if( apl ) delete apl; if( upl ) delete upl; if( m_heap ) delete m_heap; } mem_inline void begin( size_type heap_size ) { m_heap = new heap( heap_size ); upl = new pool< allocator >; apl = new pool< aligned_allocator >; } mem_inline void end() { delete apl; apl = NULL; delete upl; upl = NULL; delete m_heap; m_heap = NULL; } mem_inline void *alloc( size_type size ) { return upl->alloc( size ); } mem_inline void dealloc( void *ptr, size_type size ) { return upl->dealloc( ptr, size ); } mem_inline void *aligned_alloc( size_type size ) { return apl->alloc( size ); } mem_inline void aligned_dealloc( void *ptr, size_type size ) { return apl->dealloc( ptr, size ); } public: static heap *m_heap; public: class allocator { public: mem_inline void *alloc( size_type size ) { return m_heap->alloc( size ); } mem_inline void dealloc( void *ptr, size_type size ) { m_heap->dealloc( ptr, size ); } mem_inline size_type available() { return m_heap->available(); } }; class aligned_allocator { public: mem_inline void *alloc( size_type size ) { return m_heap->aligned_alloc( size ); } mem_inline void dealloc( void *ptr, size_type size ) { m_heap->aligned_dealloc( ptr, size ); } mem_inline size_type available() { return m_heap->available(); } }; public: pool< allocator > *upl; pool< aligned_allocator > *apl; }; typedef cache< man::allocator >::entry resource; typedef cache< man::aligned_allocator >::entry aligned_resource;} // namespace memextern mem::man memman;#pragma pack(pop)#endif // __MEMMAN__