Bump OculusVR RIFT SDK to 0.5.0.1vanilla_0.5.0.1

1 files changed, 842 insertions, 0 deletions

diff --git a/LibOVRKernel/Src/Kernel/OVR_Allocator.cpp b/LibOVRKernel/Src/Kernel/OVR_Allocator.cpp
new file mode 100644
index 0000000..c4f2ad9
--- /dev/null
+++ b/LibOVRKernel/Src/Kernel/OVR_Allocator.cpp
@@ -0,0 +1,842 @@
+/************************************************************************************
+
+Filename    :   OVR_Allocator.cpp
+Content     :   Installable memory allocator implementation
+Created     :   September 19, 2012
+Notes       : 
+
+Copyright   :   Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License"); 
+you may not use the Oculus VR Rift SDK except in compliance with the License, 
+which is provided at the time of installation or download, or which 
+otherwise accompanies this software in either electronic or hard copy form.
+
+You may obtain a copy of the License at
+
+http://www.oculusvr.com/licenses/LICENSE-3.2 
+
+Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#include "OVR_Allocator.h"
+#include "OVR_DebugHelp.h"
+#include <stdlib.h>
+
+#ifdef OVR_OS_MAC
+ #include <stdlib.h>
+ #include <malloc/malloc.h>
+#else
+ #include <malloc.h>
+#endif
+
+#if defined(OVR_OS_MS)
+ #include "OVR_Win32_IncludeWindows.h"
+#elif defined(OVR_OS_MAC) || defined(OVR_OS_UNIX)
+ #include <unistd.h>
+ #include <sys/mman.h>
+#endif
+
+namespace OVR {
+
+
+//-----------------------------------------------------------------------------------
+// ***** Allocator
+
+Allocator* Allocator::pInstance = 0;
+
+// Default AlignedAlloc implementation will delegate to Alloc/Free after doing rounding.
+void* Allocator::AllocAligned(size_t size, size_t align)
+{
+    OVR_ASSERT((align & (align-1)) == 0);
+    align = (align > sizeof(size_t)) ? align : sizeof(size_t);
+    size_t p = (size_t)Alloc(size+align);
+    size_t aligned = 0;
+    if (p)
+    {
+        aligned = (size_t(p) + align-1) & ~(align-1);
+        if (aligned == p) 
+            aligned += align;
+        *(((size_t*)aligned)-1) = aligned-p;
+    }
+
+    trackAlloc((void*)aligned, size);
+
+    return (void*)aligned;
+}
+
+void Allocator::FreeAligned(void* p)
+{
+    untrackAlloc((void*)p);
+
+    size_t src = size_t(p) - *(((size_t*)p) - 1);
+    Free((void*)src);
+}
+
+
+//------------------------------------------------------------------------
+// ***** Default Allocator
+
+// This allocator is created and used if no other allocator is installed.
+// Default allocator delegates to system malloc.
+
+void* DefaultAllocator::Alloc(size_t size)
+{
+    void* p = malloc(size);
+    trackAlloc(p, size);
+    return p;
+}
+void* DefaultAllocator::AllocDebug(size_t size, const char* file, unsigned line)
+{
+	OVR_UNUSED2(file, line); // should be here for debugopt config
+    void* p;
+#if defined(OVR_CC_MSVC) && defined(_CRTDBG_MAP_ALLOC)
+    p = _malloc_dbg(size, _NORMAL_BLOCK, file, line);
+#else
+    p = malloc(size);
+#endif
+    trackAlloc(p, size);
+    return p;
+}
+
+void* DefaultAllocator::Realloc(void* p, size_t newSize)
+{
+    void* newP = realloc(p, newSize);
+
+    // This used to more efficiently check if (newp != p) but static analyzers were erroneously flagging this.
+    if(newP) // Need to check newP because realloc doesn't free p unless it returns a valid newP.
+    {
+        #if !defined(__clang_analyzer__)  // The analyzer complains that we are using p after it was freed.
+            untrackAlloc(p);
+        #endif
+    }
+    trackAlloc(newP, newSize);
+    return newP;
+}
+
+void DefaultAllocator::Free(void *p)
+{
+    untrackAlloc(p);
+    return free(p);
+}
+
+
+// System block allocator:
+
+void* SafeMMapAlloc(size_t size)
+{
+    #if defined(OVR_OS_MS)
+        return VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); // size is rounded up to a page. // Returned memory is 0-filled.
+
+    #elif defined(OVR_OS_MAC) || defined(OVR_OS_UNIX)
+        #if !defined(MAP_FAILED)
+            #define MAP_FAILED ((void*)-1)
+        #endif
+
+        void* result = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); // Returned memory is 0-filled.
+        if(result == MAP_FAILED) // mmap returns MAP_FAILED (-1) upon failure.
+            result = nullptr;
+        return result;
+    #endif
+}
+
+void SafeMMapFree(const void* memory, size_t size)
+{
+    #if defined(OVR_OS_MS)
+        OVR_UNUSED(size);
+        VirtualFree(const_cast<void*>(memory), 0, MEM_RELEASE);
+
+    #elif defined(OVR_OS_MAC) || defined(OVR_OS_UNIX)
+        size_t pageSize = getpagesize();
+        size = (((size + (pageSize - 1)) / pageSize) * pageSize);
+        munmap(const_cast<void*>(memory), size); // Must supply the size to munmap.
+    #endif
+}
+
+
+//------------------------------------------------------------------------
+// ***** Track Allocations
+
+struct TrackedAlloc
+{
+    TrackedAlloc* pNext;
+    TrackedAlloc* pPrev;
+    void*         pAlloc;
+    void*         Callstack[64];
+    uint32_t      FrameCount;
+    uint32_t      Size;
+};
+
+static TrackedAlloc* TrackHead = nullptr;
+static SymbolLookup Symbols;
+static bool IsLeakTracking = false;
+
+void Allocator::SetLeakTracking(bool enabled)
+{
+#if defined(OVR_OS_WIN32) && !defined(OVR_OS_WIN64)
+    // HACK: Currently 32-bit leak tracing is too slow to run in real-time on Windows.
+    // Note: We can possibly fix this by making a custom Win32 backtrace function which 
+    // takes advantage of the fact that we have enabled stack frames in all builds.
+    enabled = false;
+#endif
+
+    IsLeakTracking = enabled;
+}
+
+bool Allocator::IsTrackingLeaks()
+{
+    return IsLeakTracking;
+}
+
+void Allocator::trackAlloc(void* p, size_t size)
+{
+    if (!p || !IsLeakTracking)
+        return;
+
+    Lock::Locker locker(&TrackLock);
+
+    TrackedAlloc* tracked = (TrackedAlloc*)malloc(sizeof(TrackedAlloc));
+    if (tracked)
+    {
+        memset(tracked, 0, sizeof(TrackedAlloc));
+
+        tracked->pAlloc = p;
+        tracked->pPrev = nullptr;
+        tracked->FrameCount = (uint32_t)Symbols.GetBacktrace(tracked->Callstack, OVR_ARRAY_COUNT(tracked->Callstack), 2);
+        tracked->Size = (uint32_t)size;
+
+        tracked->pNext = TrackHead;
+        if (TrackHead)
+        {
+            TrackHead->pPrev = tracked;
+        }
+        TrackHead = tracked;
+    }
+}
+
+void Allocator::untrackAlloc(void* p)
+{
+    if (!p || !IsLeakTracking)
+        return;
+
+    Lock::Locker locker(&TrackLock);
+
+    for (TrackedAlloc* t = TrackHead; t; t = t->pNext)
+    {
+        if (t->pAlloc == p)
+        {
+            if (t->pPrev)
+            {
+                t->pPrev->pNext = t->pNext;
+            }
+            if (t->pNext)
+            {
+                t->pNext->pPrev = t->pPrev;
+            }
+            if (TrackHead == t)
+            {
+                TrackHead = t->pNext;
+            }
+            free(t);
+
+            break;
+        }
+    }
+}
+
+int DumpMemory()
+{
+    const bool symbolLookupWasInitialized = SymbolLookup::IsInitialized();
+    const bool symbolLookupAvailable = SymbolLookup::Initialize();
+
+    if(!symbolLookupWasInitialized) // If SymbolLookup::Initialize was the first time being initialized, we need to refresh the Symbols view of modules, etc.
+        Symbols.Refresh();
+
+    // If we're dumping while LibOVR is running, then we should hold the lock.
+    Allocator* pAlloc = Allocator::GetInstance();
+
+    // It's possible this is being called after the Allocator was shut down, at which 
+    // point we assume we are the only instance that can be executing at his time.
+    Lock* lock = pAlloc ? &pAlloc->TrackLock : nullptr;
+    if (lock) 
+        lock->DoLock();
+
+    int leakCount = 0;
+
+    for (TrackedAlloc* t = TrackHead; t; t = t->pNext)
+    {
+        LogError("[Leak] ** Detected leaked allocation at %p (size = %u) (%d frames)", t->pAlloc, (unsigned)t->Size, (unsigned)t->FrameCount);
+
+        for (size_t i = 0; i < t->FrameCount; ++i)
+        {
+            SymbolInfo symbolInfo;
+
+            if (symbolLookupAvailable && Symbols.LookupSymbol((uint64_t)t->Callstack[i], symbolInfo) && (symbolInfo.filePath[0] || symbolInfo.function[0]))
+            {
+                if(symbolInfo.filePath[0])
+                    LogText("%s(%d): %s\n", symbolInfo.filePath, symbolInfo.fileLineNumber, symbolInfo.function[0] ? symbolInfo.function : "(unknown function)");
+                else
+                    LogText("%p (unknown source file): %s\n", t->Callstack[i], symbolInfo.function);
+            }
+            else
+            {
+                LogText("%p (symbols unavailable)\n", t->Callstack[i]);
+            }
+        }
+
+        ++leakCount;
+    }
+
+    if (lock)
+        lock->Unlock();
+
+    if(symbolLookupAvailable)
+        SymbolLookup::Shutdown();
+
+    return leakCount;
+}
+
+
+
+//------------------------------------------------------------------------
+// ***** DebugPageAllocator
+
+static size_t AlignSizeUp(size_t value, size_t alignment)
+{
+    return ((value + (alignment - 1)) & ~(alignment - 1));
+}
+
+static size_t AlignSizeDown(size_t value, size_t alignment)
+{
+    return (value & ~(alignment - 1));
+}
+
+template <typename Pointer>
+Pointer AlignPointerUp(Pointer p, size_t alignment)
+{
+    return reinterpret_cast<Pointer>(((reinterpret_cast<size_t>(p) + (alignment - 1)) & ~(alignment - 1)));
+}
+
+template <typename Pointer>
+Pointer AlignPointerDown(Pointer p, size_t alignment)
+{
+    return reinterpret_cast<Pointer>(reinterpret_cast<size_t>(p) & ~(alignment-1));
+}
+
+
+const size_t kFreedBlockArrayMaxSizeDefault = 16384;
+
+
+DebugPageAllocator::DebugPageAllocator()
+  : FreedBlockArray(nullptr)
+  , FreedBlockArrayMaxSize(0)
+  , FreedBlockArraySize(0)
+  , FreedBlockArrayOldest(0)
+  , AllocationCount(0)
+  , OverrunPageEnabled(true)
+  #if defined(OVR_BUILD_DEBUG)
+  , OverrunGuardBytesEnabled(true)
+  #else
+  , OverrunGuardBytesEnabled(false)
+  #endif
+  //PageSize(0)
+  , Lock()
+{
+    #if defined(_WIN32)
+        SYSTEM_INFO systemInfo;
+        GetSystemInfo(&systemInfo);
+        PageSize = (size_t)systemInfo.dwPageSize;
+    #else
+        PageSize = 4096;
+    #endif
+
+    SetDelayedFreeCount(kFreedBlockArrayMaxSizeDefault);
+}
+
+
+DebugPageAllocator::~DebugPageAllocator()
+{
+    Shutdown();
+}
+
+
+void DebugPageAllocator::Init()
+{
+    // Nothing to do.
+}
+
+void DebugPageAllocator::Shutdown()
+{
+    Lock::Locker autoLock(&Lock);
+
+    for(size_t i = 0; i < FreedBlockArraySize; i++)
+    {
+        if(FreedBlockArray[i].BlockPtr)
+        {
+            FreePageMemory(FreedBlockArray[i].BlockPtr, FreedBlockArray[i].BlockSize);
+            FreedBlockArray[i].Clear();
+        }
+    }
+
+    SetDelayedFreeCount(0);
+    FreedBlockArraySize = 0;
+    FreedBlockArrayOldest = 0;
+}
+
+
+void DebugPageAllocator::EnableOverrunDetection(bool enableOverrunDetection, bool enableOverrunGuardBytes)
+{
+    OVR_ASSERT(AllocationCount == 0);
+
+    OverrunPageEnabled       = enableOverrunDetection;
+    OverrunGuardBytesEnabled = (enableOverrunDetection && enableOverrunGuardBytes); // Set OverrunGuardBytesEnabled to false if enableOverrunDetection is false.
+}
+
+
+void DebugPageAllocator::SetDelayedFreeCount(size_t delayedFreeCount)
+{
+    OVR_ASSERT(AllocationCount == 0);
+
+    if(FreedBlockArray)
+    {
+        SafeMMapFree(FreedBlockArray, FreedBlockArrayMaxSize * sizeof(Block));
+        FreedBlockArrayMaxSize = 0;
+    }
+
+    if(delayedFreeCount)
+    {
+        FreedBlockArray = (Block*)SafeMMapAlloc(delayedFreeCount * sizeof(Block));
+        OVR_ASSERT(FreedBlockArray);
+
+        if(FreedBlockArray)
+        {
+            FreedBlockArrayMaxSize = delayedFreeCount;
+            #if defined(OVR_BUILD_DEBUG)
+                memset(FreedBlockArray, 0, delayedFreeCount * sizeof(Block));
+            #endif
+        }
+    }
+}
+
+
+size_t DebugPageAllocator::GetDelayedFreeCount() const
+{
+    return FreedBlockArrayMaxSize;
+}
+
+
+void* DebugPageAllocator::Alloc(size_t size)
+{
+    #if defined(_WIN32)
+        return AllocAligned(size, DefaultAlignment);
+    #else
+        void* p = malloc(size);
+        trackAlloc(p, size);
+        return p;
+    #endif
+}
+
+
+void* DebugPageAllocator::AllocAligned(size_t size, size_t align)
+{
+    #if defined(_WIN32)
+        OVR_ASSERT(align <= PageSize);
+
+        Lock::Locker autoLock(&Lock);
+
+        if(align < DefaultAlignment)
+            align = DefaultAlignment;
+
+        // The actual needed size may be a little less than this, but it's hard to tell how the size and alignments will play out.
+        size_t maxRequiredSize = AlignSizeUp(size, align) + SizeStorageSize;
+
+        if(align > SizeStorageSize)
+        {
+            // Must do: more sophisticated fitting, as maxRequiredSize is potentially too small.
+            OVR_ASSERT(SizeStorageSize <= align);
+        }
+
+        size_t blockSize = AlignSizeUp(maxRequiredSize, PageSize);
+
+        if(OverrunPageEnabled)
+            blockSize += PageSize; // We add another page which will be uncommitted, so any read or write with it will except.
+
+        void* pBlockPtr;
+
+        if((FreedBlockArraySize == FreedBlockArrayMaxSize) && FreedBlockArrayMaxSize &&     // If there is an old block we can recycle...
+           (FreedBlockArray[FreedBlockArrayOldest].BlockSize == blockSize))                 // We require it to be the exact size, as there would be some headaches for us if it was over-sized.
+        {
+            pBlockPtr = EnablePageMemory(FreedBlockArray[FreedBlockArrayOldest].BlockPtr, blockSize);  // Convert this memory from PAGE_NOACCESS back to PAGE_READWRITE.
+            FreedBlockArray[FreedBlockArrayOldest].Clear();
+            
+            if(++FreedBlockArrayOldest == FreedBlockArrayMaxSize)
+                FreedBlockArrayOldest = 0;
+        }
+        else
+        {
+            pBlockPtr = AllocCommittedPageMemory(blockSize); // Allocate a new block of one or more pages (via VirtualAlloc).
+        }
+
+        if(pBlockPtr)
+        {
+            void*   pUserPtr = GetUserPosition(pBlockPtr, blockSize, size, align);
+            size_t* pSizePos = GetSizePosition(pUserPtr);
+
+            pSizePos[UserSizeIndex] = size;
+            pSizePos[BlockSizeIndex] = blockSize;
+            AllocationCount++;
+            trackAlloc(pUserPtr, size);
+
+            return pUserPtr;
+        }
+
+        return nullptr;
+    #else
+        OVR_ASSERT_AND_UNUSED(align <= DefaultAlignment, align);
+        return DebugPageAllocator::Alloc(size);
+    #endif
+}
+
+
+size_t DebugPageAllocator::GetUserSize(const void* p)
+{
+    #if defined(_WIN32)
+        return GetSizePosition(p)[UserSizeIndex];
+    #elif defined(__APPLE__)
+        return malloc_size(p);
+    #else
+        return malloc_usable_size(const_cast<void*>(p));
+    #endif
+}
+
+
+size_t DebugPageAllocator::GetBlockSize(const void* p)
+{
+    #if defined(_WIN32)
+        return GetSizePosition(p)[BlockSizeIndex];
+    #else
+        OVR_UNUSED(p);
+        return 0;
+    #endif
+}
+
+
+size_t* DebugPageAllocator::GetSizePosition(const void* p)
+{
+    // No thread safety required as per our design, as we assume that anybody 
+    // who owns a pointer returned by Alloc cannot have another thread take it away.
+
+    // We assume the pointer is a valid pointer allocated by this allocator.
+    // We store some size values into the memory returned to the user, a few bytes before it.
+    size_t  value    = reinterpret_cast<size_t>(p);
+    size_t  valuePos = (value - SizeStorageSize);
+    size_t* pSize    = reinterpret_cast<size_t*>(valuePos);
+
+    return pSize;
+}
+
+
+void* DebugPageAllocator::Realloc(void* p, size_t newSize)
+{
+    #if defined(_WIN32)
+        return ReallocAligned(p, newSize, DefaultAlignment);
+    #else
+        void* newP = realloc(p, newSize);
+
+        if(newP) // Need to check newP because realloc doesn't free p unless it returns a valid newP.
+        {
+            #if !defined(__clang_analyzer__) // The analyzer complains that we are using p after it was freed.
+                untrackAlloc(p);
+            #endif
+        }
+        trackAlloc(newP, newSize);
+        return newP;
+    #endif
+}
+
+
+void* DebugPageAllocator::ReallocAligned(void* p, size_t newSize, size_t newAlign)
+{
+    #if defined(_WIN32)
+        // The ISO C99 standard states:
+        //     The realloc function deallocates the old object pointed to by ptr and 
+        //     returns a pointer to a new object that has the size specified by size. 
+        //     The contents of the new object shall be the same as that of the old 
+        //     object prior to deallocation, up to the lesser of the new and old sizes. 
+        //     Any bytes in the new object beyond the size of the old object have
+        //     indeterminate values.
+        //
+        //     If ptr is a null pointer, the realloc function behaves like the malloc 
+        //     function for the specified size. Otherwise, if ptr does not match a 
+        //     pointer earlier returned by the calloc, malloc, or realloc function, 
+        //     or if the space has been deallocated by a call to the free or realloc 
+        //     function, the behavior is undefined. If memory for the new object 
+        //     cannot be allocated, the old object is not deallocated and its value 
+        //     is unchanged.
+        //     
+        //     The realloc function returns a pointer to the new object (which may have 
+        //     the same value as a pointer to the old object), or a null pointer if 
+        //     the new object could not be allocated.
+
+        // A mutex lock isn't required, as the functions below will handle it internally.
+        // But having it here is a little more efficient because it woudl otherwise be 
+        // locked and unlocked multiple times below, with possible context switches in between.
+        Lock::Locker autoLock(&Lock);
+
+        void* pReturn = nullptr;
+
+        if(p)
+        {
+            if(newSize)
+            {
+                pReturn = AllocAligned(newSize, newAlign);
+
+                if(pReturn)
+                {
+                    size_t prevSize = GetUserSize(p);
+
+                    if(newSize > prevSize)
+                        newSize = prevSize;
+
+                    memcpy(pReturn, p, newSize);
+                    Free(p);
+                } // Else fall through, leaving p's memory unmodified and returning nullptr.
+            }
+            else
+            {
+                Free(p);
+            }
+        }
+        else if(newSize)
+        {
+            pReturn = AllocAligned(newSize, newAlign);
+        }
+
+        return pReturn;
+    #else
+        OVR_ASSERT_AND_UNUSED(newAlign <= DefaultAlignment, newAlign);
+        return DebugPageAllocator::Realloc(p, newSize);
+    #endif
+}
+
+
+void DebugPageAllocator::Free(void *p)
+{
+    #if defined(_WIN32)
+        if(p)
+        {
+            Lock::Locker autoLock(&Lock);
+
+            if(FreedBlockArrayMaxSize)  // If we have a delayed free list...
+            {
+                // We don't free the page(s) associated with this but rather put them in the FreedBlockArray in an inaccessible state for later freeing.
+                // We do this because we don't want those pages to be available again in the near future, so we can detect use-after-free misakes.
+                Block* pBlockNew;
+
+                if(FreedBlockArraySize == FreedBlockArrayMaxSize) // If we have reached freed block capacity... we can start purging old elements from it as a circular queue.
+                {
+                    pBlockNew = &FreedBlockArray[FreedBlockArrayOldest];
+
+                    // The oldest element in the container is FreedBlockArrayOldest.
+                    if(pBlockNew->BlockPtr) // Currently this should always be true.
+                    {
+                        FreePageMemory(pBlockNew->BlockPtr, pBlockNew->BlockSize);
+                        pBlockNew->Clear();
+                    }
+
+                    if(++FreedBlockArrayOldest == FreedBlockArrayMaxSize)
+                        FreedBlockArrayOldest = 0;
+                }
+                else // Else we are still building the container and not yet treating it a circular.
+                {
+                    pBlockNew = &FreedBlockArray[FreedBlockArraySize++];
+                }
+
+                pBlockNew->BlockPtr  = GetBlockPtr(p);
+                pBlockNew->BlockSize = GetBlockSize(p);
+
+                #if defined(OVR_BUILD_DEBUG)
+                    if(OverrunGuardBytesEnabled) // If we have extra bytes at the end of the user's allocation between it and an inaccessible guard page...
+                    {
+                        const size_t   userSize = GetUserSize(p);
+                        const uint8_t* pUserEnd = (static_cast<uint8_t*>(p) + userSize);
+                        const uint8_t* pPageEnd = AlignPointerUp(pUserEnd, PageSize);
+
+                        while(pUserEnd != pPageEnd)
+                        {
+                            if(*pUserEnd++ != GuardFillByte)
+                            {
+                                OVR_FAIL();
+                                break;
+                            }
+                        }
+                    }
+                #endif
+
+                DisablePageMemory(pBlockNew->BlockPtr, pBlockNew->BlockSize); // Make it so that future attempts to use this memory result in an exception.
+            }
+            else
+            {
+                FreePageMemory(GetBlockPtr(p), GetBlockSize(p));
+            }
+
+            untrackAlloc(p);
+            AllocationCount--;
+        }
+    #else
+        untrackAlloc(p);
+        return free(p);
+    #endif
+}
+
+
+void DebugPageAllocator::FreeAligned(void* p)
+{
+    return Free(p);
+}
+
+
+// Converts a user pointer to the beginning of its page.
+void* DebugPageAllocator::GetBlockPtr(void* p)
+{
+    // We store size info before p in memory, and this will, by design, be always somewhere within 
+    // the first page of a block of pages. So just align down to the beginning of its page.
+    return AlignPointerDown(GetSizePosition(p), PageSize);
+}
+
+
+void* DebugPageAllocator::GetUserPosition(void* pPageMemory, size_t blockSize, size_t userSize, size_t userAlignment)
+{
+    uint8_t* pUserPosition;
+
+    if(OverrunPageEnabled)
+    {
+        // We need to return the highest position within the page memory that fits the user size while being aligned to userAlignment.
+        const size_t pageEnd      = reinterpret_cast<size_t>(pPageMemory) + (blockSize - PageSize); // pageEnd points to the beginning of the final guard page.
+        const size_t userPosition = AlignSizeDown(pageEnd - userSize, userAlignment);
+        pUserPosition = reinterpret_cast<uint8_t*>(userPosition);
+        OVR_ASSERT((userPosition + userSize) <= pageEnd);
+
+        // If userSize is not a multiple of userAlignment then there will be (userAlignment - userSize) bytes
+        // of unused memory between the user allocated space and the end of the page. There is no way around having this.
+        // For example, a user allocation of 3 bytes with 8 byte alignment will leave 5 unused bytes at the end of the page.
+        // We optionally fill those unused bytes with a pattern and upon Free verify that the pattern is undisturbed.
+        // This won't detect reads or writes in that area immediately as with reads or writes beyond that, but it will
+        // at least detect them at some point (e.g. upon Free).
+        #if defined(OVR_BUILD_DEBUG)
+            if(OverrunGuardBytesEnabled)
+            {
+                uint8_t* const pUserEnd = (pUserPosition + userSize);
+                const size_t remainingByteCount = (reinterpret_cast<uint8_t*>(pageEnd) - pUserEnd);
+                if(remainingByteCount) // If there are any left-over bytes...
+                    memset(pUserEnd, GuardFillByte, remainingByteCount);
+            }
+        #endif
+    }
+    else
+    {
+        // We need to return the first position in the first page after SizeStorageSize bytes which is aligned to userAlignment.
+        const size_t lowestPossiblePos = reinterpret_cast<size_t>(pPageMemory) + SizeStorageSize;
+        const size_t userPosition = AlignSizeUp(lowestPossiblePos, userAlignment);
+        pUserPosition = reinterpret_cast<uint8_t*>(userPosition);
+        OVR_ASSERT((userPosition + userSize) <= (reinterpret_cast<size_t>(pPageMemory) + blockSize));
+    }
+
+    // Assert that the returned user pointer (actually the size info before it) will be within the first page.
+    // This is important because it verifieds that we haven't wasted memory and because 
+    // our functionality for telling the start of the page block depends on it.
+    OVR_ASSERT(AlignPointerDown(GetSizePosition(pUserPosition), PageSize) == pPageMemory);
+
+    return pUserPosition;
+}
+
+
+void* DebugPageAllocator::AllocCommittedPageMemory(size_t blockSize)
+{
+    #if defined(_WIN32)
+        void* p;
+    
+        if(OverrunPageEnabled)
+        {
+            // We need to make it so that last page is MEM_RESERVE and the previous pages are MEM_COMMIT + PAGE_READWRITE.
+            OVR_ASSERT(blockSize > PageSize); // There should always be at least one extra page.
+
+            // Reserve blockSize amount of pages.
+            // We could possibly use PAGE_GUARD here for the last page. This differs from simply leaving it reserved
+            // because the OS will generate a one-time-only gaurd page exception. We probabl don't want this, as it's
+            // more useful for maintaining your own stack than for catching unintended overruns.
+            p = VirtualAlloc(nullptr, blockSize, MEM_RESERVE, PAGE_READWRITE);
+            OVR_ASSERT(p);
+
+            if(p)
+            {
+                // Commit all but the last page. Leave the last page as merely reserved so that reads from or writes
+                // to it result in an immediate exception.
+                p = VirtualAlloc(p, blockSize - PageSize, MEM_COMMIT, PAGE_READWRITE);
+                OVR_ASSERT(p);
+            }
+        }
+        else
+        {
+            // We need to make it so that all pages are MEM_COMMIT + PAGE_READWRITE.
+
+            p = VirtualAlloc(nullptr, blockSize, MEM_COMMIT, PAGE_READWRITE);
+        }
+    
+        return p;
+    #else
+        OVR_UNUSED2(blockSize, OverrunPageEnabled);
+        return nullptr;
+    #endif
+}
+
+
+// We convert disabled page memory (see DisablePageMemory) to enabled page memory. The output is the same 
+// as with AllocPageMemory.
+void* DebugPageAllocator::EnablePageMemory(void* pPageMemory, size_t blockSize)
+{
+    #if defined(_WIN32)
+        // Make sure the entire range of memory is of type PAGE_READWRITE.
+        DWORD dwPrevAccess = 0;
+        BOOL result = VirtualProtect(pPageMemory, OverrunPageEnabled ? (blockSize - PageSize) : blockSize, PAGE_READWRITE, &dwPrevAccess);
+        OVR_ASSERT_AND_UNUSED(result, result);
+    #else
+        OVR_UNUSED3(pPageMemory, blockSize, OverrunPageEnabled);
+    #endif
+
+    return pPageMemory;
+}
+
+
+void DebugPageAllocator::DisablePageMemory(void* pPageMemory, size_t blockSize)
+{
+    #if defined(_WIN32)
+        // Disable access to the page(s). It's faster for us to change the page access than it is to decommit or free the pages.
+        // However, this results in more committed physical memory usage than we would need if we instead decommitted the memory.
+        DWORD dwPrevAccesss = 0;
+        BOOL result = VirtualProtect(pPageMemory, OverrunPageEnabled ?  (blockSize - PageSize) : blockSize, PAGE_NOACCESS, &dwPrevAccesss);
+        OVR_ASSERT_AND_UNUSED(result, result);
+    #else
+        OVR_UNUSED2(pPageMemory, blockSize);
+    #endif
+}
+
+
+void DebugPageAllocator::FreePageMemory(void* pPageMemory, size_t /*blockSize*/)
+{
+    #if defined(_WIN32)    
+        BOOL result = VirtualFree(pPageMemory, 0, MEM_RELEASE);
+        OVR_ASSERT_AND_UNUSED(result, result);
+    #else
+        OVR_UNUSED(pPageMemory);
+    #endif
+}
+
+
+
+} // namespace OVR