/**************************************************
* * MemMan 3.0.0.0 beta * * Copyright (C) 2007 - 2008 by Len3d * All rights reserved. *
*************************************************/
#ifndef __MEMMAN__#define __MEMMAN__#include <malloc.h>#include <vector>#include <algorithm>#include <iostream>#pragma pack(push,1)namespace mem {
#define mem_inline __forceinline #define mem_pool_pad 16 #define mem_page_pad 48 #define mem_page_size ( 2 << 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) ) #define mem_mbyte( a ) ( float(a) * (1.0f / float( 1024 * 1024 )) )
enum {
ENTRY_PRIORITY = 0,
}; extern time_type num_stream_out; 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() const { return available_size; } mem_inline void print() { std::cout << std::endl; std::cout << "========== heap Statistics ==========" << std::endl; std::cout << std::endl; std::cout << "allocated size: " << mem_mbyte( allocated_size ) << " MB" << std::endl; std::cout << "available size: " << mem_mbyte( available_size ) << " MB" << std::endl; std::cout << std::endl; std::cout << "=====================================" << std::endl; std::cout << std::endl; } 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() const { 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() const { 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(); } mem_inline void print() { std::cout << std::endl; std::cout << "========== pool Statistics ==========" << std::endl; std::cout << std::endl; std::cout << "number of allocations: " << allocated << std::endl; std::cout << std::endl; std::cout << "=====================================" << std::endl; std::cout << std::endl; } 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 entry( prior_type prior ) { priority = prior; 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: virtual void stream_in() = 0; virtual size_type stream_size() = 0; virtual void *stream_out() = 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 ); } mem_inline time_type get_last_use_time() const { if( ptr ) return ptr->last_use_time; else return 0; } mem_inline bool is_locked() const { if( ptr ) return ptr->is_locked(); else return false; } mem_inline size_type stream_size() { if( ptr ) return ptr->stream_size(); else return 0; } mem_inline bool stream_out( void * & p ) { if( ptr ) { p = ptr->stream_out(); ptr->node_ptr = NULL; ++ num_stream_out; return true; } else return false; } mem_inline void detach() { if( prev ) prev->next = next; if( next ) next->prev = prev; } mem_inline void g_detach() { 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->g_detach(); p->~node(); node_pool.dealloc( p, sizeof(node) ); p = head.next; } } mem_inline void recycle( page *old ) { node *p = head.next; while( p ) { head.next = p->next; p->g_detach(); p->~node(); node_pool.dealloc( p, sizeof(node) ); 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() const { 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 is_locked() const { node *p = head.next; while( p ) { if( p->is_locked() ) return true; p = p->next; } return false; } 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() const { return size; } public: chunk *next; chunk *prev; size_type size; }; public: mem_inline cache() { current_time = 0; pages = NULL; chunks = NULL; allocated = 0; g_num_nodes = 0; num_recycle = 0; num_chunk_alloc = 0; num_pages = 0; num_chunks = 0; num_stream_alloc = 0; num_page_del = 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 { if( recycle_page( size ) ) { if( search_page( ptr, size, obj ) ) return ptr; else { std::cout << "fatal: failed to allocate memory!" << std::endl; return NULL; } } else { free_page( size ); allocate_page( size ); if( search_page( ptr, size, obj ) ) return ptr; else { std::cout << "fatal: failed to allocate memory!" << std::endl; return NULL; } } } } else { allocate_page( size ); if( search_page( ptr, size, obj ) ) return ptr; else { std::cout << "fatal: failed to allocate memory!" << std::endl; 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->g_detach(); obj->node_ptr->~node(); node_pool.dealloc( obj->node_ptr, sizeof(node) ); obj->node_ptr = NULL; -- g_num_nodes; } if( size >= sizeof(chunk) ) { chunks = new (ptr) chunk( size, chunks ); ++ num_chunks; } if( allocated == 0 ) destory(); } mem_inline void print() { std::cout << std::endl; std::cout << "========== cache Statistics ==========" << std::endl; std::cout << std::endl; std::cout << "current time: " << current_time << std::endl; std::cout << "number of allocations: " << allocated << std::endl; std::cout << "number of chunks: " << num_chunks << std::endl; std::cout << "number of chunk allocations: " << num_chunk_alloc << std::endl; std::cout << "number of nodes: " << g_num_nodes << std::endl; std::cout << "number of stream allocations: " << num_stream_alloc << std::endl; std::cout << "number of pages: " << num_pages << std::endl; std::cout << "number of page recycles: " << num_recycle << std::endl; std::cout << "number of page deletions: " << num_page_del << std::endl; std::cout << std::endl; std::cout << "======================================" << std::endl; std::cout << std::endl; } 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_num_nodes = 0; num_recycle = 0; num_chunk_alloc = 0; num_pages = 0; num_chunks = 0; num_stream_alloc = 0; num_page_del = 0; } 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; ++ num_chunk_alloc; -- num_chunks; 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; ++ g_num_nodes; return true; } p = p->next; } return false; } mem_inline bool search_entry( void * & ptr, size_type size, entry *obj ) { node *old = NULL; node *p = g_head.g_next; while( p ) { if( !p->is_locked() && p->stream_size() >= size ) { if( old ) { if( *p->ptr < *old->ptr ) old = p; } else old = p; } p = p->g_next; } if( old && old->stream_out( ptr ) ) { old->ptr = obj; obj->node_ptr = old; ++ num_stream_alloc; return true; } return false; } mem_inline bool recycle_page( size_type size ) { if( pages ) { page *old = NULL; page *p = pages; while( p ) { if( !p->is_locked() && p->get_size() >= size ) { if( old ) { if( *p < *old ) old = p; } else old = p; } p = p->next; } if( old ) { if( old != pages ) { if( old->prev ) old->prev->next = old->next; if( old->next ) old->next->prev = old->prev; old->recycle( pages ); pages = old; } else { old->recycle( old->next ); } ++ num_recycle; return true; } } return false; } mem_inline bool delete_page( size_type & del_size ) { if( pages ) { page *old = NULL; page *p = pages; while( p ) { if( !p->is_locked() ) { if( old ) { if( *p < *old ) old = p; } else old = p; } p = p->next; } if( old ) { if( old != pages ) { if( old->prev ) old->prev->next = old->next; if( old->next ) old->next->prev = old->prev; } else { pages = old->next; if( pages ) pages->prev = NULL; } del_size = old->get_size(); old->~page(); al.dealloc( old, old->get_size() ); -- num_pages; ++ num_page_del; return true; } } del_size = 0; return false; } mem_inline void free_page( size_type size ) { size_type del_size = 0; size_type freed_size = 0; while( freed_size < size && delete_page( del_size ) ) { freed_size += del_size; } } 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 ); ++ num_pages; } private: time_type current_time; time_type allocated; ALLOC al; node g_head; size_type g_num_nodes; page *pages; size_type num_pages; size_type num_recycle; chunk *chunks; size_type num_chunks; size_type num_chunk_alloc; size_type num_stream_alloc; size_type num_page_del; public: static pool< ALLOC > node_pool; }; class man { public: mem_inline man() { m_heap = NULL; upl = NULL; apl = NULL; num_stream_out = 0; } 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 >; num_stream_out = 0; } 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 ); } mem_inline void print() { std::cout << std::endl; std::cout << "********** MemMan Statistics **********" << std::endl; std::cout << std::endl; if( m_heap ) { std::cout << "global heap: " << std::endl; m_heap->print(); } std::cout << std::endl; std::cout << "page size: " << mem_page_size << " Byte" << std::endl; std::cout << std::endl; if( upl ) { std::cout << "unaligned pool: " << std::endl; upl->print(); } if( apl ) { std::cout << "aligned pool: " << std::endl; apl->print(); } std::cout << "unaligned node pool: " << std::endl; cache< mem::man::allocator >::node_pool.print(); std::cout << "aligned node pool: " << std::endl; cache< mem::man::aligned_allocator >::node_pool.print(); std::cout << "unaligned cache: " << std::endl; cache< mem::man::allocator >::entry::pl.print(); std::cout << "aligned cache: " << std::endl; cache< mem::man::aligned_allocator >::entry::pl.print(); std::cout << std::endl; std::cout << "number of stream_out: " << num_stream_out << std::endl; std::cout << std::endl; std::cout << std::endl; std::cout << "***************************************" << std::endl; std::cout << std::endl; } 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() const { 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() const { 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__/************************************************** * * MemMan 3.0.0.0 beta * * Copyright (C) 2007 - 2008 by Len3d * All rights reserved. * *************************************************/#ifndef __MEMMAN_DEF__#define __MEMMAN_DEF__#include "memman3.h"mem::man memman;mem::heap *mem::man::m_heap;mem::pool< mem::man::allocator > mem::cache< mem::man::allocator >::node_pool;mem::pool< mem::man::aligned_allocator > mem::cache< mem::man::aligned_allocator >::node_pool;mem::time_type mem::num_stream_out;mem::cache< mem::man::allocator > mem::cache< mem::man::allocator >::entry::pl;mem::cache< mem::man::aligned_allocator > mem::cache< mem::man::aligned_allocator >::entry::pl;#endif // __MEMMAN_DEF__