cinospartitionmemory.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSPARTITIONMEMORY_H
#define INC_CINOSPARTITIONMEMORY_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
//
// C++
//
// project
//
 
//------------------------------------------------------------------------------
// forwards
//------------------------------------------------------------------------------
class CINOSPartitionMemory;
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
struct SINOSPMClassInfo
{
    // pointer to next info structure in chain
    SINOSPMClassInfo* m_pNext;
    // pointer to class name
    char* m_pName;
    // actual used size of this class
    uint32* m_pSize;        
};
 
struct SBackTrace
{
    explicit SBackTrace(
        uint32 i_nCallStackDepth);
    ~SBackTrace();
    uint32  m_uCallStackDepth;
    uint32* m_pCallStack;
};
 
struct SINOSPMHeader
{
    CINOSPartitionMemory* m_pPartition;
    const char* m_pClassName;
    uintptr* m_pBackTrace;
    void* m_pOwner;
    #if defined(INOS_64)
    uint64 m_uReserved;
    #endif
 
    uint64 m_uTimeBase;
    SINOSPMHeader* m_pNext;
    SINOSPMHeader* m_pPrevious;
};
 
struct SINOSPMFooter
{
    enum { 
        eFooterPattern = 0x79811115
    };
    uint32 m_uPartitionFooterPattern;
    uint32 m_uChecksum;
};
 
struct SINOSPMHeaderNoSecure
{
    CINOSPartitionMemory* m_pPartition;
    void* m_pNext;
    uint8 m_uPadding [16 - sizeof(m_pPartition) - sizeof(m_pNext)];
};
 
static_assert(sizeof(SINOSPMHeaderNoSecure) % 16 == 0,
    "sizeof(SINOSPMHeaderNoSecure) must be a multiple of 16 bytes");
 
class CINOSMemoryPool;
class CINCOObject;
class CINOSMutex;
class CINOSPartitionMemory
{
    friend void _INI_0000_CINOSPartitionMemory();
 
        static void* OperatorNewDuringCreate(size_t auSize);
        ~CINOSPartitionMemory();
 
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        enum {
            eAllocAlignment = DF_INOS_MEMORY_ALLOC_ALIGNMENT 
        }; 
        
        // construction / destruction
 
        CINOSPartitionMemory (uint32 auSize, const char* apPoolName);
            //; create partition memory with size 'auSize' which takes memory 
            //; from pool 'apPoolName'
        static CINOSPartitionMemory* Create(uint32 auPartitionSize, 
            const char* apPoolName = 0);
            //; create new partition memory object and return pointer to it
        static CINOSPartitionMemory* Create(uint32 auPartitionSize, 
            const char* apPoolName, const char* apClass, uint32* apSize=0);
            //; create new partition memory object for apClass and return pointer to it
 
        // allocation / deallocation
 
        void* Alloc(uint32 auSize=0, const char* apClassName = s_cNoClassNameSpecified,
                bool abReturnNullOnFailure = false,
                uint32 auMinimalReserve = 0);
            //; allocate one partition and return pointer to it
        bool Free(void* apPartition, const char* apClassName = s_cNoClassNameSpecified);
            //; free partition 'apPartition'
            //; returns true if the partition was actually freed (and its UsedSize counter was decremented)
        static void* AllocGlobal(size_t auSize,
            const char* apClassName = s_cNoClassNameSpecified,
            bool abReturnNullOnFailure = false,
            size_t auMinimalReserve = 0);
            //; allocate auSize bytes for class named "apClassName". Always
            //; prefer using DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC in favor of this
            //; function because the former is faster. AllocGlobal (and it's
            //; counterpart FreeGlobal) were introduced to be used by 'operator
            //; new' and 'operator delete', in order to use the partition 
            //; memory mechanism (instead of malloc/free).
        static void FreeGlobal(void* apPartition, 
            const char* apClassName = s_cNoClassNameSpecified);
            //; Frees memory allocated by AllocGlobal
        uintnbr Available();
            //; \return Overall available partition memory [bytes]. The function
            //;  takes the overhead added by the header/footer. E.g. assume
            //;  the partition size is 8. Further assume that the available
            //;  free memory (e.g. "Heap") is 64. The value returned by this
            //;  function will not be 64 in that case, because each allocation
            //;  produces some overhead. Instead (depending on the overhead
            //;  size), the function will return something like 56 or 48.
 
