Memory_Manager.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Description : Dynamic memory manager
// Filename    : MemoryManager.h
//------------------------------------------------------------------------------
 
#pragma once
 
//------------------------------------------------------------------------------
 
#include <StdLib.h>
 
#include "Defines.h"
 
//--- C++ definition -----------------------------------------------------------
 
#ifdef __cplusplus
extern "C"
{
#endif
 
//--- Structur TAllocatedSegment -----------------------------------------------
 
class TAllocatedSegment;
class TAllocatedSegment
{
  
  public:
    U32 Status;                          // Status of segment
    U32 Size;                            // Size of segment
    TAllocatedSegment *PreviousSegment;  // Pointer to previous segment
    TAllocatedSegment *NextSegment;      // Pointer to next segment
    #ifdef MEMORY_MANAGER_ADD_OWNER_INFORMATION
    CHAR File[ 32 ];                     // File name
    U32 Line;                            // File line
    #endif
    
};
 
//--- Structur TMemoryStatistics -----------------------------------------------
 
typedef struct
{                     
 
  VOID *BaseAddress;                  // Base Address of the virtual memory
  VOID *BottomSegment;                // Address of bottom segment
  VOID *TopSegment;                   // Address of top segment
  U32 TotalMemorySize;                // Total size of virtual memory
  U32 AllocatedMemorySize;            // Size of allocated memory
  U32 WastedMemorySize;               // Size of wated memory
  U32 FreeMemorySize;                 // Size of free memory
 
  U32 MaximalUsedMemory;              // Maximal used memory
      
  U32 AllocatedSegments;              // Allocated segments      
  U32 FreeSegments;                   // Free segments
  U32 TotalSegments;                  // Total allocated segments
        
  U32 MaximalAllocatedSegmentSize;    // Maximal size of allocated segment
  U32 MaximalFreeSegmentSize;         // Maximal size of free segment
 
  U32 AllocateClearedMemoryRequests;  // Count of allocate and clear memory requests
  U32 AllocateMemoryRequests;         // Count of allocate memory requests
  U32 DeallocateMemoryRequests;       // Count of deallocate memory requests
  U32 ReallocateMemoryRequests;       // Count of reallocate memory requesta
 
  U32 AllocationErrorCount;           // Count of allocation errors. (Out of memory or allocated size is null. )
  U32 ReallocationErrorCount;         // Count of reallocation errors.
  U32 DeallocationErrorCount;         // Count of deallocation errors. (Pointer is NULL.)
 
  VOID *FailedSegment;                // Last failed segment
  U32 FailedSegmentSatus;             // Status of the failed segment
 
  #ifdef MEMORY_MANAGER_ADD_OWNER_INFORMATION
  CHAR File[ 32 ];
  U32 Line;
  #endif
                
} TMemoryStatistics;
 
//--- Class TMemoryManager -----------------------------------------------------
 
class TMemoryManager
{
 
  public:
 
    TMemoryManager( VOID *ParentBaseAddress, U32 MemorySize );                 // Constructor
  
    #ifdef MEMORY_MANAGER_ADD_OWNER_INFORMATION
    VOID *allocMemory( U32 Size, BOOL Clear, const CHAR* File, U32 Line );     // Allocate memory segment
    VOID *rllocMemory( VOID *Pointer, U32 Size, const CHAR* File, U32 Line );  // Reallocate memory segment
    VOID dllocMemory( VOID *Pointer );                                         // Deallocate memory segment
    #else
    VOID *allocMemory( U32 Size, BOOL Clear );                                 // Allocate memory segment
    VOID *rllocMemory( VOID *Pointer, U32 Size );                              // Reallocate memory segment
    VOID dllocMemory( VOID *Pointer );                                         // Deallocate memory segment
    #endif
    
    BOOL CheckIntegrity();                                                     // Check integrety of virtual memory
    
    VOID GetStatistics( TMemoryStatistics *Statistics );                       // Get statistics 
         
  private:
    
    BOOL Is_Segment_Valid( TAllocatedSegment *object_Segment );
    BOOL Is_Segment_Free( TAllocatedSegment *object_Segment );
    BOOL Is_Segment_Allocated( TAllocatedSegment *object_Segment );
  
    VOID MergeSegments( TAllocatedSegment *Segment );                              // Merge segements
    
    BOOL SplitSegment( TAllocatedSegment *Segment, U32 SegmentSizeToAllocation );  // Split segement
    
    VOID SetFirstFreeSegment( TAllocatedSegment *Segment );
    
    // Start address of virtual memory
    VOID *BaseAddress;                    
    
    // Pointer to bottom memory segment
    TAllocatedSegment *BottomSegment;     
    
    // Pointer to top memory segment
    TAllocatedSegment *TopSegment;        
    
    // First free segment
    TAllocatedSegment *FirstFreeSegment;  
    
    // Total size of virtual memory
    U32 TotalMemorySize;                  
    
    // Size of allocated memory
    U32 AllocatedMemorySize;              
    
    // Size of wated memory
    U32 WastedMemorySize;                 
    
    // Size of free memory
    U32 FreeMemorySize;                   
    
    // Maximal used memory
    U32 MaximalUsedMemory;                
    
    // Allocated segments
    U32 AllocatedSegments;                
    
    // Free segments
    U32 FreeSegments;                     
    
    // Total allocated segments
    U32 TotalSegments;                    
    
    // Maximal size of allocated segment
    U32 MaximalAllocatedSegmentSize;      
    
    // Maximal size of free segment
    U32 MaximalFreeSegmentSize;           
    
    // Count of allocate and clear memory requests
    U32 AllocateClearedMemoryRequests;    
    
    // Count of allocate memory requests
    U32 AllocateMemoryRequests;           
    
    // Count of deallocate memory requests
    U32 DeallocateMemoryRequests;         
    
    // Count of reallocate memory requesta
    U32 ReallocateMemoryRequests;         
    
    // Count of allocation errors. Out of memory or allocated size is null. 
    U32 AllocationErrorCount;             
    
    // Count of reallocation errors.
    U32 ReallocationErrorCount;           
    
    // Count of deallocation errors. Pointer is NULL.
    U32 DeallocationErrorCount;           
    
    // Last failed segment
    TAllocatedSegment *FailedSegment;     
    
    // Status of the failed segment
    U32 FailedSegmentSatus;             
 
};
 
//------------------------------------------------------------------------------
// Extern object declaration
//------------------------------------------------------------------------------
 
extern TMemoryManager MemoryManager;
 
//--- End of C++ definition ----------------------------------------------------
 
#ifdef __cplusplus
}
#endif
 
