src/dawn/native/d3d11/QueueD3D11.cpp - dawn - Git at Google

 // Copyright 2023 The Dawn & Tint Authors
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //
 // 1. Redistributions of source code must retain the above copyright notice, this
 //    list of conditions and the following disclaimer.
 //
 // 2. Redistributions in binary form must reproduce the above copyright notice,
 //    this list of conditions and the following disclaimer in the documentation
 //    and/or other materials provided with the distribution.
 //
 // 3. Neither the name of the copyright holder nor the names of its
 //    contributors may be used to endorse or promote products derived from
 //    this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "dawn/native/d3d11/QueueD3D11.h"

 #include <utility>

 #include "dawn/native/d3d/D3DError.h"
 #include "dawn/native/d3d11/BufferD3D11.h"
 #include "dawn/native/d3d11/CommandBufferD3D11.h"
 #include "dawn/native/d3d11/DeviceD3D11.h"
 #include "dawn/native/d3d11/SharedFenceD3D11.h"
 #include "dawn/native/d3d11/TextureD3D11.h"
 #include "dawn/platform/DawnPlatform.h"
 #include "dawn/platform/tracing/TraceEvent.h"

 namespace dawn::native::d3d11 {

 ResultOrError<Ref<Queue>> Queue::Create(Device* device, const QueueDescriptor* descriptor) {
     Ref<Queue> queue = AcquireRef(new Queue(device, descriptor));
     DAWN_TRY(queue->Initialize());
     return queue;
 }

 MaybeError Queue::Initialize() {
     // Create the fence.
     DAWN_TRY(CheckHRESULT(ToBackend(GetDevice())
                               ->GetD3D11Device5()
                               ->CreateFence(0, D3D11_FENCE_FLAG_SHARED, IID_PPV_ARGS(&mFence)),
                           "D3D11: creating fence"));

     // Create the fence event.
     mFenceEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
     DAWN_ASSERT(mFenceEvent != nullptr);

     DAWN_TRY_ASSIGN(mSharedFence, SharedFence::Create(ToBackend(GetDevice()),
                                                       "Internal shared DXGI fence", mFence));

     return {};
 }

 MaybeError Queue::InitializePendingContext() {
     return mPendingCommands.Initialize(ToBackend(GetDevice()));
 }

 void Queue::DestroyImpl() {
     if (mFenceEvent != nullptr) {
         ::CloseHandle(mFenceEvent);
         mFenceEvent = nullptr;
     }

     // Release the shared fence here to prevent a ref-cycle with the device, but do not destroy the
     // underlying native fence so that we can return a SharedFence on EndAccess after destruction.
     mSharedFence = nullptr;

     mPendingCommands.Release();
 }

 ResultOrError<Ref<d3d::SharedFence>> Queue::GetOrCreateSharedFence() {
     if (mSharedFence == nullptr) {
         DAWN_ASSERT(!IsAlive());
         return SharedFence::Create(ToBackend(GetDevice()), "Internal shared DXGI fence", mFence);
     }
     return mSharedFence;
 }

 ScopedCommandRecordingContext Queue::GetScopedPendingCommandContext(SubmitMode submitMode) {
     // Callers of GetPendingCommandList do so to record commands. Only reserve a command
     // allocator when it is needed so we don't submit empty command lists
     DAWN_ASSERT(mPendingCommands.IsOpen());

     if (submitMode == SubmitMode::Normal) {
         mPendingCommands.SetNeedsSubmit();
     }

     return ScopedCommandRecordingContext(&mPendingCommands);
 }

 ScopedSwapStateCommandRecordingContext Queue::GetScopedSwapStatePendingCommandContext(
     SubmitMode submitMode) {
     // Callers of GetPendingCommandList do so to record commands. Only reserve a command
     // allocator when it is needed so we don't submit empty command lists
     DAWN_ASSERT(mPendingCommands.IsOpen());

     if (submitMode == SubmitMode::Normal) {
         mPendingCommands.SetNeedsSubmit();
     }

     return ScopedSwapStateCommandRecordingContext(&mPendingCommands);
 }

 MaybeError Queue::SubmitPendingCommands() {
     if (!mPendingCommands.IsOpen() || !mPendingCommands.NeedsSubmit()) {
         return {};
     }

     DAWN_TRY(mPendingCommands.ExecuteCommandList());
     return NextSerial();
 }

 MaybeError Queue::SubmitImpl(uint32_t commandCount, CommandBufferBase* const* commands) {
     // CommandBuffer::Execute() will modify the state of the global immediate device context, it may
     // affect following usage of it.
     // TODO(dawn:1770): figure how if we need to track and restore the state of the immediate device
     // context.
     TRACE_EVENT_BEGIN0(GetDevice()->GetPlatform(), Recording, "CommandBufferD3D11::Execute");
     {
         auto commandContext = GetScopedSwapStatePendingCommandContext(Device::SubmitMode::Normal);
         for (uint32_t i = 0; i < commandCount; ++i) {
             DAWN_TRY(ToBackend(commands[i])->Execute(&commandContext));
         }
     }
     DAWN_TRY(SubmitPendingCommands());
     TRACE_EVENT_END0(GetDevice()->GetPlatform(), Recording, "CommandBufferD3D11::Execute");

     return {};
 }

 MaybeError Queue::WriteBufferImpl(BufferBase* buffer,
                                   uint64_t bufferOffset,
                                   const void* data,
                                   size_t size) {
     if (size == 0) {
         // skip the empty write
         return {};
     }

     auto commandContext = GetScopedPendingCommandContext(Device::SubmitMode::Normal);
     return ToBackend(buffer)->Write(&commandContext, bufferOffset, data, size);
 }

 MaybeError Queue::WriteTextureImpl(const ImageCopyTexture& destination,
                                    const void* data,
                                    const TextureDataLayout& dataLayout,
                                    const Extent3D& writeSizePixel) {
     if (writeSizePixel.width == 0 || writeSizePixel.height == 0 ||
         writeSizePixel.depthOrArrayLayers == 0) {
         return {};
     }

     Device* device = ToBackend(GetDevice());
     auto commandContext = device->GetScopedPendingCommandContext(Device::SubmitMode::Normal);
     TextureCopy textureCopy;
     textureCopy.texture = destination.texture;
     textureCopy.mipLevel = destination.mipLevel;
     textureCopy.origin = destination.origin;
     textureCopy.aspect = SelectFormatAspects(destination.texture->GetFormat(), destination.aspect);

     SubresourceRange subresources = GetSubresourcesAffectedByCopy(textureCopy, writeSizePixel);

     Texture* texture = ToBackend(destination.texture);

     return texture->Write(&commandContext, subresources, destination.origin, writeSizePixel,
                           static_cast<const uint8_t*>(data) + dataLayout.offset,
                           dataLayout.bytesPerRow, dataLayout.rowsPerImage);
 }

 bool Queue::HasPendingCommands() const {
     return mPendingCommands.NeedsSubmit();
 }

 ResultOrError<ExecutionSerial> Queue::CheckAndUpdateCompletedSerials() {
     ExecutionSerial completedSerial = ExecutionSerial(mFence->GetCompletedValue());
     if (DAWN_UNLIKELY(completedSerial == ExecutionSerial(UINT64_MAX))) {
         // GetCompletedValue returns UINT64_MAX if the device was removed.
         // Try to query the failure reason.
         ID3D11Device* d3d11Device = ToBackend(GetDevice())->GetD3D11Device();
         DAWN_TRY(CheckHRESULT(d3d11Device->GetDeviceRemovedReason(),
                               "ID3D11Device::GetDeviceRemovedReason"));
         // Otherwise, return a generic device lost error.
         return DAWN_DEVICE_LOST_ERROR("Device lost");
     }

     if (completedSerial <= GetCompletedCommandSerial()) {
         return ExecutionSerial(0);
     }

     return completedSerial;
 }

 void Queue::ForceEventualFlushOfCommands() {}

 MaybeError Queue::WaitForIdleForDestruction() {
     DAWN_TRY(NextSerial());
     // Wait for all in-flight commands to finish executing
     DAWN_TRY(WaitForSerial(GetLastSubmittedCommandSerial()));

     return {};
 }

 MaybeError Queue::NextSerial() {
     IncrementLastSubmittedCommandSerial();

     TRACE_EVENT1(GetDevice()->GetPlatform(), General, "D3D11Device::SignalFence", "serial",
                  uint64_t(GetLastSubmittedCommandSerial()));

     auto commandContext = GetScopedPendingCommandContext(SubmitMode::Passive);
     DAWN_TRY(
         CheckHRESULT(commandContext.Signal(mFence.Get(), uint64_t(GetLastSubmittedCommandSerial())),
                      "D3D11 command queue signal fence"));

     return {};
 }

 MaybeError Queue::WaitForSerial(ExecutionSerial serial) {
     DAWN_TRY(CheckPassedSerials());
     if (GetCompletedCommandSerial() >= serial) {
         return {};
     }

     DAWN_TRY(CheckHRESULT(mFence->SetEventOnCompletion(uint64_t(serial), mFenceEvent),
                           "D3D11 set event on completion"));
     WaitForSingleObject(mFenceEvent, INFINITE);
     return CheckPassedSerials();
 }

 void Queue::SetEventOnCompletion(ExecutionSerial serial, HANDLE event) {
     mFence->SetEventOnCompletion(static_cast<uint64_t>(serial), event);
 }

 }  // namespace dawn::native::d3d11
	// Copyright 2023 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#include "dawn/native/d3d11/QueueD3D11.h"

	#include <utility>

	#include "dawn/native/d3d/D3DError.h"
	#include "dawn/native/d3d11/BufferD3D11.h"
	#include "dawn/native/d3d11/CommandBufferD3D11.h"
	#include "dawn/native/d3d11/DeviceD3D11.h"
	#include "dawn/native/d3d11/SharedFenceD3D11.h"
	#include "dawn/native/d3d11/TextureD3D11.h"
	#include "dawn/platform/DawnPlatform.h"
	#include "dawn/platform/tracing/TraceEvent.h"

	namespace dawn::native::d3d11 {

	ResultOrError<Ref<Queue>> Queue::Create(Device* device, const QueueDescriptor* descriptor) {
	Ref<Queue> queue = AcquireRef(new Queue(device, descriptor));
	DAWN_TRY(queue->Initialize());
	return queue;
	}

	MaybeError Queue::Initialize() {
	// Create the fence.
	DAWN_TRY(CheckHRESULT(ToBackend(GetDevice())
	->GetD3D11Device5()
	->CreateFence(0, D3D11_FENCE_FLAG_SHARED, IID_PPV_ARGS(&mFence)),
	"D3D11: creating fence"));

	// Create the fence event.
	mFenceEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
	DAWN_ASSERT(mFenceEvent != nullptr);

	DAWN_TRY_ASSIGN(mSharedFence, SharedFence::Create(ToBackend(GetDevice()),
	"Internal shared DXGI fence", mFence));

	return {};
	}

	MaybeError Queue::InitializePendingContext() {
	return mPendingCommands.Initialize(ToBackend(GetDevice()));
	}

	void Queue::DestroyImpl() {
	if (mFenceEvent != nullptr) {
	::CloseHandle(mFenceEvent);
	mFenceEvent = nullptr;
	}

	// Release the shared fence here to prevent a ref-cycle with the device, but do not destroy the
	// underlying native fence so that we can return a SharedFence on EndAccess after destruction.
	mSharedFence = nullptr;

	mPendingCommands.Release();
	}

	ResultOrError<Ref<d3d::SharedFence>> Queue::GetOrCreateSharedFence() {
	if (mSharedFence == nullptr) {
	DAWN_ASSERT(!IsAlive());
	return SharedFence::Create(ToBackend(GetDevice()), "Internal shared DXGI fence", mFence);
	}
	return mSharedFence;
	}

	ScopedCommandRecordingContext Queue::GetScopedPendingCommandContext(SubmitMode submitMode) {
	// Callers of GetPendingCommandList do so to record commands. Only reserve a command
	// allocator when it is needed so we don't submit empty command lists
	DAWN_ASSERT(mPendingCommands.IsOpen());

	if (submitMode == SubmitMode::Normal) {
	mPendingCommands.SetNeedsSubmit();
	}

	return ScopedCommandRecordingContext(&mPendingCommands);
	}

	ScopedSwapStateCommandRecordingContext Queue::GetScopedSwapStatePendingCommandContext(
	SubmitMode submitMode) {
	// Callers of GetPendingCommandList do so to record commands. Only reserve a command
	// allocator when it is needed so we don't submit empty command lists
	DAWN_ASSERT(mPendingCommands.IsOpen());

	if (submitMode == SubmitMode::Normal) {
	mPendingCommands.SetNeedsSubmit();
	}

	return ScopedSwapStateCommandRecordingContext(&mPendingCommands);
	}

	MaybeError Queue::SubmitPendingCommands() {
	if (!mPendingCommands.IsOpen() \|\| !mPendingCommands.NeedsSubmit()) {
	return {};
	}

	DAWN_TRY(mPendingCommands.ExecuteCommandList());
	return NextSerial();
	}

	MaybeError Queue::SubmitImpl(uint32_t commandCount, CommandBufferBase* const* commands) {
	// CommandBuffer::Execute() will modify the state of the global immediate device context, it may
	// affect following usage of it.
	// TODO(dawn:1770): figure how if we need to track and restore the state of the immediate device
	// context.
	TRACE_EVENT_BEGIN0(GetDevice()->GetPlatform(), Recording, "CommandBufferD3D11::Execute");
	{
	auto commandContext = GetScopedSwapStatePendingCommandContext(Device::SubmitMode::Normal);
	for (uint32_t i = 0; i < commandCount; ++i) {
	DAWN_TRY(ToBackend(commands[i])->Execute(&commandContext));
	}
	}
	DAWN_TRY(SubmitPendingCommands());
	TRACE_EVENT_END0(GetDevice()->GetPlatform(), Recording, "CommandBufferD3D11::Execute");

	return {};
	}

	MaybeError Queue::WriteBufferImpl(BufferBase* buffer,
	uint64_t bufferOffset,
	const void* data,
	size_t size) {
	if (size == 0) {
	// skip the empty write
	return {};
	}

	auto commandContext = GetScopedPendingCommandContext(Device::SubmitMode::Normal);
	return ToBackend(buffer)->Write(&commandContext, bufferOffset, data, size);
	}

	MaybeError Queue::WriteTextureImpl(const ImageCopyTexture& destination,
	const void* data,
	const TextureDataLayout& dataLayout,
	const Extent3D& writeSizePixel) {
	if (writeSizePixel.width == 0 \|\| writeSizePixel.height == 0 \|\|
	writeSizePixel.depthOrArrayLayers == 0) {
	return {};
	}

	Device* device = ToBackend(GetDevice());
	auto commandContext = device->GetScopedPendingCommandContext(Device::SubmitMode::Normal);
	TextureCopy textureCopy;
	textureCopy.texture = destination.texture;
	textureCopy.mipLevel = destination.mipLevel;
	textureCopy.origin = destination.origin;
	textureCopy.aspect = SelectFormatAspects(destination.texture->GetFormat(), destination.aspect);

	SubresourceRange subresources = GetSubresourcesAffectedByCopy(textureCopy, writeSizePixel);

	Texture* texture = ToBackend(destination.texture);

	return texture->Write(&commandContext, subresources, destination.origin, writeSizePixel,
	static_cast<const uint8_t*>(data) + dataLayout.offset,
	dataLayout.bytesPerRow, dataLayout.rowsPerImage);
	}

	bool Queue::HasPendingCommands() const {
	return mPendingCommands.NeedsSubmit();
	}

	ResultOrError<ExecutionSerial> Queue::CheckAndUpdateCompletedSerials() {
	ExecutionSerial completedSerial = ExecutionSerial(mFence->GetCompletedValue());
	if (DAWN_UNLIKELY(completedSerial == ExecutionSerial(UINT64_MAX))) {
	// GetCompletedValue returns UINT64_MAX if the device was removed.
	// Try to query the failure reason.
	ID3D11Device* d3d11Device = ToBackend(GetDevice())->GetD3D11Device();
	DAWN_TRY(CheckHRESULT(d3d11Device->GetDeviceRemovedReason(),
	"ID3D11Device::GetDeviceRemovedReason"));
	// Otherwise, return a generic device lost error.
	return DAWN_DEVICE_LOST_ERROR("Device lost");
	}

	if (completedSerial <= GetCompletedCommandSerial()) {
	return ExecutionSerial(0);
	}

	return completedSerial;
	}

	void Queue::ForceEventualFlushOfCommands() {}

	MaybeError Queue::WaitForIdleForDestruction() {
	DAWN_TRY(NextSerial());
	// Wait for all in-flight commands to finish executing
	DAWN_TRY(WaitForSerial(GetLastSubmittedCommandSerial()));

	return {};
	}

	MaybeError Queue::NextSerial() {
	IncrementLastSubmittedCommandSerial();

	TRACE_EVENT1(GetDevice()->GetPlatform(), General, "D3D11Device::SignalFence", "serial",
	uint64_t(GetLastSubmittedCommandSerial()));

	auto commandContext = GetScopedPendingCommandContext(SubmitMode::Passive);
	DAWN_TRY(
	CheckHRESULT(commandContext.Signal(mFence.Get(), uint64_t(GetLastSubmittedCommandSerial())),
	"D3D11 command queue signal fence"));

	return {};
	}

	MaybeError Queue::WaitForSerial(ExecutionSerial serial) {
	DAWN_TRY(CheckPassedSerials());
	if (GetCompletedCommandSerial() >= serial) {
	return {};
	}

	DAWN_TRY(CheckHRESULT(mFence->SetEventOnCompletion(uint64_t(serial), mFenceEvent),
	"D3D11 set event on completion"));
	WaitForSingleObject(mFenceEvent, INFINITE);
	return CheckPassedSerials();
	}

	void Queue::SetEventOnCompletion(ExecutionSerial serial, HANDLE event) {
	mFence->SetEventOnCompletion(static_cast<uint64_t>(serial), event);
	}

	} // namespace dawn::native::d3d11