gzMemory.h

Go to the documentation of this file.

//******************************************************************************
// File         : gzMemory.h
// Module       : gzBase
// Description  : Class definition of memory allocation utilities
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980915  Created file    
//
//******************************************************************************

#ifndef __GZ_MEMORY_H__
#define __GZ_MEMORY_H__

#include "gzBasicTypes.h"
#include "gzArgument.h"

//-------------------------- turn of mem debug for this header -------------------

#ifdef GZ_MEM_DEBUG
#undef new
#undef gz_malloc
#endif

//******************************************************************************
// Class    : gzMemoryManagerInterface
//                                  
// Purpose  : Memory manager interface
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980819  Created 
//                                  
//******************************************************************************
class gzMemoryManagerInterface
{
public:

    GZ_BASE_EXPORT virtual gzVoid *malloc(size_t size)=0;
    GZ_BASE_EXPORT virtual gzVoid *calloc(size_t num,size_t size)=0;
    GZ_BASE_EXPORT virtual gzVoid free(gzVoid *address)=0;
    GZ_BASE_EXPORT virtual gzVoid *realloc(gzVoid *address,size_t size)=0;
};

//******************************************************************************
// Struct   : gzMemInfoItem
//                                  
// Purpose  : Hold memory allocation info
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  031120  Created 
//                                  
//******************************************************************************
struct gzMemInfoItem
{
    gzMemPointer    address;
    gzMemSize       size;
    char            *info;
    gzULong         pid;
    gzULong         counter;
    gzULong         state;
};


const gzULong GZ_MEM_DEFAULT_STATE = 1;

//******************************************************************************
// Class    : gzSharedMemory
//                                  
// Purpose  : Memory allocator from one shared pool
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980819  Created 
//                                  
//******************************************************************************

class GZ_BASE_EXPORT gzSharedMemory 
{
public:

#ifndef GZ_DISABLE_MEMORY_NEW_HANDLER

    void * operator new(size_t size) GZ_THROW_BAD_ALLOC;
    void * operator new(size_t size, void* placement) { return placement; }

    void operator delete(void *address);
    void operator delete(void *address, void* placement) {}

#ifndef GZ_NO_DEBUG_MEM

    void * operator new(size_t size,const char *info) GZ_THROW_BAD_ALLOC;

    void operator delete(void *address,const char *info);

#endif // GZ_NO_DEBUG_MEM

#ifdef GZ_ADVANCED_MEM  // Newer compilers

    void * operator new[](size_t size) GZ_THROW_BAD_ALLOC;

    void operator delete[](void *address);

#ifndef GZ_NO_DEBUG_MEM

    void * operator new[](size_t size,const char *info) GZ_THROW_BAD_ALLOC;

    void operator delete[](void *address,const char *info);

#endif // GZ_NO_DEBUG_MEM

#endif // GZ_ADVANCED_MEM

#endif // GZ_DISABLE_MEMORY_NEW_HANDLER

};

#define GIZMO_INTERNAL_MEM_STATE    (99999)

class GZ_BASE_EXPORT gzMemoryControl
{
public:


    static gzVoid   traceAlloc(gzBool on);

    static gzVoid   debugMem(gzBool on);


    static gzVoid   dumpAllocMem(gzULong state=0,gzULong pid=0,gzBool dumpInternalGizmoMem=FALSE);


    static gzULong  updateState(gzULong state=0,gzULong pid=0);

    static gzULong  getState(gzULong pid=0);

    static gzULongLong  getAllocMem(gzULong state=0,gzULong pid=0);

    static gzVoid   cleanAllocMem();

    static gzVoid   useFormatOutput(gzBool on);

    static gzVoid   memprintf(const char *fmt , ARG_DECL_LIST );

    static gzVoid   setMemoryManager(gzMemoryManagerInterface *manager);

    static inline gzMemoryManagerInterface *getMemoryManagerInterface() { return s_currentMemoryManager; }

    static gzULong getMemInfo(gzMemInfoItem *buffer,gzULong maxBufferItems);

private:

    static gzMemoryManagerInterface *s_currentMemoryManager;
};

#define PUSH_INTERNAL_MEM_STATE(x)  gzULong state_##x=gzMemoryControl::updateState(GIZMO_INTERNAL_MEM_STATE)
#define POP_INTERNAL_MEM_STATE(x)   gzMemoryControl::updateState(state_##x)

//************** Memory  Allocation utilities **********************************

