void CommandQueueD3D12Impl::IdleGPU()
{
Uint64 LastSignaledFenceValue = m_NextFenceValue;
m_pd3d12CmdQueue->Signal(m_d3d12Fence, LastSignaledFenceValue);
Atomics::AtomicIncrement(m_NextFenceValue);
if (GetCompletedFenceValue() < LastSignaledFenceValue)
{
m_d3d12Fence->SetEventOnCompletion(LastSignaledFenceValue, m_WaitForGPUEventHandle);
WaitForSingleObject(m_WaitForGPUEventHandle, INFINITE);
VERIFY(GetCompletedFenceValue() == LastSignaledFenceValue, "Unexpected signaled fence value");
}
}
void RenderDeviceD3D12Impl::FinishFrame(bool ReleaseAllResources)
{
{
if (auto pImmediateCtx = m_wpImmediateContext.Lock())
{
auto pImmediateCtxD3D12 = ValidatedCast<DeviceContextD3D12Impl>(pImmediateCtx.RawPtr());
if(pImmediateCtxD3D12->GetNumCommandsInCtx() != 0)
LOG_ERROR_MESSAGE("There are outstanding commands in the immediate device context when finishing the frame. This is an error and may cause unpredicted behaviour. Call Flush() to submit all commands for execution before finishing the frame");
}
for (auto wpDeferredCtx : m_wpDeferredContexts)
{
if (auto pDeferredCtx = wpDeferredCtx.Lock())
{
auto pDeferredCtxD3D12 = ValidatedCast<DeviceContextD3D12Impl>(pDeferredCtx.RawPtr());
if(pDeferredCtxD3D12->GetNumCommandsInCtx() != 0)
LOG_ERROR_MESSAGE("There are outstanding commands in the deferred device context when finishing the frame. This is an error and may cause unpredicted behaviour. Close all deferred contexts and execute them before finishing the frame");
}
}
}
auto CompletedFenceValue = ReleaseAllResources ? std::numeric_limits<Uint64>::max() : GetCompletedFenceValue();
// We must use NextFenceValue here, NOT current value, because the
// fence value may or may not have been incremented when the last
// command list was submitted for execution (Unity only
// increments fence value once per frame)
Uint64 NextFenceValue = 0;
Uint64 CmdListNumber = 0;
{
// Lock the command queue to avoid other threads interfering with the GPU
std::lock_guard<std::mutex> LockGuard(m_CmdQueueMutex);
NextFenceValue = m_pCommandQueue->GetNextFenceValue();
// Increment cmd list number while keeping queue locked.
// This guarantees that any D3D12 object released after the lock
// is released, will be associated with the incremented cmd list number
CmdListNumber = m_NextCmdListNumber;
Atomics::AtomicIncrement(m_NextCmdListNumber);
}
{
// There is no need to lock as new heaps are only created during initialization
// time for every context
//std::lock_guard<std::mutex> LockGuard(m_UploadHeapMutex);
// Upload heaps are used to update resource contents as well as to allocate
// space for dynamic resources.
// Initial resource data is uploaded using temporary one-time upload buffers,
// so can be performed in parallel across frame boundaries
for (auto &UploadHeap : m_UploadHeaps)
{
// Currently upload heaps are free-threaded, so other threads must not allocate
// resources at the same time. This means that all dynamic buffers must be unmaped
// in the same frame and all resources must be updated within boundaries of a single frame.
//
// worker thread 3 | pDevice->CrateTexture(InitData) | | pDevice->CrateBuffer(InitData) | | pDevice->CrateTexture(InitData) |
//
// worker thread 2 | pDfrdCtx2->UpdateResource() | ||
// ||
// worker thread 1 | pDfrdCtx1->Map(WRITE_DISCARD) | | pDfrdCtx1->UpdateResource() | ||
// ||
// main thread | pCtx->Map(WRITE_DISCARD )| | pCtx->UpdateResource() | || | Present() |
//
//
UploadHeap->FinishFrame(NextFenceValue, CompletedFenceValue);
}
}
for(Uint32 CPUHeap=0; CPUHeap < _countof(m_CPUDescriptorHeaps); ++CPUHeap)
{
// This is OK if other thread disposes descriptor heap allocation at this time
// The allocation will be registered as part of the current frame
m_CPUDescriptorHeaps[CPUHeap].ReleaseStaleAllocations(CompletedFenceValue);
}
for(Uint32 GPUHeap=0; GPUHeap < _countof(m_GPUDescriptorHeaps); ++GPUHeap)
{
m_GPUDescriptorHeaps[GPUHeap].ReleaseStaleAllocations(CompletedFenceValue);
}
// Discard all remaining objects. This is important to do if there were
// no command lists submitted during the frame
DiscardStaleD3D12Objects(CmdListNumber, NextFenceValue);
ProcessReleaseQueue(CompletedFenceValue);
Atomics::AtomicIncrement(m_FrameNumber);
}
Bool RenderDeviceD3D12Impl::IsFenceSignaled(Uint64 FenceValue)
{
return FenceValue <= GetCompletedFenceValue();
}