/**************************************************************************** Copyright (c) 2008, Radon Labs GmbH Copyright (c) 2011-2013,WebJet Business Division,CYOU http://www.genesis-3d.com.cn Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ****************************************************************************/ #pragma once //------------------------------------------------------------------------------ /** @file memory/win360/win360memoryconfig.h Central config file for memory setup on the Win32 and Xbox360 platform. */ #include "core/config.h" #include "core/debug.h" namespace Memory { //------------------------------------------------------------------------------ /** Heap types are defined here. The main purpose for the different heap types is to decrease memory fragmentation and to improve cache usage by grouping similar data together. Platform ports may define platform-specific heap types, as long as only platform specific code uses those new heap types. */ 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 ScaleformHeap, // the scaleform UI heap Xbox360GraphicsHeap, // defines special Xbox360 graphical memory Xbox360AudioHeap, // defines special Xbox360 audio memory NumHeapTypes, InvalidHeapType, }; //------------------------------------------------------------------------------ /** Heap pointers are defined here. Call ValidateHeap() to check whether a heap already has been setup, and to setup the heap if not. */ extern HANDLE volatile Heaps[NumHeapTypes]; //------------------------------------------------------------------------------ /** This method is called by SysFunc::Setup() to setup the different heap types. This method can be tuned to define the start size of the heaps and whether the heap may grow or not (non-growing heaps may be especially useful on console platforms without memory paging). */ extern void SetupHeaps(); //------------------------------------------------------------------------------ /** Returns a human readable name for a heap type. */ extern const char* GetHeapTypeName(HeapType heapType); //------------------------------------------------------------------------------ /** Global PoolArrayAllocator objects, these are all setup in a central place in the Memory::SetupHeaps() function! */ #if NEBULA3_OBJECTS_USE_MEMORYPOOL class PoolArrayAllocator; extern PoolArrayAllocator* ObjectPoolAllocator; // Rtti::AllocInstanceMemory() and new operators alloc from here #endif //------------------------------------------------------------------------------ /** Helper function for Heap16 functions: aligns pointer to 16 byte and writes padding mask to byte before returned pointer. */ __forceinline unsigned char* __HeapAlignPointerAndWritePadding16(unsigned char* ptr) { unsigned char paddingMask = DWORD(ptr) & 15; ptr = (unsigned char*)(DWORD(ptr + 16) & ~15); ptr[-1] = paddingMask; return ptr; } //------------------------------------------------------------------------------ /** Helper function for Heap16 functions: "un-aligns" pointer through the padding mask stored in the byte before the pointer. */ __forceinline unsigned char* __HeapUnalignPointer16(unsigned char* ptr) { return (unsigned char*)(DWORD(ptr - 16) | ptr[-1]); } //------------------------------------------------------------------------------ /** HeapAlloc replacement which always returns 16-byte aligned addresses. NOTE: only works for 32 bit pointers! */ __forceinline LPVOID __HeapAlloc16(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) { #if __XBOX360__ return ::HeapAlloc(hHeap, dwFlags, dwBytes); #else unsigned char* ptr = (unsigned char*) ::HeapAlloc(hHeap, dwFlags, dwBytes + 16); if(ptr) ptr = __HeapAlignPointerAndWritePadding16(ptr); return (LPVOID) ptr; #endif } //------------------------------------------------------------------------------ /** HeapReAlloc replacement for 16-byte alignment. NOTE: only works for 32 bit pointers! */ __forceinline LPVOID __HeapReAlloc16(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes) { #if __XBOX360__ return HeapReAlloc(hHeap, dwFlags, lpMem, dwBytes); #else // 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) { DWORD rawSize = ::HeapSize(hHeap, dwFlags, rawPtr); // re-allocate manually because padding may be different! ptr = (unsigned char*) ::HeapAlloc(hHeap, dwFlags, dwBytes + 16); ptr = __HeapAlignPointerAndWritePadding16(ptr); DWORD 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; #endif } //------------------------------------------------------------------------------ /** HeapFree replacement which always returns 16-byte aligned addresses. NOTE: only works for 32 bit pointers! */ __forceinline BOOL __HeapFree16(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) { #if __XBOX360__ return ::HeapFree(hHeap, dwFlags, lpMem); #else unsigned char* ptr = (unsigned char*) lpMem; ptr = __HeapUnalignPointer16(ptr); return ::HeapFree(hHeap, dwFlags, ptr); #endif } //------------------------------------------------------------------------------ /** HeapSize replacement function. */ __forceinline SIZE_T __HeapSize16(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) { #if __XBOX360__ return ::HeapSize(hHeap, dwFlags, lpMem); #else unsigned char* ptr = (unsigned char*) lpMem; ptr = __HeapUnalignPointer16(ptr); return ::HeapSize(hHeap, dwFlags, ptr); #endif } } // namespace Memory //------------------------------------------------------------------------------