win32memoryconfig.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
#include "core/config.h"
#include "core/debug.h"
 
namespace Memory
{
 
//------------------------------------------------------------------------------
enum HeapType
{
    DefaultHeap = 0,            // for stuff that doesn't fit into any category
    ObjectHeap,                 // heap for global new allocator
    ObjectArrayHeap,            // heap for global new[] allocator
    ResourceHeap,               // heap for resource data (like animation buffers)
    ScratchHeap,                // for short-lived scratch memory (encode/decode buffers, etc...)
    StringDataHeap,             // special heap for string data
    StreamDataHeap,             // special heap for stream data like memory streams, zip file streams, etc...
    PhysicsHeap,                // physics engine allocations go here
    AppHeap,                    // for general Application layer stuff
    NetworkHeap,                // for network layer
    ScriptingHeap,              // for scripting layers
    
    NumHeapTypes,
    InvalidHeapType,
};
 
//------------------------------------------------------------------------------
extern HANDLE volatile Heaps[NumHeapTypes];
 
//------------------------------------------------------------------------------
extern void SetupHeaps();
 
//------------------------------------------------------------------------------
extern const char* GetHeapTypeName(HeapType heapType);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
__forceinline unsigned char*
__HeapAlignPointerAndWritePadding16(unsigned char* ptr)
{
    unsigned char paddingMask = size_t(ptr) & 15;
    ptr = (unsigned char*)(size_t(ptr + 16) & ~15);
    ptr[-1] = paddingMask;
    return ptr;
}
 
//------------------------------------------------------------------------------
__forceinline unsigned char*
__HeapUnalignPointer16(unsigned char* ptr)
{
    return (unsigned char*)(size_t(ptr - 16) | ptr[-1]);
}
 
//------------------------------------------------------------------------------
__forceinline LPVOID 
__HeapAlloc16(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes)
{
    unsigned char* ptr = (unsigned char*) ::HeapAlloc(hHeap, dwFlags, dwBytes + 16);
    ptr = __HeapAlignPointerAndWritePadding16(ptr);
    return (LPVOID) ptr;
}
 
//------------------------------------------------------------------------------
__forceinline LPVOID
__HeapReAlloc16(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes)
{
    // restore unaligned pointer
    unsigned char* ptr = (unsigned char*) lpMem;
    unsigned char* rawPtr = __HeapUnalignPointer16(ptr); 
 
    // perform re-alloc, NOTE: if re-allocation can't happen in-place,
    // we need to handle the allocation ourselves, in order not to destroy 
    // the original data because of different alignment!!!
    ptr = (unsigned char*) ::HeapReAlloc(hHeap, (dwFlags | HEAP_REALLOC_IN_PLACE_ONLY), rawPtr, dwBytes + 16);
    if (0 == ptr)
    {                   
        SIZE_T rawSize = ::HeapSize(hHeap, dwFlags, rawPtr);        
        // re-allocate manually because padding may be different!
        ptr = (unsigned char*) ::HeapAlloc(hHeap, dwFlags, dwBytes + 16);
        ptr = __HeapAlignPointerAndWritePadding16(ptr);
        SIZE_T copySize = dwBytes <= (rawSize - 16) ? dwBytes : (rawSize - 16);
        ::CopyMemory(ptr, lpMem, copySize);    
        // release old mem block
        ::HeapFree(hHeap, dwFlags, rawPtr);
    }
    else
    {
        // was re-allocated in place
        ptr = __HeapAlignPointerAndWritePadding16(ptr);
    }
    return (LPVOID) ptr;
}
 
//------------------------------------------------------------------------------
__forceinline BOOL
__HeapFree16(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
{
    unsigned char* ptr = (unsigned char*) lpMem;
    ptr = __HeapUnalignPointer16(ptr);
    return ::HeapFree(hHeap, dwFlags, ptr);
}
 
//------------------------------------------------------------------------------
__forceinline SIZE_T
__HeapSize16(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem)
{
    unsigned char* ptr = (unsigned char*) lpMem;
    ptr = __HeapUnalignPointer16(ptr);
    return ::HeapSize(hHeap, dwFlags, ptr);
}    
 
} // namespace Memory    
//------------------------------------------------------------------------------