/**************************************************
* * MemMan 1.0.0.2 * * Copyright (C) 2007 - 2008 by Len3d * All rights reserved. *
*************************************************/
#ifndef __MEM_MAN__#define __MEM_MAN__#define DEFAULT_MEMORY_ALIGN 16 // default memory aligment set to this size#define ALIGN_DEF __declspec( align( DEFAULT_MEMORY_ALIGN ) )typedef int (*FreeContentFunc)( void *object, UINT requested_size, UINT & ref_count ); // can't be member function of a class#pragma pack(push,1)class MemoryAllocator { // memory allocator, takes charge of all system operations, also limits the usage of memoryprivate: typedef UINT MemoryHeaderBias; // biased value type of memory header // elements of the memory priority queue, keep track of all memory blocks
class MemoryHeader {
public: FORCEINLINE MemoryHeader( UINT prior, void *obj, FreeContentFunc func, UINT al ) { lchild = rchild = parent = NULL; priority = prior; object = obj; free_func = func; locked = TRUE; // we lock immediately after allocation align = al; ref_count = 1; // assume one block references this header at beginning bias = sizeof(MemoryHeader); bfact = 0; // initialize balance factor with 0
} // we don't need a deconstructor for this class FORCEINLINE void lock() { locked = TRUE; } FORCEINLINE void unlock() { locked = FALSE; } FORCEINLINE MemoryHeader *insert( MemoryHeader *key ) { MemoryHeader *root = this; bool taller = true; create_child( key, root, taller ); return root; // AVL may change the root, we return the new root here } FORCEINLINE void create_child( MemoryHeader *key, MemoryHeader * & root, bool & taller ) { if( key->priority < priority ) { if( lchild ) lchild->create_child( key, root, taller ); else { lchild = key; lchild->parent = this; taller = true; } if( taller ) { switch( bfact ) { case 1: left_balance( root ); taller = false; break; case 0: bfact = 1; taller = true; break; case -1: bfact = 0; taller = false; break; } } } else { if( rchild ) rchild->create_child( key, root, taller ); else { rchild = key; rchild->parent = this; taller = true; } if( taller ) { switch( bfact ) { case 1: bfact = 0; taller = false; break; case 0: bfact = -1; taller = true; break; case -1: right_balance( root ); taller = false; break; } } } } FORCEINLINE void left_rotate( MemoryHeader * & root ) { MemoryHeader *rc; rc = rchild; rchild = rc->lchild; if( rchild ) rchild->parent = this; rc->lchild = this; rc->parent = parent; if( parent ) { if( parent->lchild == this ) parent->lchild = rc; else if( parent->rchild == this ) parent->rchild = rc; } else { root = rc; } parent = rc; } FORCEINLINE void right_rotate( MemoryHeader * & root ) { MemoryHeader *lc; lc = lchild; lchild = lc->rchild; if( lchild ) lchild->parent = this; lc->rchild = this; lc->parent = parent; if( parent ) { if( parent->lchild == this ) parent->lchild = lc; else if( parent->rchild == this ) parent->rchild = lc; } else { root = lc; } parent = lc; } FORCEINLINE void left_balance( MemoryHeader * & root ) { MemoryHeader *lc, *rd; lc = lchild; switch( lc->bfact ) { case 1: bfact = lc->bfact = 0; right_rotate( root ); break; case 0: rd = lc->rchild; switch( rd->bfact ) { case 1: bfact = -1; lc->bfact = 0; break; case 0: bfact = lc->bfact = 0; break; case -1: bfact = 0; lc->bfact = 1; break; } rd->bfact = 0; lchild->left_rotate( root ); right_rotate( root ); break; } } FORCEINLINE void right_balance( MemoryHeader * & root ) { MemoryHeader *rc, *ld; rc = rchild; switch( rc->bfact ) { case 1: bfact = rc->bfact = 0; left_rotate( root ); break; case 0: ld = rc->lchild; switch( ld->bfact ) { case 1: bfact = -1; rc->bfact = 0; break; case 0: bfact = rc->bfact = 0; break; case -1: bfact = 0; rc->bfact = 1; break; } ld->bfact = 0; rchild->right_rotate( root ); left_rotate( root ); break; } } FORCEINLINE bool search_memory( UINT search_size, int search_align, void * & search_result, void *obj, FreeContentFunc func ) { if( lchild && lchild->search_memory( search_size, search_align, search_result, obj, func ) ) return true; if( align == search_align && free_content( search_size ) ) { search_result = get_memory(); object = obj; // update the attributes of the memory block free_func = func; return true; } if( rchild && rchild->search_memory( search_size, search_align, search_result, obj, func ) ) return true; return false; } FORCEINLINE void *get_memory() // the allocated memory block { return ((char *)this + sizeof(MemoryHeader)); } FORCEINLINE void dec_ref_count() // decrease the reference count { -- ref_count; } FORCEINLINE UINT get_ref_count() // the reference count { return ref_count; } // try to free some content of the object for requested size, // update the reference count and return the size of the freed memory FORCEINLINE int free_content( UINT requested_size ) { if( !locked && free_func && object ) return free_func( object, requested_size, ref_count ); else return 0; } public: ALIGN_DEF struct { // 48 Byte aligned including the header bias MemoryHeader *lchild, // left child, right child and parent *rchild, *parent; UINT priority; // priority for sorting the memory blocks void *object; // the object for which the memory was allocated FreeContentFunc free_func; // function to free the content of the object for requested size, // memory blocks without this function will be restored to memory-mapped files. int locked; // this memory block was locked by a thread int bfact; // balance factor of the AVL tree UINT align; // aligment of the allocated memory should match UINT ref_count; // how many blocks reference this header UINT pad; // padded to 48 Byte, no use MemoryHeaderBias bias; // the header bias }; };public: MemoryAllocator( UINT max_size ) // max allowed memory usage { allocated_size = 0; available_size = max_size; queue = NULL; aligned_queue = NULL; } ~MemoryAllocator() { dealloc_header( queue ); dealloc_aligned_header( aligned_queue ); } FORCEINLINE void *alloc( UINT size, UINT priority, void *object, FreeContentFunc free_func ) { if( size == 0 ) { return NULL; } else if( size > available_size ) // searching has the complexity of O(N) { void *ptr = NULL; if( queue && queue->search_memory( size, 0, ptr, object, free_func ) ) return ptr; else return NULL; // the system has run out of memory
} else // the complexity is O(logN) { allocated_size += ( sizeof(MemoryHeader) + size ); available_size -= ( sizeof(MemoryHeader) + size ); MemoryHeader *elem; // allocate a block elem = new (sys_alloc( sizeof(MemoryHeader) + size )) MemoryHeader( priority, object, free_func, 0 ); if( queue ) queue = queue->insert( elem ); // insert the node else queue = elem; // be the root return elem->get_memory(); } } FORCEINLINE void *aligned_alloc( UINT size, UINT priority, void *object, FreeContentFunc free_func, UINT align = DEFAULT_MEMORY_ALIGN ) { if( size == 0 ) { return NULL; } else if( size > available_size ) // searching has the complexity of O(N) { void *ptr = NULL; if( aligned_queue && aligned_queue->search_memory( size, align, ptr, object, free_func ) ) return ptr; else return NULL; // the system has run out of memory } else // the complexity is O(logN) { allocated_size += ( sizeof(MemoryHeader) + size ); available_size -= ( sizeof(MemoryHeader) + size ); MemoryHeader *elem; // allocate an aligned block elem = new (sys_aligned_alloc( sizeof(MemoryHeader) + size, align )) MemoryHeader( priority, object, free_func, align ); if( aligned_queue ) aligned_queue = aligned_queue->insert( elem ); // insert the node else aligned_queue = elem; // be the root return elem->get_memory(); } } // a lock must be used before the object being deallocated, the complexity is O(1) FORCEINLINE void lock( void *ptr ) { if( ptr ) { MemoryHeader *header = get_memory_header( ptr ); header->lock(); } } FORCEINLINE void unlock( void *ptr ) { if( ptr ) { MemoryHeader *header = get_memory_header( ptr ); header->unlock(); } } // deallocating has the complexity of O(logN) FORCEINLINE void dealloc( void *ptr, UINT size ) { if( ptr ) { MemoryHeader *header, *node, *parent; header = get_memory_header( ptr ); header->dec_ref_count(); if( header->get_ref_count() != 0 ) // still have objects reference this return; parent = header->parent; if( header->lchild && header->rchild ) // has left child and right child { node = find_rightmost_child( header->lchild ); // rebuild the links if( node != header->lchild ) { node->parent->rchild = node->lchild; if( node->lchild ) node->lchild->parent = node->parent; node->lchild = header->lchild; node->lchild->parent = node; } node->rchild = header->rchild; node->rchild->parent = node; node->parent = parent; if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = node; else if( parent->rchild == header ) parent->rchild = node; } else // it's the root { queue = node; } } else if( header->lchild ) // has only left child { // rebuild the links node = header->lchild; node->parent = parent; if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = node; else if( parent->rchild == header ) parent->rchild = node; } else // it's the root { queue = node; } } else if( header->rchild ) // has only right child { // rebuild the links node = header->rchild; node->parent = parent; if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = node; else if( parent->rchild == header ) parent->rchild = node; } else // it's the root { queue = node; } } else // has no child { if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = NULL; else if( parent->rchild == header ) parent->rchild = NULL; } else // it's the root, clear it { queue = NULL; } } allocated_size -= ( sizeof(MemoryHeader) + size ); available_size += ( sizeof(MemoryHeader) + size ); sys_dealloc( header ); // deallocate the block } } FORCEINLINE void aligned_dealloc( void *ptr, UINT size ) { if( ptr ) { MemoryHeader *header, *node, *parent; header = get_memory_header( ptr ); header->dec_ref_count(); if( header->get_ref_count() != 0 ) // still have objects reference this return; parent = header->parent; if( header->lchild && header->rchild ) // has left child and right child { node = find_rightmost_child( header->lchild ); // rebuild the links if( node != header->lchild ) { node->parent->rchild = node->lchild; if( node->lchild ) node->lchild->parent = node->parent; node->lchild = header->lchild; node->lchild->parent = node; } node->rchild = header->rchild; node->rchild->parent = node; node->parent = parent; if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = node; else if( parent->rchild == header ) parent->rchild = node; } else // it's the root { aligned_queue = node; } } else if( header->lchild ) // has only left child { // rebuild the links node = header->lchild; node->parent = parent; if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = node; else if( parent->rchild == header ) parent->rchild = node; } else // it's the root { aligned_queue = node; } } else if( header->rchild ) // has only right child { // rebuild the links node = header->rchild; node->parent = parent; if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = node; else if( parent->rchild == header ) parent->rchild = node; } else // it's the root { aligned_queue = node; } } else // has no child { if( parent ) // has parent { if( parent->lchild == header ) parent->lchild = NULL; else if( parent->rchild == header ) parent->rchild = NULL; } else // it's the root, clear it { aligned_queue = NULL; } } allocated_size -= ( sizeof(MemoryHeader) + size ); available_size += ( sizeof(MemoryHeader) + size ); sys_aligned_dealloc( header ); // deallocate the block } }private: // help functions FORCEINLINE void dealloc_header( MemoryHeader *node ) { if( node ) { if( node->lchild ) dealloc_header( node->lchild ); if( node->rchild ) dealloc_header( node->rchild ); sys_dealloc( node ); } } FORCEINLINE void dealloc_aligned_header( MemoryHeader *node ) { if( node ) { if( node->lchild ) dealloc_aligned_header( node->lchild ); if( node->rchild ) dealloc_aligned_header( node->rchild ); sys_aligned_dealloc( node ); } } FORCEINLINE MemoryHeader *find_rightmost_child( MemoryHeader *node ) { while( node && node->rchild ) { node = node->rchild; } return node; } FORCEINLINE MemoryHeader *get_memory_header( void *ptr ) { // get the biased value first MemoryHeaderBias *pb = (MemoryHeaderBias *)((char *) ptr - sizeof(MemoryHeaderBias)); // then get the header using the biased value MemoryHeader *header = (MemoryHeader *)((char *) ptr - (*pb)); return header; }private: // encapsulate system operations FORCEINLINE void *sys_alloc( UINT size ) { return malloc( size ); } FORCEINLINE void *sys_aligned_alloc( UINT size, UINT align ) { return _mm_malloc( size, align ); } FORCEINLINE void sys_dealloc( void *ptr ) { free( ptr ); } FORCEINLINE void sys_aligned_dealloc( void *ptr ) { _mm_free( ptr ); }private: // memory statistics UINT allocated_size, available_size; // implement priority queues to record all the allocations MemoryHeader *queue; MemoryHeader *aligned_queue;};#pragma pack(pop)#endif // __MEM_MAN__