Core/CommandListManager.cpp

   1 //
   2 // Copyright (c) Microsoft. All rights reserved.
   3 // This code is licensed under the MIT License (MIT).
   4 // THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
   5 // ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
   6 // IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
   7 // PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
   8 //
   9 // Developed by Minigraph
  10 //
  11 // Author:  James Stanard
  12 //
  13
  14 #include "pch.h"
  15 #include "CommandListManager.h"
  16
  17 CommandQueue::CommandQueue(D3D12_COMMAND_LIST_TYPE Type) :
  18     m_CommandQueue(nullptr),
  19     m_Type(Type),
  20     m_AllocatorPool(Type),
  21     m_pFence(nullptr),
  22     m_NextFenceValue((uint64_t)Type << 56 | 1),
  23     m_LastCompletedFenceValue((uint64_t)Type << 56)
  24 {
  25 }
  26
  27 CommandQueue::~CommandQueue()
  28 {
  29     Shutdown();
  30 }
  31
  32 void CommandQueue::Shutdown()
  33 {
  34     if (m_CommandQueue == nullptr)
  35         return;
  36
  37     m_AllocatorPool.Shutdown();
  38
  39     port_destroy_event(m_FenceEventHandle);
  40
  41     m_pFence->Release();
  42     m_pFence = nullptr;
  43
  44     m_CommandQueue->Release();
  45     m_CommandQueue = nullptr;
  46 }
  47
  48 CommandListManager::CommandListManager() :
  49     m_Device(nullptr),
  50     m_GraphicsQueue(D3D12_COMMAND_LIST_TYPE_DIRECT),
  51     m_ComputeQueue(D3D12_COMMAND_LIST_TYPE_COMPUTE),
  52     m_CopyQueue(D3D12_COMMAND_LIST_TYPE_COPY)
  53 {
  54 }
  55
  56 CommandListManager::~CommandListManager()
  57 {
  58     Shutdown();
  59 }
  60
  61 void CommandListManager::Shutdown()
  62 {
  63     m_GraphicsQueue.Shutdown();
  64     m_ComputeQueue.Shutdown();
  65     m_CopyQueue.Shutdown();
  66 }
  67
  68 void CommandQueue::Create(ID3D12Device* pDevice)
  69 {
  70     ASSERT(pDevice != nullptr);
  71     ASSERT(!IsReady());
  72     ASSERT(m_AllocatorPool.Size() == 0);
  73
  74     D3D12_COMMAND_QUEUE_DESC QueueDesc = {};
  75     QueueDesc.Type = m_Type;
  76     QueueDesc.NodeMask = 1;
  77     pDevice->CreateCommandQueue(&QueueDesc, MY_IID_PPV_ARGS(&m_CommandQueue));
  78     m_CommandQueue->SetName(L"CommandListManager::m_CommandQueue");
  79
  80     ASSERT_SUCCEEDED(pDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, MY_IID_PPV_ARGS(&m_pFence)));
  81     m_pFence->SetName(L"CommandListManager::m_pFence");
  82     m_pFence->Signal((uint64_t)m_Type << 56);
  83
  84     m_FenceEventHandle = port_create_event();
  85     ASSERT(m_FenceEventHandle != INVALID_HANDLE_VALUE);
  86
  87     m_AllocatorPool.Create(pDevice);
  88
  89     ASSERT(IsReady());
  90 }
  91
  92 void CommandListManager::Create(ID3D12Device* pDevice)
  93 {
  94     ASSERT(pDevice != nullptr);
  95
  96     m_Device = pDevice;
  97
  98     m_GraphicsQueue.Create(pDevice);
  99     m_ComputeQueue.Create(pDevice);
 100     m_CopyQueue.Create(pDevice);
 101 }
 102
 103 void CommandListManager::CreateNewCommandList( D3D12_COMMAND_LIST_TYPE Type, ID3D12GraphicsCommandList** List, ID3D12CommandAllocator** Allocator )
 104 {
 105     ASSERT(Type != D3D12_COMMAND_LIST_TYPE_BUNDLE, "Bundles are not yet supported");
 106     switch (Type)
 107     {
 108     case D3D12_COMMAND_LIST_TYPE_DIRECT: *Allocator = m_GraphicsQueue.RequestAllocator(); break;
 109     case D3D12_COMMAND_LIST_TYPE_BUNDLE: break;
 110     case D3D12_COMMAND_LIST_TYPE_COMPUTE: *Allocator = m_ComputeQueue.RequestAllocator(); break;
 111     case D3D12_COMMAND_LIST_TYPE_COPY: *Allocator = m_CopyQueue.RequestAllocator(); break;
 112     }
 113
 114     ASSERT_SUCCEEDED( m_Device->CreateCommandList(1, Type, *Allocator, nullptr, MY_IID_PPV_ARGS(List)) );
 115     (*List)->SetName(L"CommandList");
 116 }
 117
 118 uint64_t CommandQueue::ExecuteCommandList( ID3D12CommandList* List )
 119 {
 120     std::lock_guard<std::mutex> LockGuard(m_FenceMutex);
 121
 122     ASSERT_SUCCEEDED(((ID3D12GraphicsCommandList*)List)->Close());
 123
 124     // Kickoff the command list
 125     m_CommandQueue->ExecuteCommandLists(1, &List);
 126
 127     // Signal the next fence value (with the GPU)
 128     m_CommandQueue->Signal(m_pFence, m_NextFenceValue);
 129
 130     // And increment the fence value.
 131     return m_NextFenceValue++;
 132 }
 133
 134 uint64_t CommandQueue::IncrementFence(void)
 135 {
 136     std::lock_guard<std::mutex> LockGuard(m_FenceMutex);
 137     m_CommandQueue->Signal(m_pFence, m_NextFenceValue);
 138     return m_NextFenceValue++;
 139 }
 140
 141 bool CommandQueue::IsFenceComplete(uint64_t FenceValue)
 142 {
 143     // Avoid querying the fence value by testing against the last one seen.
 144     // The max() is to protect against an unlikely race condition that could cause the last
 145     // completed fence value to regress.
 146     if (FenceValue > m_LastCompletedFenceValue)
 147         m_LastCompletedFenceValue = std::max(m_LastCompletedFenceValue, m_pFence->GetCompletedValue());
 148
 149     return FenceValue <= m_LastCompletedFenceValue;
 150 }
 151
 152 namespace Graphics
 153 {
 154     extern CommandListManager g_CommandManager;
 155 }
 156
 157 void CommandQueue::StallForFence(uint64_t FenceValue)
 158 {
 159     CommandQueue& Producer = Graphics::g_CommandManager.GetQueue((D3D12_COMMAND_LIST_TYPE)(FenceValue >> 56));
 160     m_CommandQueue->Wait(Producer.m_pFence, FenceValue);
 161 }
 162
 163 void CommandQueue::StallForProducer(CommandQueue& Producer)
 164 {
 165     ASSERT(Producer.m_NextFenceValue > 0);
 166     m_CommandQueue->Wait(Producer.m_pFence, Producer.m_NextFenceValue - 1);
 167 }
 168
 169 void CommandQueue::WaitForFence(uint64_t FenceValue)
 170 {
 171     if (IsFenceComplete(FenceValue))
 172         return;
 173
 174     // TODO:  Think about how this might affect a multi-threaded situation.  Suppose thread A
 175     // wants to wait for fence 100, then thread B comes along and wants to wait for 99.  If
 176     // the fence can only have one event set on completion, then thread B has to wait for
 177     // 100 before it knows 99 is ready.  Maybe insert sequential events?
 178     {
 179         std::lock_guard<std::mutex> LockGuard(m_EventMutex);
 180
 181         m_pFence->SetEventOnCompletion(FenceValue, m_FenceEventHandle);
 182         port_wait_event(m_FenceEventHandle, INFINITE);
 183         m_LastCompletedFenceValue = FenceValue;
 184     }
 185 }
 186
 187 void CommandListManager::WaitForFence(uint64_t FenceValue)
 188 {
 189     CommandQueue& Producer = Graphics::g_CommandManager.GetQueue((D3D12_COMMAND_LIST_TYPE)(FenceValue >> 56));
 190     Producer.WaitForFence(FenceValue);
 191 }
 192
 193 ID3D12CommandAllocator* CommandQueue::RequestAllocator()
 194 {
 195     uint64_t CompletedFence = m_pFence->GetCompletedValue();
 196
 197     return m_AllocatorPool.RequestAllocator(CompletedFence);
 198 }
 199
 200 void CommandQueue::DiscardAllocator(uint64_t FenceValue, ID3D12CommandAllocator* Allocator)
 201 {
 202     m_AllocatorPool.DiscardAllocator(FenceValue, Allocator);
 203 }