        // miscelanselous
 
        CINCOObject* GetRegister();
            //; do inco registration and return pointer to it
        void GetRegisterClass(CINCOObject* apClassObj,
            const SINOSPMClassInfo* apClassInfo);
            //; add the 'class information' (apClassInfo) to the "Classes"
            //; object passed by apClassObj
 
        // get / set properties
        
        const char* GetPoolName() const { return m_pPoolName;};
            //; return pool name this partition memory belongs to
        CINOSMemoryPool* GetPool() const { return m_pPool;};
            //; get pool this partition memory belongs to
        void SetPool(CINOSMemoryPool* apPool) { m_pPool = apPool;};
            //; set pool this partition memory belongs to
        uint32 GetPartitionSize() const { return m_uPartitionSize;};
            //; return pool name this partition memory belongs to
        uint32 GetFreeCount() const { return m_uActualSize - m_uUsedSize;};
            //; return number of free blocks
        static CINOSPartitionMemory* GetFirst() { return m_pFirst;};
            //; return pointer to first partition memory
        CINOSPartitionMemory* GetNext() const { return m_pNext;};
            //; return pointer to next partition memory
        void SetBackTrace(const uint32 auBackTrace) { m_uBackTrace = auBackTrace; }
            //; set new count of backtraces
        uint32 GetBackTrace() const { return m_uBackTrace; }
            //; \return The currently configured count of backtraces
        static void CheckConsistency();
            //; check consistency of all currently free partition blocks in the system
            //; (this is just  debug helper method)
 
    //--- internals --------------------------------------------------------
 
    friend void InitHeap(void*);
 
    // protected member functions
    protected :
        uint32 CalcChecksum(SINOSPMHeader* apPartition) const;
 
    // protected members
    protected :
        const char* m_pPoolName;
            //; according memory pool name
        CINOSMemoryPool* m_pPool;
            //; pointer to parent pool
        SINOSCoreLock m_Lock;
            //; partition lock (used in multicore systems)
        uint32 m_uPartitionSize;
            //; partition size
        uint32 m_uActualSize;
            //; actual overall number of partitions this object handles
        uint32 m_uUsedSize;
            //; actual number of used partitions
        uint32 m_uChecksumSize;
            //; number of bytes to check 
        uint32 m_uBackTrace;
            //; max. backtrace depth. If set to 0, backtraces are not stored.
        void* m_pFstFree;
            //; pointer to first free memory partition 
        SINOSPMHeader* m_pLstFree;
            //; pointer to last free memory partition 
        SINOSPMHeader* m_pFstUsed;
            //; pointer to first used memory partition 
        CINCOObject* m_pRegister;
            //; pointer to inco registration
        static CINOSPartitionMemory* m_pFirst;
            //; pointer to first partition memory object in chain
        CINOSPartitionMemory* m_pNext;
            //; pointer to next partition memory object in chain
        SINOSPMClassInfo* m_pFirstCI;
            //; pointer to chain of class info
        static const char* s_cNoClassNameSpecified;
            //; default class name - in case that a class does not use secure
            //; partition memory
        static CINOSMutex s_PartitionCreationMutex;
            //; Usually, the partition are created during the startup - there,
            //; the function will not be executed by multiple threads. But under
            //; certain circumstances (e.g. the INOSHeapAlloc function) the 
            //; Create function may also be executed after 'system startup'. 
            //; Then it's important to make sure only one task at a time will
            //; 'search for' or 'create' a partition.
};
 
//
//------------------------------------------------------------------------------
//--- dynamic object handling macros -------------------------------------------
//------------------------------------------------------------------------------
 
#ifdef INOS_CACHE_LOCK_SUPPORT 
  #define INOS_CACHE "Cache"
#else
  #define INOS_CACHE 0
#endif
 