//------------------------------------------------------------------------------
 
#ifdef MEMORY_MANAGER_ADD_OWNER_INFORMATION
 
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
 
#define new                 new ( __FILE__, __LINE__ )
#define delete( ptr )       MemoryManager.dllocMemory( ptr )
#define malloc( sz )        MemoryManager.allocMemory( (U32)sz, false, __FILE__, __LINE__ )
#define free( ptr )         MemoryManager.dllocMemory( ptr )
#define realloc( ptr, sz )  MemoryManager.rllocMemory( ptr, (U32)sz, __FILE__, __LINE__ )
#define calloc( cnt, sz )   MemoryManager.allocMemory( (U32)cnt * (U32)sz, true,__FILE__, __LINE__ )
 
//--- Overridden global "new" --------------------------------------------------
 
inline VOID *operator new( size_t count, const CHAR* File, U32 Line )
{
 
  // Return pointer to allocated memory  
  return( MemoryManager.allocMemory( (U32)count, false, File, Line ) );
  
}                               
 
//--- Overridden global "new[]" ------------------------------------------------
 
inline VOID *operator new[]( size_t count, const CHAR* File, U32 Line )
{
 
  // Return pointer to allocated memory  
  return( MemoryManager.allocMemory( (U32)count, false, File, Line ) );
  
}
 
//------------------------------------------------------------------------------
// Overridden global "delete" 
//------------------------------------------------------------------------------
 
inline VOID operator delete[]( VOID* void_Pointer_To_Memory )
{
 
  // Deallocate memory  
  MemoryManager.dllocMemory( void_Pointer_To_Memory );
  
}
 
//------------------------------------------------------------------------------
// Overridden global "delete[]"
//------------------------------------------------------------------------------
 
inline VOID operator delete( VOID* void_Pointer_To_Memory )
{
 
  // Deallocate memory
  MemoryManager.dllocMemory( void_Pointer_To_Memory );
  
}
 
#else
 
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
 
#define new                 new
#define delete              delete 
#define malloc( sz )        MemoryManager.allocMemory( (U32)sz, false )
#define free( ptr )         MemoryManager.dllocMemory( ptr )
#define realloc( ptr, sz )  MemoryManager.rllocMemory( ptr, (U32)sz )
#define calloc( cnt, sz )   MemoryManager.allocMemory( (U32)cnt * (U32)sz, true )
 
//------------------------------------------------------------------------------
// Override global "new" 
//------------------------------------------------------------------------------
 
inline VOID *operator new( size_t count )
{
 
  // Return pointer to allocated memory  
  return( MemoryManager.allocMemory( (U32)count, false ) );
  
}                               
 
//------------------------------------------------------------------------------
// Override global "new[]" 
//------------------------------------------------------------------------------
 
inline VOID *operator new[]( size_t count )
{
 
  // Return pointer to allocated memory  
  return( MemoryManager.allocMemory( (U32)count, false ) );
 
}
 
//------------------------------------------------------------------------------
// Override global "delete" 
//------------------------------------------------------------------------------
 
inline VOID operator delete( VOID* void_Pointer_To_Memory )
{
 
  // Deallocate memory  
  MemoryManager.dllocMemory( void_Pointer_To_Memory );
 
}
 
//------------------------------------------------------------------------------
// Override global "delete[]" 
//------------------------------------------------------------------------------
 
inline VOID operator delete[]( VOID* void_Pointer_To_Memory )
{
 
  // Deallocate memory
  MemoryManager.dllocMemory( void_Pointer_To_Memory );
  
}
 
#endif
 
//------------------------------------------------------------------------------
// End of file
//------------------------------------------------------------------------------