blob: bb8ef81300588d6707af4a63903bfc5d8dc220f2 [file] [log] [blame] [edit]
// Copyright 2019 The Dawn Authors
//
// 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
//
// Unless required by applicable law or agreed to in writing, software
// 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 "dawn/native/d3d12/CommandRecordingContext.h"
#include "dawn/native/d3d12/CommandAllocatorManager.h"
#include "dawn/native/d3d12/D3D12Error.h"
#include "dawn/native/d3d12/DeviceD3D12.h"
#include "dawn/native/d3d12/HeapD3D12.h"
#include "dawn/native/d3d12/ResidencyManagerD3D12.h"
#include "dawn/platform/DawnPlatform.h"
#include "dawn/platform/tracing/TraceEvent.h"
#include <profileapi.h>
#include <sysinfoapi.h>
namespace dawn::native::d3d12 {
void CommandRecordingContext::AddToSharedTextureList(Texture* texture) {
ASSERT(IsOpen());
mSharedTextures.insert(texture);
}
MaybeError CommandRecordingContext::Open(ID3D12Device* d3d12Device,
CommandAllocatorManager* commandAllocationManager) {
ASSERT(!IsOpen());
ID3D12CommandAllocator* commandAllocator;
DAWN_TRY_ASSIGN(commandAllocator, commandAllocationManager->ReserveCommandAllocator());
if (mD3d12CommandList != nullptr) {
MaybeError error = CheckHRESULT(mD3d12CommandList->Reset(commandAllocator, nullptr),
"D3D12 resetting command list");
if (error.IsError()) {
mD3d12CommandList.Reset();
DAWN_TRY(std::move(error));
}
} else {
ComPtr<ID3D12GraphicsCommandList> d3d12GraphicsCommandList;
DAWN_TRY(CheckHRESULT(
d3d12Device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, commandAllocator,
nullptr, IID_PPV_ARGS(&d3d12GraphicsCommandList)),
"D3D12 creating direct command list"));
mD3d12CommandList = std::move(d3d12GraphicsCommandList);
// Store a cast to ID3D12GraphicsCommandList4. This is required to use the D3D12 render
// pass APIs introduced in Windows build 1809.
mD3d12CommandList.As(&mD3d12CommandList4);
}
mIsOpen = true;
return {};
}
MaybeError CommandRecordingContext::ExecuteCommandList(Device* device) {
if (IsOpen()) {
// Shared textures must be transitioned to common state after the last usage in order
// for them to be used by other APIs like D3D11. We ensure this by transitioning to the
// common state right before command list submission. TransitionUsageNow itself ensures
// no unnecessary transitions happen if the resources is already in the common state.
for (Texture* texture : mSharedTextures) {
DAWN_TRY(texture->AcquireKeyedMutex());
texture->TrackAllUsageAndTransitionNow(this, D3D12_RESOURCE_STATE_COMMON);
}
MaybeError error =
CheckHRESULT(mD3d12CommandList->Close(), "D3D12 closing pending command list");
if (error.IsError()) {
Release();
DAWN_TRY(std::move(error));
}
DAWN_TRY(device->GetResidencyManager()->EnsureHeapsAreResident(
mHeapsPendingUsage.data(), mHeapsPendingUsage.size()));
if (device->IsToggleEnabled(Toggle::RecordDetailedTimingInTraceEvents)) {
uint64_t gpuTimestamp;
uint64_t cpuTimestamp;
FILETIME fileTimeNonPrecise;
SYSTEMTIME systemTimeNonPrecise;
// Both supported since Windows 2000, have a accuracy of 1ms
GetSystemTimeAsFileTime(&fileTimeNonPrecise);
GetSystemTime(&systemTimeNonPrecise);
// Query CPU and GPU timestamps at almost the same time
device->GetCommandQueue()->GetClockCalibration(&gpuTimestamp, &cpuTimestamp);
uint64_t gpuFrequency;
uint64_t cpuFrequency;
LARGE_INTEGER cpuFrequencyLargeInteger;
device->GetCommandQueue()->GetTimestampFrequency(&gpuFrequency);
QueryPerformanceFrequency(
&cpuFrequencyLargeInteger); // Supported since Windows 2000
cpuFrequency = cpuFrequencyLargeInteger.QuadPart;
std::string timingInfo = absl::StrFormat(
"UTC Time: %u/%u/%u %02u:%02u:%02u.%03u, File Time: %u, CPU "
"Timestamp: %u, GPU Timestamp: %u, CPU Tick Frequency: %u, GPU Tick Frequency: "
"%u",
systemTimeNonPrecise.wYear, systemTimeNonPrecise.wMonth,
systemTimeNonPrecise.wDay, systemTimeNonPrecise.wHour,
systemTimeNonPrecise.wMinute, systemTimeNonPrecise.wSecond,
systemTimeNonPrecise.wMilliseconds,
(static_cast<uint64_t>(fileTimeNonPrecise.dwHighDateTime) << 32) +
fileTimeNonPrecise.dwLowDateTime,
cpuTimestamp, gpuTimestamp, cpuFrequency, gpuFrequency);
TRACE_EVENT_INSTANT1(
device->GetPlatform(), General,
"d3d12::CommandRecordingContext::ExecuteCommandList Detailed Timing", "Timing",
timingInfo.c_str());
}
ID3D12CommandList* d3d12CommandList = GetCommandList();
device->GetCommandQueue()->ExecuteCommandLists(1, &d3d12CommandList);
for (Texture* texture : mSharedTextures) {
texture->ReleaseKeyedMutex();
}
mIsOpen = false;
mSharedTextures.clear();
mHeapsPendingUsage.clear();
}
return {};
}
void CommandRecordingContext::TrackHeapUsage(Heap* heap, ExecutionSerial serial) {
// Before tracking the heap, check the last serial it was recorded on to ensure we aren't
// tracking it more than once.
if (heap->GetLastUsage() < serial) {
heap->SetLastUsage(serial);
mHeapsPendingUsage.push_back(heap);
}
}
ID3D12GraphicsCommandList* CommandRecordingContext::GetCommandList() const {
ASSERT(mD3d12CommandList != nullptr);
ASSERT(IsOpen());
return mD3d12CommandList.Get();
}
// This function will fail on Windows versions prior to 1809. Support must be queried through
// the device before calling.
ID3D12GraphicsCommandList4* CommandRecordingContext::GetCommandList4() const {
ASSERT(IsOpen());
ASSERT(mD3d12CommandList != nullptr);
return mD3d12CommandList4.Get();
}
void CommandRecordingContext::Release() {
mD3d12CommandList.Reset();
mD3d12CommandList4.Reset();
mIsOpen = false;
mSharedTextures.clear();
mHeapsPendingUsage.clear();
mTempBuffers.clear();
}
bool CommandRecordingContext::IsOpen() const {
return mIsOpen;
}
void CommandRecordingContext::AddToTempBuffers(Ref<Buffer> tempBuffer) {
mTempBuffers.emplace_back(tempBuffer);
}
} // namespace dawn::native::d3d12