#define DECLARE_DYNAMIC(aClass)                 DECLARE_DYNAMIC_POOL(aClass,0)
 
#define DECLARE_DYNAMIC_T(aClass,aT)            DECLARE_DYNAMIC_POOL_T(aClass,aT,0)
 
#define DECLARE_DYNAMIC_T2(aClass,aT1,aT2)      DECLARE_DYNAMIC_POOL_T2(aClass,aT1,aT2,0)
 
#define DECLARE_DYNAMIC_T3(aClass,aT1,aT2,aT3)      DECLARE_DYNAMIC_POOL_T3(aClass,aT1,aT2,aT3,0)
 
#define DECLARE_DYNAMIC_T4(aClass,aT1,aT2,aT3,aT4)    DECLARE_DYNAMIC_POOL_T4(aClass,aT1,aT2,aT3,aT4,0)
 
#define DECLARE_DYNAMIC_N(aClass,aN)            DECLARE_DYNAMIC_POOL_N(aClass,aN,0)
 
#define DECLARE_DYNAMIC_N2(aClass,aN,aM)        DECLARE_DYNAMIC_POOL_N2(aClass,aN,aM,0)
 
#define DECLARE_DYNAMIC_CACHE(aClass)           DECLARE_DYNAMIC_POOL(aClass,INOS_CACHE)
 
#define DECLARE_DYNAMIC_I(aClass,aInnerClass)   DECLARE_DYNAMIC_POOL_T(aClass,aInnerClass,0)
 
#define DECLARE_DYNAMIC_PLACEMENT(aClass)       DECLARE_DYNAMIC_POOL_PLACEMENT(aClass)
 
#define DECLARE_DYNAMIC_VARIADIC(aClass)        DECLARE_DYNAMIC_POOL_VARIADIC(aClass,0)
 
#define IMPLEMENT_DYNAMIC(aClass)           IMPLEMENT_DYNAMIC_POOL(aClass,0)
 
#define IMPLEMENT_DYNAMIC_T(aClass,aT)      IMPLEMENT_DYNAMIC_POOL_T(aClass,aT,0)
 
#define IMPLEMENT_DYNAMIC_T2(aClass,aT1,aT2) IMPLEMENT_DYNAMIC_POOL_T2(aClass,aT1,aT2,0)
 
#define IMPLEMENT_DYNAMIC_T3(aClass,aT1,aT2,aT3) IMPLEMENT_DYNAMIC_POOL_T3(aClass,aT1,aT2,aT3,0)
 
#define IMPLEMENT_DYNAMIC_T_S(aClass,aT,aS)     IMPLEMENT_DYNAMIC_POOL_T_S(aClass,aT,aS,0)
 
#define IMPLEMENT_DYNAMIC_T4(aClass,aT1,aT2,aT3,aT4) IMPLEMENT_DYNAMIC_POOL_T4(aClass,aT1,aT2,aT3,aT4,0)
 
#define IMPLEMENT_DYNAMIC_N(aClass,aN)      IMPLEMENT_DYNAMIC_POOL_N(aClass,aN,0)
 
