cHeap.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cHeap_H
#define _INC_cHeap_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cMem.h"
#include "cDebugAssert.h"
#include "cUnitTestDecl.h"
 
// #define USE_HEAP_STATS               // Debug total allocation stats.
 
namespace Gray
{
        struct GRAYCORE_LINK cHeap      // static class
        {
 
                enum FILL_TYPE
                {
                        FILL_AllocStack = 0xCC, 
                        FILL_Alloc = 0xCD,      
                        FILL_Freed = 0xDD,      
 
#if (_MSC_VER<1400)
                        FILL_AlignTail = 0xBD,  
#else
                        FILL_AlignTail = 0xED,  
#endif
                        FILL_UnusedStack = 0xFE,        
                        FILL_Prefix = 0xFD,     
                };
 
                static const size_t k_ALLOC_MAX = 0x1000000; 
 
                static ITERATE_t sm_nAllocs;            
#ifdef USE_HEAP_STATS
                static size_t sm_nAllocTotalBytes;      
#endif
 
                static UINT64 GRAYCALL get_PhysTotal();         // For process/machine
                static UINT64 GRAYCALL get_PhysAvail();
 
                static void GRAYCALL Init(int nFlags = 0);
                static bool GRAYCALL Check();
                static size_t GRAYCALL GetSize(const void* pData) noexcept;
                static bool GRAYCALL IsValidHeap(const void* pData) noexcept;
 
                static inline bool IsCorruptHeap(const void* pData) noexcept
                {
                        if (pData == nullptr)   // nullptr is not corrupt.
                                return false;
                        return !IsValidHeap(pData);
                }
                static bool GRAYCALL IsValidInside(const void* pData, ptrdiff_t index) noexcept;
 
                static void* GRAYCALL AllocPtr(size_t nSize);
 
                static inline void* AllocPtr(size_t nSize, const void* pDataInit)
                {
                        void* pData = AllocPtr(nSize);
                        if (pData != nullptr && pDataInit != nullptr)
                        {
                                cMem::Copy(pData, pDataInit, nSize);
                        }
                        return pData;
                }
                static void GRAYCALL FreePtr(void* pData);
                static void* GRAYCALL ReAllocPtr(void* pData, size_t nSize);
 
                UNITTEST_FRIEND(cHeap);
        };
 
        struct GRAYCORE_LINK cHeapAlign : public cHeap  // static
        {
                typedef cHeap SUPER_t;
 
#if defined(_MSC_VER) && (_MSC_VER >= 1300)
                static const size_t k_SizeGap = 4;
                static const size_t k_SizeAlignMax = 128;       // max reasonable size for alignment.
 
                struct CATTR_PACKED cHeapHeader
                {
                        void* m_pMallocHead;    // pointer back to the returned malloc() memory. may point at self !
#ifdef _DEBUG
                        BYTE m_TailGap[k_SizeGap];      
#endif
                                                                                // ASSUME memory block follows this
                };
 
                static const cHeapHeader* GRAYCALL GetHeader(const void* pData) noexcept;
 
                static bool GRAYCALL IsAlignedAlloc(const void* pData, size_t iAligned) noexcept;
                static bool GRAYCALL IsValidHeap(const void* pData) noexcept;
                static size_t GRAYCALL GetSize(const void* pData) noexcept;
                static bool GRAYCALL IsValidInside(const void* pData, INT_PTR index) noexcept;
 
                static void* GRAYCALL AllocPtr(size_t nSize, size_t iAligned);
                static void GRAYCALL FreePtr(void* pData);
 
#else
                // stub these out.
                static inline bool IsAlignedAlloc(const void* pData, size_t iAligned) noexcept
                {
                        return false;
                }
                static inline bool IsValidHeap(const void* pData) noexcept
                {
                        return SUPER_t::IsValidHeap(pData);
                }
                static inline size_t GetSize(const void* pData) noexcept
                {
                        return SUPER_t::GetSize(pData);
                }
                static inline bool IsValidInside(const void* pData, INT_PTR index) noexcept
                {
                        return SUPER_t::IsValidInside(pData, index);
                }
 
                static inline void* AllocPtr(size_t nSize, size_t iAligned)
                {
                        return SUPER_t::AllocPtr(nSize);
                }
                static inline void FreePtr(void* pData)
                {
                        return SUPER_t::FreePtr(pData);
                }
 
#endif // _MSC_VER
        };
 
        class GRAYCORE_LINK cHeapBlock : public cMemBlock
        {
                typedef cHeapBlock THIS_t;
                typedef cMemBlock SUPER_t;
 
        private:
                explicit cHeapBlock(void* pData)
                {
                        UNREFERENCED_PARAMETER(pData);
                        ASSERT(0);
                }
 
        public:
                cHeapBlock() noexcept
                {
                        DEBUG_CHECK(m_pData == nullptr);
                        DEBUG_CHECK(m_nSize == 0);
                }
                cHeapBlock(const THIS_t& ref)
                {
                        Alloc(ref.m_pData, ref.m_nSize);
                }
                cHeapBlock(THIS_t&& ref) noexcept
                {
                        m_pData = ref.m_pData; ref.m_pData = nullptr;
                        m_nSize = ref.m_nSize; ref.m_nSize = 0;
                }
                explicit cHeapBlock(size_t nSize)
                {
                        Alloc(nSize);
                }
                cHeapBlock(const void* pDataCopy, size_t nSize)
                {
                        Alloc(pDataCopy, nSize);
                }
                ~cHeapBlock()
                {
                        cHeap::FreePtr(m_pData);        // nullptr is OK/Safe here.
                }
 