extern "C"  // C functions
{
GZ_BASE_EXPORT gzVoid *gz_malloc(size_t size);
GZ_BASE_EXPORT gzVoid *gz_calloc(size_t size);
GZ_BASE_EXPORT gzVoid gz_free(gzVoid *address);
}

GZ_BASE_EXPORT gzVoid *gz_malloc(size_t size,const char *info);
GZ_BASE_EXPORT gzVoid *gz_calloc(size_t size,const char *info);

//******************************************************************************
// Class    : gzMemoryCheck
//                                  
// Purpose  : Checks to see if memeory is valid (allocated)
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010720  Created 
//                                  
//******************************************************************************
class GZ_BASE_EXPORT gzMemoryCheck 
{
public:

    gzMemoryCheck();

    virtual ~gzMemoryCheck();

    gzBool isValidMemory();

private:

    gzULong m_isValid;
};


class gzMutex;  // Forward decl
class gzString; // The same

//******************************************************************************
// Function : gzMemOptimizer
//                                  
// Purpose  : Generic accelleration of memory allocations
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  011204  Created release 
//                                  
//******************************************************************************
class GZ_BASE_EXPORT gzMemOptimizer
{
public:
    gzMemOptimizer(gzULong slots , gzULong byteSize,const char *name=NULL,gzBool enable=FALSE);
    
    virtual ~gzMemOptimizer();

    gzBool tryResize(gzULong slots);
    
    gzVoid *malloc(size_t size);
    
    gzVoid free(gzVoid *adress);
    
    gzBool isManaged(gzVoid *adress);
    
    gzVoid disable(gzBool force=FALSE);
    
    gzVoid enable();

    gzVoid setReportPercentage(gzULong perc=10);
    
private:

    gzVoid enable_unsafe();

    gzUByte         *m_pMemOptimArray;

    gzMemPointer    *m_pMemOptimFreeStackIndex;

    gzULong         m_isInitialized;

    gzULong         m_stackPos;

    gzMutex         *m_locker;

    gzULong         m_byteSize;

    gzULong         m_slots;

    gzMemPointer    m_pOptimMemEnd;

    gzString        *m_name;

    gzULong         m_allocCount;

    gzULong         m_lastPerc;

    gzULong         m_repPerc;
};


//****************** MemBase custom allocations *********************************

#ifndef GZ_MEM_DEBUG    // In mem debug we don't want allocations to be private

#define GZ_MEMBASE(className) gzMemBaseAlloc_##className

#define GZ_MEMBASE_IMP(className)   void * operator new(size_t size) GZ_THROW_BAD_ALLOC \
{                                                                                       \
    return s_allocator_##className.malloc(size);                                        \
}                                                                                       \
                                                                                        \
void operator delete(void *address)                                                     \
{                                                                                       \
    s_allocator_##className.free(address);                                              \
}


#define GZ_DECLARE_MEMBASE(className) class GZ_MEMBASE(className)           \
{                                                                           \
public:                                                                     \
    GZ_MEMBASE_IMP(className)                                               \
    static gzMemOptimizer   s_allocator_##className;                        \
};

#define GZ_DECLARE_MEMBASE_EXPORT(className,export) class GZ_MEMBASE(className)     \
{                                                                                   \
public:                                                                             \
    GZ_MEMBASE_IMP(className)                                                       \
    export static gzMemOptimizer    s_allocator_##className;                        \
};

#define GZ_DECLARE_MEMBASE_IMP(className,size) gzMemOptimizer GZ_MEMBASE(className)::s_allocator_##className(size,sizeof(className),#className,TRUE)

#else // GZ_MEM_DEBUG - no active allocators

class gzDummyMem {}; // Empty class as base to MEMBASE

#define GZ_MEMBASE(className) gzDummyMem
#define GZ_MEMBASE_IMP(className) 
#define GZ_DECLARE_MEMBASE(className)
#define GZ_DECLARE_MEMBASE_EXPORT(className,export)
#define GZ_DECLARE_MEMBASE_IMP(className,size) 

#endif // GZ_MEM_DEBUG

//--------------------- redefine memory debug info -----------------

#ifdef GZ_MEM_DEBUG
#ifndef GZ_NO_DEBUG_MEM
#define new new (GZ_DEBUG_INFO(GZ_VERSION_STR))
#define gz_malloc(arg) gz_malloc(arg,GZ_DEBUG_INFO(GZ_VERSION_STR))
#endif
#endif

#endif

---