#define IMPLEMENT_DYNAMIC_N2(aClass,aN,aM)  IMPLEMENT_DYNAMIC_POOL_N2(aClass,aN,aM,0)
#define IMPLEMENT_DYNAMIC_CACHE(aClass)     IMPLEMENT_DYNAMIC_POOL(aClass,INOS_CACHE)
#define IMPLEMENT_DYNAMIC_I(aClass,aT)      IMPLEMENT_DYNAMIC_POOL_I(aClass,aT,0)
#define IMPLEMENT_DYNAMIC_PLACEMENT(aClass) IMPLEMENT_DYNAMIC_POOL_PLACEMENT(aClass)
#define IMPLEMENT_DYNAMIC_PLACEMENT_N(aClass,N) IMPLEMENT_DYNAMIC_POOL_PLACEMENT_N(aClass, N)
#define IMPLEMENT_DYNAMIC_T2_VARIADIC(aClass,aT1,aT2) IMPLEMENT_DYNAMIC_POOL_T2_VARIADIC(aClass,aT1,aT2,0)
#define IMPLEMENT_DYNAMIC_T3_VARIADIC(aClass,aT1,aT2,aT3) IMPLEMENT_DYNAMIC_POOL_T3_VARIADIC(aClass,aT1,aT2,aT3,0)
#define IMPLEMENT_DYNAMIC_T4_VARIADIC(aClass,aT1,aT2,aT3,aT4) IMPLEMENT_DYNAMIC_POOL_T4_VARIADIC(aClass,aT1,aT2,aT3,aT4,0)
 
 
#ifdef INOS_SECURE_PARTITION_MEMORY
#define DF_HANDLE_MEMPOOL_CLASSNAME_ARG(i_Arg)      \
    , i_Arg
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(aStatement) \
    aStatement
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(aStatement1, aStatement2, aStatement3) \
    aStatement1, aStatement2, aStatement3
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_4(aStatement1, aStatement2, aStatement3, aStatement4) \
    aStatement1, aStatement2, aStatement3, aStatement4
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_5(aStatement1, aStatement2, aStatement3, aStatement4, aStatement5) \
    aStatement1, aStatement2, aStatement3, aStatement4, aStatement5
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_7(aStatement1, aStatement2, aStatement3, aStatement4, aStatement5, aStatement6, aStatement7) \
    aStatement1, aStatement2, aStatement3, aStatement4, aStatement5, aStatement6, aStatement7
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_10(aStatement1, aStatement2, aStatement3, aStatement4, aStatement5, aStatement6, aStatement7, aStatement8, aStatement9, aStatement10) \
    aStatement1, aStatement2, aStatement3, aStatement4, aStatement5, aStatement6, aStatement7, aStatement8, aStatement9, aStatement10
#else
#define DF_HANDLE_MEMPOOL_CLASSNAME_ARG(i_Arg)
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(i_Statement)
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(aStatement1, aStatement2, aStatement3)
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_4(aStatement1, aStatement2, aStatement3, aStatement4)
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_5(aStatement1, aStatement2, aStatement3, aStatement4, aStatement5)
#define DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_10(aStatement1, aStatement2, aStatement3, aStatement4, aStatement5, aStatement6, aStatement7, aStatement8, aStatement9, aStatement10)
#endif
 
 
// class 
#define DECLARE_DYNAMIC_POOL(aClass,aPool)          \
    static CINOSPartitionMemory* p##aClass##Memory; \
    static uint32 u##aClass##Memory;                \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##Name;)  \
    public:                                         \
    void* operator new(size_t aSize);               \
    void operator delete(void* aPtr);
 
