VariableSizeGPUAllocationsManager.h

/*     Copyright 2015-2018 Egor Yusov
 *  
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 *  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 OF ANY PROPRIETARY RIGHTS.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */


// An GPU-tailored extension of the basic variable-size allocations manager
// See http://diligentgraphics.com/diligent-engine/architecture/d3d12/variable-size-memory-allocations-manager/

#pragma once

#include <deque>
#include "VariableSizeAllocationsManager.h"
#include "STDAllocator.h"

namespace Diligent
{
    // Class extends basic variable-size memory block allocator by deferring deallocation
    // of freed blocks untill the corresponding frame is completed
    class VariableSizeGPUAllocationsManager : public VariableSizeAllocationsManager
    {
    private:
        struct StaleAllocationAttribs
        {
            OffsetType Offset;
            OffsetType Size;
            Uint64 FenceValue;
            StaleAllocationAttribs(OffsetType _Offset, OffsetType _Size, Uint64 _FenceValue) :
                Offset(_Offset), Size(_Size), FenceValue(_FenceValue)
            {}
        };

    public:
        VariableSizeGPUAllocationsManager(OffsetType MaxSize, IMemoryAllocator &Allocator) : 
            VariableSizeAllocationsManager(MaxSize, Allocator),
            m_StaleAllocations(0, StaleAllocationAttribs(0,0,0), STD_ALLOCATOR_RAW_MEM(StaleAllocationAttribs, Allocator, "Allocator for deque<StaleAllocationAttribs>" ))
        {}

        ~VariableSizeGPUAllocationsManager()
        {
            VERIFY(m_StaleAllocations.empty(), "Not all stale allocations released");
            VERIFY(m_StaleAllocationsSize == 0, "Not all stale allocations released");
        }

        // = default causes compiler error when instantiating std::vector::emplace_back() in Visual Studio 2015 (Version 14.0.23107.0 D14REL)
        VariableSizeGPUAllocationsManager(VariableSizeGPUAllocationsManager&& rhs) : 
            VariableSizeAllocationsManager(std::move(rhs)),
            m_StaleAllocations(std::move(rhs.m_StaleAllocations)),
            m_StaleAllocationsSize(rhs.m_StaleAllocationsSize)
        {
            rhs.m_StaleAllocationsSize = 0;
        }

        VariableSizeGPUAllocationsManager& operator = (VariableSizeGPUAllocationsManager&& rhs) = delete;
        VariableSizeGPUAllocationsManager(const VariableSizeGPUAllocationsManager&) = delete;
        VariableSizeGPUAllocationsManager& operator = (const VariableSizeGPUAllocationsManager&) = delete;

        void Free(OffsetType Offset, OffsetType Size, Uint64 FenceValue)
        {
            // Do not release the block immediately, but add
            // it to the queue instead
            m_StaleAllocations.emplace_back(Offset, Size, FenceValue);
            m_StaleAllocationsSize += Size;
        }

        // Releases stale allocation from completed command lists
        // The method takes the last known completed fence value N
        // and releases all allocations whose associated fence value 
        // is at most N (n <= N)
        void ReleaseStaleAllocations(Uint64 LastCompletedFenceValue)
        {
            // Free all allocations from the beginning of the queue that belong to completed command lists
            while(!m_StaleAllocations.empty() && m_StaleAllocations.front().FenceValue <= LastCompletedFenceValue)
            {
                auto &OldestAllocation = m_StaleAllocations.front();
                VariableSizeAllocationsManager::Free(OldestAllocation.Offset, OldestAllocation.Size);
                m_StaleAllocationsSize -= OldestAllocation.Size;
                m_StaleAllocations.pop_front();
            }
        }

        size_t GetStaleAllocationsSize()const { return m_StaleAllocationsSize; }

    private:
        std::deque< StaleAllocationAttribs, STDAllocatorRawMem<StaleAllocationAttribs> > m_StaleAllocations;
        size_t m_StaleAllocationsSize = 0;
    };
}