home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 March / Gamestar_82_2006-03_dvd.iso / DVDStar / Editace / quake4_sdkv10.exe / source / idlib / rvMemSys.h < prev    next >
C/C++ Source or Header  |  2005-11-14  |  5KB  |  145 lines
  1. //
  2. // rvMemSys.h - Memory management system
  3. // Date: 12/17/04
  4. // Created by: Dwight Luetscher
  5. //
  6. // Date: 04/01/05
  7. // Modified by: Marcus Whitlock
  8. // Added permanent heap and new heap push function to push the heap that contains
  9. // a specified piece of memory.
  10. //
  11. // Date: 04/04/05
  12. // Modified by: Marcus Whitlock
  13. // Added rvAutoHeapCtxt class for push and auto-pop of heap context.
  14. //
  15.  
  16. #ifndef __RV_MEM_SYS_H__
  17. #define __RV_MEM_SYS_H__
  18.  
  19. typedef enum 
  20. {
  21.     RV_HEAP_ID_DEFAULT,            // heap that exists on application startup
  22.     RV_HEAP_ID_PERMANENT,        // heap for allocations that have permanent (application scope) lifetime
  23.     RV_HEAP_ID_LEVEL,            // heap for allocations that have a level lifetime
  24.     RV_HEAP_ID_MULTIPLE_FRAME,    // heap for run-time allocations that have a lifetime of multiple draw frames 
  25.     RV_HEAP_ID_SINGLE_FRAME,    // heap for run-time allocations that have a lifetime of a single draw frame
  26.     RV_HEAP_ID_TEMPORARY,        // heap for objects that have a short lifetime (temporaries generally used for level loading)
  27.     RV_HEAP_ID_IO_TEMP,            // heap for allocations that are temporaries used in I/O operations like level loading or writing out data
  28.     rv_heap_ID_max_count        // just a count, not a valid type
  29. } 
  30. Rv_Sys_Heap_ID_t;
  31.  
  32. static const uint MAX_SYSTEM_HEAPS    = (uint) rv_heap_ID_max_count;
  33.  
  34. #ifdef _RV_MEM_SYS_SUPPORT
  35.  
  36. //
  37. //    _RV_MEM_SYS_SUPPORT is defined
  38. //
  39.  
  40. extern rvHeapArena *currentHeapArena;    
  41.  
  42. // Functions for getting and setting the system heaps.
  43. void    rvSetSysHeap( Rv_Sys_Heap_ID_t sysHeapID, rvHeap *heapPtr );                    // associates a heap with the given system heap ID value
  44. rvHeap* rvGetSysHeap( Rv_Sys_Heap_ID_t sysHeapID );                                        // retrieves the specified system heap
  45. void    rvGetAllSysHeaps( rvHeap *destSystemHeapArray[MAX_SYSTEM_HEAPS] );                // retrieves all the MAX_SYSTEM_HEAPS heap pointers into the given array
  46. void    rvSetAllSysHeaps( rvHeap *srcSystemHeapArray[MAX_SYSTEM_HEAPS] );                // associates all the MAX_SYSTEM_HEAPS heap pointers from the given array with their corresponding id value
  47. bool    rvPushHeapContainingMemory( const void* mem );                                    // pushes the heap containg the memory specified to the top of the arena stack, making it current - mwhitlock
  48.  
  49. void rvEnterArenaCriticalSection( );                            // enters the heap arena critical section
  50. void rvExitArenaCriticalSection( );                                // exits the heap arena critical section
  51. void rvPushSysHeap(Rv_Sys_Heap_ID_t sysHeapID);                    // pushes the system heap associated with the given identifier to the top of the arena stack, making it current
  52.  
  53. // Useful in situations where a heap is pushed, but a return on error or an
  54. // exception could cause the stack to be unwound, bypassing the heap pop
  55. // operation - mwhitlock.
  56. class rvAutoHeapCtxt
  57. {
  58.     bool mPushed;
  59.  
  60. public:
  61.     rvAutoHeapCtxt(void) :
  62.         mPushed(false)
  63.     {
  64.         // Should never call this.
  65.         assert(0);
  66.     }
  67.  
  68.     rvAutoHeapCtxt(Rv_Sys_Heap_ID_t sysHeapID) :
  69.         mPushed(false)
  70.     {
  71.         rvPushSysHeap(sysHeapID);
  72.         mPushed = true;
  73.     }
  74.  
  75.     rvAutoHeapCtxt(const void* mem) :
  76.         mPushed(false)
  77.     {
  78.         mPushed = rvPushHeapContainingMemory( mem );
  79.     }
  80.  
  81.     ~rvAutoHeapCtxt(void)
  82.     {
  83.         if(mPushed)
  84.         {
  85.             currentHeapArena->Pop();
  86.         }
  87.     }
  88. };
  89.  
  90. //
  91. //    RV_PUSH_SYS_HEAP_ID()
  92. //    Push system heaps by their ID (always available to idLib, Game and executable).
  93. //
  94. #define RV_PUSH_SYS_HEAP_ID(sysHeapID)                rvPushSysHeap(sysHeapID)
  95. #define RV_PUSH_SYS_HEAP_ID_AUTO(varName,sysHeapID)    rvAutoHeapCtxt varName(sysHeapID)
  96.  
  97. //
  98. //    RV_PUSH_HEAP_MEM()
  99. //    Push the heap containing the piece of memory pointed to. Note that if the
  100. //    piece of memory is not from a heap, no heap will be pushed.
  101. //
  102. #define RV_PUSH_HEAP_MEM(memPtr)                    rvPushHeapContainingMemory(memPtr)
  103. #define RV_PUSH_HEAP_MEM_AUTO(varName,memPtr)        rvAutoHeapCtxt varName(memPtr)
  104.  
  105. //
  106. //    RV_PUSH_HEAP_PTR()
  107. //    Local heaps used mainly by executable (idLib and Game would use these only
  108. //    if heap was passed in)
  109. //
  110. #define RV_PUSH_HEAP_PTR(heapPtr)                    ( (heapPtr)->PushCurrent() )
  111.  
  112. //
  113. //    RV_PUSH_SYS_HEAP()
  114. //    Pop top of heap stack, regardless of how it was pushed.
  115. //
  116. #define RV_POP_HEAP()                                ( currentHeapArena->Pop() )
  117.  
  118. // The following versions enter/exit the heap arena's critical section so that
  119. // critical section protection remains active between a push/pop pair (NOTE that
  120. // the heap and heap arena are always protected by critical sections within a single method call)
  121. #define RV_PUSH_SYS_HEAP_ENTER_CRIT_SECT(sysHeapID)    { rvEnterArenaCriticalSection( ); rvPushSysHeap( sysHeapID ); }
  122. #define RV_PUSH_HEAP_ENTER_CRIT_SECT(heapPtr)        { rvEnterArenaCriticalSection( ); (heapPtr)->PushCurrent( ); }
  123. #define RV_POP_HEAP_EXIT_CRIT_SECT()                { currentHeapArena->Pop( ); rvExitArenaCriticalSection( ); }
  124.  
  125. #else    // #ifdef _RV_MEM_SYS_SUPPORT
  126.  
  127. //
  128. //    _RV_MEM_SYS_SUPPORT is not defined
  129. //
  130.  
  131. #define RV_PUSH_SYS_HEAP_ID(sysHeapID)
  132. #define RV_PUSH_SYS_HEAP_ID_AUTO(varName,sysHeapID)
  133. #define RV_PUSH_HEAP_MEM(memPtr)
  134. #define RV_PUSH_HEAP_MEM_AUTO(varName,memPtr)
  135. #define RV_PUSH_HEAP_PTR(heapPtr)
  136. #define RV_POP_HEAP()    
  137.  
  138. #define RV_PUSH_SYS_HEAP_ENTER_CRIT_SECT(sysHeapID)
  139. #define RV_PUSH_HEAP_ENTER_CRIT_SECT(heapPtr)    
  140. #define RV_POP_HEAP_EXIT_CRIT_SECT()            
  141.  
  142. #endif    // #else not #ifdef _RV_MEM_SYS_SUPPORT
  143.  
  144. #endif    // #ifndef __RV_MEM_SYS_H__
  145.