#define IMPLEMENT_DYNAMIC_POOL(aClass,aPool)                        \
    CINOSPartitionMemory* aClass::p##aClass##Memory =               \
        CINOSPartitionMemory::Create(sizeof(aClass),aPool,#aClass,&aClass::u##aClass##Memory);  \
    uint32 aClass::u##aClass##Memory = 0;                           \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(const char* aClass::s##aClass##Name = #aClass;)       \
    void* aClass::operator new(size_t aSize)                        \
        {                                                           \
            INOS_ADD(aClass::u##aClass##Memory, 1);                 \
            return p##aClass##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##Name));\
        }                                                           \
    void aClass::operator delete(void* aPtr)                        \
        {                                                           \
            bool bFreed = p##aClass##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##Name));           \
            if(bFreed) INOS_ADD(aClass::u##aClass##Memory, -1);     \
        }
 
// class
#define DECLARE_DYNAMIC_POOL_PLACEMENT(aClass)          \
    public:                                             \
    void* operator new(size_t aSize, void*);
 
#define IMPLEMENT_DYNAMIC_POOL_PLACEMENT(aClass)                    \
    void* aClass::operator new(size_t aSize, void* aAddress)        \
        {                                                           \
            return aAddress;                                        \
        }
#define IMPLEMENT_DYNAMIC_POOL_PLACEMENT_N(aClass,N)                \
        template< int aN> void* aClass< aN >::operator new(size_t aSize, void* aAddress)\
        {                                                           \
            return aAddress;                                        \
        }
 
 
// template class
#define DECLARE_DYNAMIC_POOL_T(aClass, aT, aPool )      \
    static CINOSPartitionMemory* p##aClass##aT##Memory; \
    static uint32 u##aClass##aT##Memory;                \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT##Name;)  \
    public:                                             \
    void* operator new(size_t aSize)                    \
        {                                               \
            INOS_ADD_(u##aClass##aT##Memory, 1);        \
            return p##aClass##aT##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT##Name));    \
        }                                               \
    void operator delete(void* aPtr)                    \
        {                                               \
            bool bFreed = p##aClass##aT##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT##Name));           \
            if(bFreed) INOS_ADD_(u##aClass##aT##Memory, -1);        \
        }
 
#define IMPLEMENT_DYNAMIC_POOL_T(aClass, aT, aPool)                                 \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(template< class aT > const char* aClass< aT >::s##aClass##aT##Name = #aClass#aT;)     \
    template< class aT > CINOSPartitionMemory* aClass< aT >::p##aClass##aT##Memory =\
        CINOSPartitionMemory::Create(sizeof(aClass< aT >),aPool,#aClass#aT,&aClass< aT >::u##aClass##aT##Memory);       \
    template< class aT > uint32 aClass< aT >::u##aClass##aT##Memory = 0;
 
#define IMPLEMENT_DYNAMIC_POOL_T_S(aClass, aT, aS, aPool)                                   \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(const char* aClass< aS >::s##aClass##aT##Name = #aClass#aS;)      \
    CINOSPartitionMemory* aClass< aS >::p##aClass##aT##Memory =\
        CINOSPartitionMemory::Create(sizeof(aClass< aS >),aPool,#aClass#aS,&aClass< aS >::u##aClass##aT##Memory);       \
    uint32 aClass< aS >::u##aClass##aT##Memory = 0;
 
// template class (two template args)
#define DECLARE_DYNAMIC_POOL_T2(aClass, aT1, aT2, aPool )       \
    static CINOSPartitionMemory* p##aClass##aT1##aT2##Memory;   \
    static uint32 u##aClass##aT1##aT2##Memory;                  \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT1##aT2##Name;)    \
    public:                                                     \
    void* operator new(size_t aSize)                            \
        {                                                       \
            INOS_ADD_(u##aClass##aT1##aT2##Memory, 1);          \
            return p##aClass##aT1##aT2##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##Name));    \
        }                                                       \
    void operator delete(void* aPtr)                            \
        {                                                       \
            bool bFreed = p##aClass##aT1##aT2##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##Name));           \
            if(bFreed) INOS_ADD_(u##aClass##aT1##aT2##Memory, -1);          \
        }
 
#define IMPLEMENT_DYNAMIC_POOL_T2(aClass, aT1, aT2, aPool)                                                  \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(template< class aT1, class aT2 > const char* aClass< aT1, aT2 >::s##aClass##aT1##aT2##Name = #aClass#aT1#aT2;)      \
    template< class aT1, class aT2 > CINOSPartitionMemory* aClass< aT1, aT2 >::p##aClass##aT1##aT2##Memory =\
        CINOSPartitionMemory::Create(sizeof(aClass< aT1, aT2 >),aPool,#aClass#aT1#aT2,&aClass< aT1, aT2 >::u##aClass##aT1##aT2##Memory);                        \
    template< class aT1, class aT2 > uint32 aClass< aT1, aT2 >::u##aClass##aT1##aT2##Memory = 0;
 
 
// template class (three template args)
#define DECLARE_DYNAMIC_POOL_T3(aClass, aT1, aT2, aT3, aPool )      \
    static CINOSPartitionMemory* p##aClass##aT1##aT2##aT3##Memory;  \
    static uint32 u##aClass##aT1##aT2##aT3##Memory;                 \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT1##aT2##aT3##Name;)   \
    public:                                                     \
    void* operator new(size_t aSize)                            \
        {                                                       \
            INOS_ADD_(u##aClass##aT1##aT2##aT3##Memory, 1);         \
            return p##aClass##aT1##aT2##aT3##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##Name));  \
        }                                                       \
    void operator delete(void* aPtr)                            \
        {                                                       \
            bool bFreed = p##aClass##aT1##aT2##aT3##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##Name));         \
            if(bFreed) INOS_ADD_(u##aClass##aT1##aT2##aT3##Memory, -1);         \
        }
 
#define IMPLEMENT_DYNAMIC_POOL_T3(aClass, aT1, aT2, aT3, aPool)                                                 \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_5(template< class aT1, class aT2, class aT3 > const char* aClass< aT1, aT2, aT3 >::s##aClass##aT1##aT2##aT3##Name = #aClass#aT1#aT2#aT3;)     \
    template< class aT1, class aT2, class aT3 > CINOSPartitionMemory* aClass< aT1, aT2, aT3 >::p##aClass##aT1##aT2##aT3##Memory =\
        CINOSPartitionMemory::Create(sizeof(aClass< aT1, aT2, aT3 >),aPool,#aClass#aT1#aT2#aT3,&aClass< aT1, aT2, aT3 >::u##aClass##aT1##aT2##aT3##Memory);                     \
    template< class aT1, class aT2, class aT3 > uint32 aClass< aT1, aT2, aT3 >::u##aClass##aT1##aT2##aT3##Memory = 0;
 
 
// template class (four template args)
#define DECLARE_DYNAMIC_POOL_T4(aClass, aT1, aT2, aT3, aT4, aPool )    \
  static CINOSPartitionMemory* p##aClass##aT1##aT2##aT3##aT4##Memory;  \
  static uint32 u##aClass##aT1##aT2##aT3##aT4##Memory;         \
  DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aT1##aT2##aT3##aT4##Name;) \
  public:                           \
  void* operator new(size_t aSize)              \
    {                           \
      INOS_ADD_(u##aClass##aT1##aT2##aT3##aT4##Memory, 1);     \
      return p##aClass##aT1##aT2##aT3##aT4##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##aT4##Name));  \
    }                           \
  void operator delete(void* aPtr)              \
    {                           \
      bool bFreed = p##aClass##aT1##aT2##aT3##aT4##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aT1##aT2##aT3##aT4##Name));     \
      if(bFreed) INOS_ADD_(u##aClass##aT1##aT2##aT3##aT4##Memory, -1);     \
    }
 
#define IMPLEMENT_DYNAMIC_POOL_T4(aClass, aT1, aT2, aT3, aT4, aPool)                         \
  DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_7(template< class aT1, class aT2, class aT3, class aT4 > const char* aClass< aT1, aT2, aT3, aT4 >::s##aClass##aT1##aT2##aT3##aT4##Name = #aClass#aT1#aT2#aT3#aT4;)   \
  template< class aT1, class aT2, class aT3, class aT4 > CINOSPartitionMemory* aClass< aT1, aT2, aT3, aT4 >::p##aClass##aT1##aT2##aT3##aT4##Memory =\
    CINOSPartitionMemory::Create(sizeof(aClass< aT1, aT2, aT3, aT4 >),aPool,#aClass#aT1#aT2#aT3#aT4,&aClass< aT1, aT2, aT3, aT4 >::u##aClass##aT1##aT2##aT3##aT4##Memory);           \
  template< class aT1, class aT2, class aT3, class aT4 > uint32 aClass< aT1, aT2, aT3, aT4 >::u##aClass##aT1##aT2##aT3##aT4##Memory = 0;
 
// template class (one integer argument)
#define DECLARE_DYNAMIC_POOL_N(aClass, aN, aPool )          \
    static CINOSPartitionMemory* p##aClass##aN##Memory;     \
    static uint32 u##aClass##aN##Memory;                    \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aN##Name;)\
    public:                                                 \
    void* operator new(size_t aSize)                        \
        {                                                   \
            INOS_ADD_(u##aClass##aN##Memory, 1);            \
            return p##aClass##aN##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##Name));\
        }                                                   \
    void operator delete(void* aPtr)                        \
        {                                                   \
            bool bFreed = p##aClass##aN##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##Name));\
            if(bFreed) INOS_ADD_(u##aClass##aN##Memory, -1);    \
        }
#define IMPLEMENT_DYNAMIC_POOL_N(aClass, aN, aPool)                                 \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(template< int aN> const char* aClass< aN >::s##aClass##aN##Name = #aClass#aN;)    \
    template< int aN> CINOSPartitionMemory* aClass< aN >::p##aClass##aN##Memory =   \
        CINOSPartitionMemory::Create(sizeof(aClass< aN >),aPool,#aClass#aN,&aClass< aN >::u##aClass##aN##Memory);\
    template< int aN> uint32 aClass< aN >::u##aClass##aN##Memory = 0;
 
// template class (two integer argument)
#define DECLARE_DYNAMIC_POOL_N2(aClass, aN, aM, aPool )         \
    static CINOSPartitionMemory* p##aClass##aN##aM##Memory;     \
    static uint32 u##aClass##aN##aM##Memory;                    \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(static const char* s##aClass##aN##aM##Name;)\
    public:                                                     \
    void* operator new(size_t aSize)                            \
        {                                                       \
            INOS_ADD_(u##aClass##aN##aM##Memory, 1);            \
            return p##aClass##aN##aM##Memory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##aM##Name));\
        }                                                       \
    void operator delete(void* aPtr)                            \
        {                                                       \
            bool bFreed = p##aClass##aN##aM##Memory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(s##aClass##aN##aM##Name));\
            if(bFreed) INOS_ADD_(u##aClass##aN##aM##Memory, -1);    \
        }
#define IMPLEMENT_DYNAMIC_POOL_N2(aClass, aN, aM, aPool)                                                                                        \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(template< int aN, int aM > const char* aClass< aN, aM >::s##aClass##aN##aM##Name = #aClass#aN#aM;)  \
    template< int aN, int aM > CINOSPartitionMemory* aClass< aN, aM >::p##aClass##aN##aM##Memory =                                              \
        CINOSPartitionMemory::Create(sizeof(aClass< aN, aM >),aPool,#aClass#aN#aM,&aClass< aN, aM >::u##aClass##aN##aM##Memory);                \
    template< int aN, int aM > uint32 aClass< aN, aM >::u##aClass##aN##aM##Memory = 0;
 
#define IMPLEMENT_DYNAMIC_POOL_I(aClass, aInnerClass, aPool)                                    \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY(const char* aClass::aInnerClass::s##aClass##aInnerClass##Name = #aClass#aInnerClass;)     \
    CINOSPartitionMemory* aClass::aInnerClass::p##aClass##aInnerClass##Memory =\
        CINOSPartitionMemory::Create(sizeof(aClass::aInnerClass),aPool,#aClass#aInnerClass,&aClass::aInnerClass::u##aClass##aInnerClass##Memory);       \
    uint32 aClass::aInnerClass::u##aClass##aInnerClass##Memory = 0;
 
#define DECLARE_DYNAMIC_POOL_VARIADIC(aClass, aPool )                               \
    static CINOSPartitionMemory* pMemory;                                           \
    static uint32 uMemory;                                                          \
    static const char* sName;                                                       \
    public:                                                                         \
    void* operator new(size_t aSize);                                               \
    void operator delete(void* aPtr);
 
#define IMPLEMENT_DYNAMIC_POOL_T4_VARIADIC(aClass, aT1, aT2, aT3, aT4, aPool)                           \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_7(                                                            \
    template< class aT1, class aT2, class aT3, class ... aT4 >                                          \
        const char* aClass< aT1, aT2, aT3, aT4 ... >::sName = #aClass"<"#aT1"_"#aT2"_"#aT3"_"#aT4">";)  \
    template< class aT1, class aT2, class aT3, class ... aT4>                                           \
        CINOSPartitionMemory* aClass< aT1, aT2, aT3, aT4 ... >::pMemory =                               \
        CINOSPartitionMemory::Create(                                                                   \
                sizeof(aClass< aT1, aT2, aT3, aT4 ... >),aPool,#aClass"<"#aT1"_"#aT2"_"#aT3"_"#aT4">",  \
                &aClass< aT1, aT2, aT3, aT4 ... >::uMemory);                                            \
    template< class aT1, class aT2, class aT3, class ... aT4>                                           \
        uint32 aClass< aT1, aT2, aT3, aT4 ... >::uMemory = 0;                                           \
    template< class aT1, class aT2, class aT3, class ... aT4>                                           \
    void* aClass< aT1, aT2, aT3, aT4 ... >::operator new(size_t aSize) {                                \
            INOS_ADD_(uMemory, 1);                                                                      \
            return pMemory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName));                        \
        }                                                                                               \
    template< class aT1, class aT2, class aT3, class ... aT4>                                           \
    void aClass< aT1, aT2, aT3, aT4 ... >::operator delete(void* aPtr) {                                \
            bool bFreed = pMemory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName));                                   \
            if(bFreed) INOS_ADD_(uMemory, -1);                                                          \
        }
 
 
#define IMPLEMENT_DYNAMIC_POOL_T3_VARIADIC(aClass, aT1, aT2, aT3, aPool)                    \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_5(                                                \
    template< class aT1, class aT2, class ... aT3 >                                         \
        const char* aClass< aT1, aT2, aT3 ... >::sName = #aClass"<"#aT1"_"#aT2"_"#aT3">";)  \
    template< class aT1, class aT2, class ... aT3>                                          \
        CINOSPartitionMemory* aClass< aT1, aT2, aT3 ... >::pMemory =                        \
        CINOSPartitionMemory::Create(                                                       \
                sizeof(aClass< aT1, aT2, aT3 ... >),aPool,#aClass"<"#aT1"_"#aT2"_"#aT3">",  \
                &aClass< aT1, aT2, aT3 ... >::uMemory);                                     \
    template< class aT1, class aT2, class ... aT3>                                          \
        uint32 aClass< aT1, aT2, aT3 ... >::uMemory = 0;                                    \
    template< class aT1, class aT2, class ... aT3>                                          \
    void* aClass< aT1, aT2, aT3 ... >::operator new(size_t aSize) {                         \
            INOS_ADD_(uMemory, 1);                                                          \
            return pMemory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName));            \
        }                                                                                   \
    template< class aT1, class aT2, class ... aT3>                                          \
    void aClass< aT1, aT2, aT3 ... >::operator delete(void* aPtr) {                         \
            bool bFreed = pMemory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName));       \
            if(bFreed) INOS_ADD_(uMemory, -1);                                              \
        }
 
 
#define IMPLEMENT_DYNAMIC_POOL_T2_VARIADIC(aClass, aT1, aT2, aPool)                 \
    DF_HIDE_IF_NO_SECURE_PARTITION_MEMORY_3(                                        \
    template< class aT1, class ... aT2 >                                            \
        const char* aClass< aT1, aT2 ... >::sName = #aClass"<"#aT1"_"#aT2">";)      \
    template< class aT1, class ... aT2>                                             \
        CINOSPartitionMemory* aClass< aT1, aT2 ... >::pMemory =                     \
        CINOSPartitionMemory::Create(                                               \
                sizeof(aClass< aT1, aT2 ... >),aPool,#aClass"<"#aT1"_"#aT2">",      \
                &aClass< aT1, aT2 ... >::uMemory);                                  \
    template< class aT1, class ... aT2> uint32 aClass< aT1, aT2 ... >::uMemory = 0; \
    template< class aT1, class ... aT2>                                             \
    void* aClass< aT1, aT2 ... >::operator new(size_t aSize) {                      \
            INOS_ADD_(uMemory, 1);                                                  \
            return pMemory->Alloc((uint32)aSize DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName));    \
        }                                                                           \
    template< class aT1, class ... aT2>                                             \
    void aClass< aT1, aT2 ... >::operator delete(void* aPtr) {                      \
            bool bFreed = pMemory->Free(aPtr DF_HANDLE_MEMPOOL_CLASSNAME_ARG(sName));               \
            if(bFreed) INOS_ADD_(uMemory, -1);                                      \
        }
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSPARTITIONMEMORY_H