                THIS_t& operator = (const THIS_t& ref)
                {
                        Alloc(ref.m_pData, ref.get_DataSize());
                        return *this;
                }
                THIS_t& operator = (THIS_t&& ref)
                {
                        m_pData = ref.m_pData; ref.m_pData = nullptr;
                        m_nSize = ref.m_nSize; ref.m_nSize = 0;
                        return *this;
                }
 
                bool isValidRead() const noexcept
                {
                        return cHeap::IsValidHeap(m_pData);
                }
                bool isCorrupt() const noexcept
                {
                        return cHeap::IsCorruptHeap(m_pData);
                }
 
                size_t get_AllocSize() const
                {
                        ASSERT(!isCorrupt());
                        return cHeap::GetSize(m_pData);
                }
                size_t GetHeapStats(OUT ITERATE_t& iAllocCount) const
                {
                        if (!isValidPtr())
                                return 0;
                        iAllocCount++;  // count total allocations used.
                        return get_AllocSize();
                }
                void Free()
                {
                        if (!isValidPtr())
                                return;
                        cHeap::FreePtr(m_pData);
                        SetEmptyBlock();
                }
                void FreeSecure()
                {
                        if (!isValidPtr())
                                return;
                        cMem::ZeroSecure(m_pData, get_DataSize());
                        cHeap::FreePtr(m_pData);
                        SetEmptyBlock();        // m_pData = nullptr
                }
 
                void SetHeapBlock(void* pData, size_t nSize)
                {
                        m_pData = pData;
                        m_nSize = nSize;
                }
                void DetachHeapBlock()
                {
                        SetEmptyBlock();
                }
                bool Alloc(size_t nSize)
                {
                        cHeap::FreePtr(m_pData);
                        if (nSize == 0)
                        {
                                m_pData = nullptr;
                        }
                        else
                        {
                                m_pData = cHeap::AllocPtr(nSize);
                                if (!isValidPtr())              // nSize = 0 may be nullptr or not?
                                {
                                        return false;   // FAILED HRESULT_WIN32_C(ERROR_NOT_ENOUGH_MEMORY)
                                }
                        }
                        m_nSize = nSize;
                        return true;    // nullptr is OK for size = 0
                }
                bool Alloc(const void* pData, size_t nSize)
                {
 
                        ASSERT(pData == nullptr || !this->IsValidPtr(pData));   // NOT from myself ! // Check before Alloc
                        if (!Alloc(nSize))
                        {
                                return false;   // FAILED HRESULT_WIN32_C(ERROR_NOT_ENOUGH_MEMORY)
                        }
                        if (pData != nullptr)
                        {
                                cMem::Copy(m_pData, pData, nSize);
                        }
                        return true;
                }
                bool ReAlloc(size_t nSize)
                {
                        if (nSize != m_nSize)
                        {
                                m_pData = cHeap::ReAllocPtr(m_pData, nSize);
                                if (nSize > 0 && !isValidPtr())
                                {
                                        return false;   // FAILED HRESULT_WIN32_C(ERROR_NOT_ENOUGH_MEMORY)
                                }
                                m_nSize = nSize;
                        }
                        return true;
                }
                bool ReAlloc(const void* pData, size_t nSize)
                {
                        ASSERT(pData == nullptr || !this->IsValidPtr(pData));   // NOT from myself ! // Check before Alloc
                        if (!ReAlloc(nSize))
                        {
                                return false;   // FAILED HRESULT_WIN32_C(ERROR_NOT_ENOUGH_MEMORY)
                        }
                        if (pData != nullptr)
                        {
                                cMem::Copy(m_pData, pData, nSize);
                        }
                        return true;
                }
 
                bool ReAllocLazy(size_t iSizeNew)
                {
                        if (iSizeNew > m_nSize && iSizeNew > get_AllocSize())
                        {
                                if (!ReAlloc(iSizeNew))
                                        return false;
                        }
                        m_nSize = iSizeNew;
                        return true;
                }
 
                bool SetCopy(const cHeapBlock& rSrc)
                {
                        if (&rSrc == this)
                                return true;
                        return Alloc(rSrc.get_Data(), rSrc.get_DataSize());
                }
 
                void* get_Data() const noexcept
                {
#ifdef _DEBUG
                        DEBUG_CHECK(!isCorrupt());
#endif
                        return m_pData; 
                }
                inline BYTE* get_DataBytes() const noexcept
                {
                        return (BYTE*)get_Data();
                }
                inline char* get_DataA() const noexcept
                {
                        return (char*)get_Data();
                }
                inline wchar_t* get_DataW() const noexcept
                {
                        return (wchar_t*)get_Data();
                }
 
                operator void* () const noexcept
                {
                        return get_Data();
                }
                operator BYTE* () const noexcept
                {
                        return get_DataBytes(); // for use with []
                }
                operator char* () const noexcept
                {
                        return get_DataA();     // for use with []
                }
        };
}
 
#endif  // _INC_cHeap_H