src/dawn/native/opengl/QueueGL.cpp - dawn - Git at Google

 // Copyright 2018 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/opengl/QueueGL.h"

 #include "dawn/native/BlitBufferToDepthStencil.h"
 #include "dawn/native/CommandBuffer.h"
 #include "dawn/native/CommandEncoder.h"
 #include "dawn/native/opengl/BufferGL.h"
 #include "dawn/native/opengl/CommandBufferGL.h"
 #include "dawn/native/opengl/DeviceGL.h"
 #include "dawn/native/opengl/EGLFunctions.h"
 #include "dawn/native/opengl/TextureGL.h"
 #include "dawn/platform/DawnPlatform.h"
 #include "dawn/platform/tracing/TraceEvent.h"

 namespace dawn::native::opengl {

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

 Queue::Queue(Device* device, const QueueDescriptor* descriptor) : QueueBase(device, descriptor) {
     const auto& egl = device->GetEGL(false);

     DAWN_ASSERT(egl.HasExt(EGLExt::FenceSync) || egl.HasExt(EGLExt::ReusableSync));
     mEGLSyncType = egl.HasExt(EGLExt::FenceSync) ? EGL_SYNC_FENCE : EGL_SYNC_REUSABLE_KHR;
 }

 MaybeError Queue::SubmitImpl(uint32_t commandCount, CommandBufferBase* const* commands) {
     TRACE_EVENT_BEGIN0(GetDevice()->GetPlatform(), Recording, "CommandBufferGL::Execute");
     for (uint32_t i = 0; i < commandCount; ++i) {
         DAWN_TRY(ToBackend(commands[i])->Execute());
     }
     TRACE_EVENT_END0(GetDevice()->GetPlatform(), Recording, "CommandBufferGL::Execute");
     return {};
 }

 MaybeError Queue::WriteBufferImpl(BufferBase* buffer,
                                   uint64_t bufferOffset,
                                   const void* data,
                                   size_t size) {
     const OpenGLFunctions& gl = ToBackend(GetDevice())->GetGL();

     ToBackend(buffer)->EnsureDataInitializedAsDestination(bufferOffset, size);

     gl.BindBuffer(GL_ARRAY_BUFFER, ToBackend(buffer)->GetHandle());
     gl.BufferSubData(GL_ARRAY_BUFFER, bufferOffset, size, data);
     buffer->MarkUsedInPendingCommands();
     return {};
 }

 MaybeError Queue::WriteTextureImpl(const ImageCopyTexture& destination,
                                    const void* data,
                                    size_t dataSize,
                                    const TextureDataLayout& dataLayout,
                                    const Extent3D& writeSizePixel) {
     TextureCopy textureCopy;
     textureCopy.texture = destination.texture;
     textureCopy.mipLevel = destination.mipLevel;
     textureCopy.origin = destination.origin;
     textureCopy.aspect = SelectFormatAspects(destination.texture->GetFormat(), destination.aspect);

     DeviceBase* device = GetDevice();
     if (textureCopy.aspect == Aspect::Stencil &&
         (textureCopy.texture->GetFormat().aspects & Aspect::Depth ||
          device->IsToggleEnabled(Toggle::UseBlitForStencilTextureWrite))) {
         // Workaround when write to stencil is unsupported:
         // - when the texture is stencil-only but OES_texture_stencil8 is unavailable.
         // - when the texture is depth-stencil-combined and writing to the stencil aspect.

         // Call WriteTexture to upload data to an intermediate R8Uint texture.
         TextureDescriptor dataTextureDesc = {};
         dataTextureDesc.format = wgpu::TextureFormat::R8Uint;
         dataTextureDesc.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::TextureBinding;
         dataTextureDesc.size = writeSizePixel;
         dataTextureDesc.mipLevelCount = 1;
         Ref<TextureBase> dataTexture;
         DAWN_TRY_ASSIGN(dataTexture, device->CreateTexture(&dataTextureDesc));
         {
             ImageCopyTexture destinationDataTexture;
             destinationDataTexture.texture = dataTexture.Get();
             destinationDataTexture.aspect = wgpu::TextureAspect::All;
             // The size of R8Uint texture equals to writeSizePixel and only has 1 mip level.
             // So the x,y,z origins and mipLevel are always 0.
             destinationDataTexture.mipLevel = 0;
             destinationDataTexture.origin = {0, 0, 0};
             DAWN_TRY_CONTEXT(WriteTextureImpl(destinationDataTexture, data, dataSize, dataLayout,
                                               writeSizePixel),
                              "writing to stencil aspect of %s using blit workaround when writing "
                              "to an intermediate r8uint texture.",
                              textureCopy.texture.Get());
         }

         // Blit from R8Uint texture to the stencil texture.
         Ref<CommandEncoderBase> commandEncoder;
         DAWN_TRY_ASSIGN(commandEncoder, device->CreateCommandEncoder());
         DAWN_TRY_CONTEXT(BlitR8ToStencil(device, commandEncoder.Get(), dataTexture.Get(),
                                          textureCopy, writeSizePixel),
                          "writing to stencil aspect of %s using blit workaround.",
                          textureCopy.texture.Get());

         Ref<CommandBufferBase> commandBuffer;
         DAWN_TRY_ASSIGN(commandBuffer, commandEncoder->Finish());
         CommandBufferBase* commands = commandBuffer.Get();
         APISubmit(1, &commands);
         return {};
     }

     SubresourceRange range = GetSubresourcesAffectedByCopy(textureCopy, writeSizePixel);
     if (IsCompleteSubresourceCopiedTo(destination.texture, writeSizePixel, destination.mipLevel,
                                       destination.aspect)) {
         destination.texture->SetIsSubresourceContentInitialized(true, range);
     } else {
         DAWN_TRY(ToBackend(destination.texture)->EnsureSubresourceContentInitialized(range));
     }
     DoTexSubImage(ToBackend(GetDevice())->GetGL(), textureCopy, data, dataLayout, writeSizePixel);
     return {};
 }

 void Queue::OnGLUsed() {
     mHasPendingCommands = true;
 }

 GLenum Queue::ClientWaitSync(EGLSync sync, Nanoseconds timeout) {
     const Device* device = ToBackend(GetDevice());
     const EGLFunctions& egl = device->GetEGL(/*makeCurrent=*/false);

     return egl.ClientWaitSync(device->GetEGLDisplay(), sync, EGL_SYNC_FLUSH_COMMANDS_BIT,
                               uint64_t(timeout));
 }

 ResultOrError<bool> Queue::WaitForQueueSerial(ExecutionSerial serial, Nanoseconds timeout) {
     // Search for the first fence >= serial.
     return mFencesInFlight.Use([&](auto fencesInFlight) -> ResultOrError<bool> {
         EGLSync waitSync = nullptr;
         for (auto it = fencesInFlight->begin(); it != fencesInFlight->end(); ++it) {
             if (it->second >= serial) {
                 waitSync = it->first;
                 break;
             }
         }
         if (waitSync == nullptr) {
             // Fence sync not found. This serial must have already completed.
             // Return a success status.
             return true;
         }

         // Wait for the fence sync.
         GLenum result = ClientWaitSync(waitSync, timeout);
         switch (result) {
             case EGL_TIMEOUT_EXPIRED:
                 return false;
             case EGL_CONDITION_SATISFIED:
                 return true;
             case EGL_FALSE:
                 return DAWN_INTERNAL_ERROR("glClientWaitSync failed");
             default:
                 DAWN_UNREACHABLE();
         }
     });
 }

 void Queue::SubmitFenceSync() {
     mFencesInFlight.Use([&](auto fencesInFlight) {
         if (!mHasPendingCommands) {
             return;
         }
         const Device* device = ToBackend(GetDevice());
         const EGLFunctions& egl = device->GetEGL(/*makeCurrent=*/true);

         EGLSync sync = egl.CreateSync(device->GetEGLDisplay(), mEGLSyncType, nullptr);
         DAWN_ASSERT(sync != EGL_NO_SYNC);

         // Signal the sync if it is EGL_SYNC_REUSABLE_KHR. On the other hand,
         // EGL_SYNC_FENCE_KHR has its signal scheduled on creation.
         if (mEGLSyncType == EGL_SYNC_REUSABLE_KHR) {
             EGLBoolean status = egl.SignalSync(device->GetEGLDisplay(), sync, EGL_SIGNALED);
             DAWN_ASSERT(status == EGL_TRUE);
         }

         IncrementLastSubmittedCommandSerial();
         fencesInFlight->emplace_back(sync, GetLastSubmittedCommandSerial());
         mHasPendingCommands = false;
     });
 }

 bool Queue::HasPendingCommands() const {
     return mHasPendingCommands;
 }

 MaybeError Queue::SubmitPendingCommands() {
     SubmitFenceSync();
     return {};
 }

 ResultOrError<ExecutionSerial> Queue::CheckAndUpdateCompletedSerials() {
     const Device* device = ToBackend(GetDevice());
     const EGLFunctions& egl = device->GetEGL(/*makeCurrent=*/false);
     EGLDisplay display = device->GetEGLDisplay();

     return mFencesInFlight.Use([&](auto fencesInFlight) {
         ExecutionSerial fenceSerial{0};
         while (!fencesInFlight->empty()) {
             auto [sync, tentativeSerial] = fencesInFlight->front();

             // Fence are added in order, so we can stop searching as soon
             // as we see one that's not ready.
             GLenum result = ClientWaitSync(sync, Nanoseconds(0));
             if (result == EGL_TIMEOUT_EXPIRED) {
                 return fenceSerial;
             }
             // Update fenceSerial since fence is ready.
             fenceSerial = tentativeSerial;

             egl.DestroySync(display, sync);

             fencesInFlight->pop_front();

             DAWN_ASSERT(fenceSerial > GetCompletedCommandSerial());
         }
         return fenceSerial;
     });
 }

 void Queue::ForceEventualFlushOfCommands() {
     mHasPendingCommands = true;
 }

 MaybeError Queue::WaitForIdleForDestruction() {
     const OpenGLFunctions& gl = ToBackend(GetDevice())->GetGL();
     gl.Finish();
     DAWN_TRY(CheckPassedSerials());
     DAWN_ASSERT(mFencesInFlight->empty());
     mHasPendingCommands = false;
     return {};
 }

 }  // namespace dawn::native::opengl
	// Copyright 2018 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/opengl/QueueGL.h"

	#include "dawn/native/BlitBufferToDepthStencil.h"
	#include "dawn/native/CommandBuffer.h"
	#include "dawn/native/CommandEncoder.h"
	#include "dawn/native/opengl/BufferGL.h"
	#include "dawn/native/opengl/CommandBufferGL.h"
	#include "dawn/native/opengl/DeviceGL.h"
	#include "dawn/native/opengl/EGLFunctions.h"
	#include "dawn/native/opengl/TextureGL.h"
	#include "dawn/platform/DawnPlatform.h"
	#include "dawn/platform/tracing/TraceEvent.h"

	namespace dawn::native::opengl {

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

	Queue::Queue(Device* device, const QueueDescriptor* descriptor) : QueueBase(device, descriptor) {
	const auto& egl = device->GetEGL(false);

	DAWN_ASSERT(egl.HasExt(EGLExt::FenceSync) \|\| egl.HasExt(EGLExt::ReusableSync));
	mEGLSyncType = egl.HasExt(EGLExt::FenceSync) ? EGL_SYNC_FENCE : EGL_SYNC_REUSABLE_KHR;
	}

	MaybeError Queue::SubmitImpl(uint32_t commandCount, CommandBufferBase* const* commands) {
	TRACE_EVENT_BEGIN0(GetDevice()->GetPlatform(), Recording, "CommandBufferGL::Execute");
	for (uint32_t i = 0; i < commandCount; ++i) {
	DAWN_TRY(ToBackend(commands[i])->Execute());
	}
	TRACE_EVENT_END0(GetDevice()->GetPlatform(), Recording, "CommandBufferGL::Execute");
	return {};
	}

	MaybeError Queue::WriteBufferImpl(BufferBase* buffer,
	uint64_t bufferOffset,
	const void* data,
	size_t size) {
	const OpenGLFunctions& gl = ToBackend(GetDevice())->GetGL();

	ToBackend(buffer)->EnsureDataInitializedAsDestination(bufferOffset, size);

	gl.BindBuffer(GL_ARRAY_BUFFER, ToBackend(buffer)->GetHandle());
	gl.BufferSubData(GL_ARRAY_BUFFER, bufferOffset, size, data);
	buffer->MarkUsedInPendingCommands();
	return {};
	}

	MaybeError Queue::WriteTextureImpl(const ImageCopyTexture& destination,
	const void* data,
	size_t dataSize,
	const TextureDataLayout& dataLayout,
	const Extent3D& writeSizePixel) {
	TextureCopy textureCopy;
	textureCopy.texture = destination.texture;
	textureCopy.mipLevel = destination.mipLevel;
	textureCopy.origin = destination.origin;
	textureCopy.aspect = SelectFormatAspects(destination.texture->GetFormat(), destination.aspect);

	DeviceBase* device = GetDevice();
	if (textureCopy.aspect == Aspect::Stencil &&
	(textureCopy.texture->GetFormat().aspects & Aspect::Depth \|\|
	device->IsToggleEnabled(Toggle::UseBlitForStencilTextureWrite))) {
	// Workaround when write to stencil is unsupported:
	// - when the texture is stencil-only but OES_texture_stencil8 is unavailable.
	// - when the texture is depth-stencil-combined and writing to the stencil aspect.

	// Call WriteTexture to upload data to an intermediate R8Uint texture.
	TextureDescriptor dataTextureDesc = {};
	dataTextureDesc.format = wgpu::TextureFormat::R8Uint;
	dataTextureDesc.usage = wgpu::TextureUsage::CopyDst \| wgpu::TextureUsage::TextureBinding;
	dataTextureDesc.size = writeSizePixel;
	dataTextureDesc.mipLevelCount = 1;
	Ref<TextureBase> dataTexture;
	DAWN_TRY_ASSIGN(dataTexture, device->CreateTexture(&dataTextureDesc));
	{
	ImageCopyTexture destinationDataTexture;
	destinationDataTexture.texture = dataTexture.Get();
	destinationDataTexture.aspect = wgpu::TextureAspect::All;
	// The size of R8Uint texture equals to writeSizePixel and only has 1 mip level.
	// So the x,y,z origins and mipLevel are always 0.
	destinationDataTexture.mipLevel = 0;
	destinationDataTexture.origin = {0, 0, 0};
	DAWN_TRY_CONTEXT(WriteTextureImpl(destinationDataTexture, data, dataSize, dataLayout,
	writeSizePixel),
	"writing to stencil aspect of %s using blit workaround when writing "
	"to an intermediate r8uint texture.",
	textureCopy.texture.Get());
	}

	// Blit from R8Uint texture to the stencil texture.
	Ref<CommandEncoderBase> commandEncoder;
	DAWN_TRY_ASSIGN(commandEncoder, device->CreateCommandEncoder());
	DAWN_TRY_CONTEXT(BlitR8ToStencil(device, commandEncoder.Get(), dataTexture.Get(),
	textureCopy, writeSizePixel),
	"writing to stencil aspect of %s using blit workaround.",
	textureCopy.texture.Get());

	Ref<CommandBufferBase> commandBuffer;
	DAWN_TRY_ASSIGN(commandBuffer, commandEncoder->Finish());
	CommandBufferBase* commands = commandBuffer.Get();
	APISubmit(1, &commands);
	return {};
	}

	SubresourceRange range = GetSubresourcesAffectedByCopy(textureCopy, writeSizePixel);
	if (IsCompleteSubresourceCopiedTo(destination.texture, writeSizePixel, destination.mipLevel,
	destination.aspect)) {
	destination.texture->SetIsSubresourceContentInitialized(true, range);
	} else {
	DAWN_TRY(ToBackend(destination.texture)->EnsureSubresourceContentInitialized(range));
	}
	DoTexSubImage(ToBackend(GetDevice())->GetGL(), textureCopy, data, dataLayout, writeSizePixel);
	return {};
	}

	void Queue::OnGLUsed() {
	mHasPendingCommands = true;
	}

	GLenum Queue::ClientWaitSync(EGLSync sync, Nanoseconds timeout) {
	const Device* device = ToBackend(GetDevice());
	const EGLFunctions& egl = device->GetEGL(/makeCurrent=/false);

	return egl.ClientWaitSync(device->GetEGLDisplay(), sync, EGL_SYNC_FLUSH_COMMANDS_BIT,
	uint64_t(timeout));
	}

	ResultOrError<bool> Queue::WaitForQueueSerial(ExecutionSerial serial, Nanoseconds timeout) {
	// Search for the first fence >= serial.
	return mFencesInFlight.Use([&](auto fencesInFlight) -> ResultOrError<bool> {
	EGLSync waitSync = nullptr;
	for (auto it = fencesInFlight->begin(); it != fencesInFlight->end(); ++it) {
	if (it->second >= serial) {
	waitSync = it->first;
	break;
	}
	}
	if (waitSync == nullptr) {
	// Fence sync not found. This serial must have already completed.
	// Return a success status.
	return true;
	}

	// Wait for the fence sync.
	GLenum result = ClientWaitSync(waitSync, timeout);
	switch (result) {
	case EGL_TIMEOUT_EXPIRED:
	return false;
	case EGL_CONDITION_SATISFIED:
	return true;
	case EGL_FALSE:
	return DAWN_INTERNAL_ERROR("glClientWaitSync failed");
	default:
	DAWN_UNREACHABLE();
	}
	});
	}

	void Queue::SubmitFenceSync() {
	mFencesInFlight.Use([&](auto fencesInFlight) {
	if (!mHasPendingCommands) {
	return;
	}
	const Device* device = ToBackend(GetDevice());
	const EGLFunctions& egl = device->GetEGL(/makeCurrent=/true);

	EGLSync sync = egl.CreateSync(device->GetEGLDisplay(), mEGLSyncType, nullptr);
	DAWN_ASSERT(sync != EGL_NO_SYNC);

	// Signal the sync if it is EGL_SYNC_REUSABLE_KHR. On the other hand,
	// EGL_SYNC_FENCE_KHR has its signal scheduled on creation.
	if (mEGLSyncType == EGL_SYNC_REUSABLE_KHR) {
	EGLBoolean status = egl.SignalSync(device->GetEGLDisplay(), sync, EGL_SIGNALED);
	DAWN_ASSERT(status == EGL_TRUE);
	}

	IncrementLastSubmittedCommandSerial();
	fencesInFlight->emplace_back(sync, GetLastSubmittedCommandSerial());
	mHasPendingCommands = false;
	});
	}

	bool Queue::HasPendingCommands() const {
	return mHasPendingCommands;
	}

	MaybeError Queue::SubmitPendingCommands() {
	SubmitFenceSync();
	return {};
	}

	ResultOrError<ExecutionSerial> Queue::CheckAndUpdateCompletedSerials() {
	const Device* device = ToBackend(GetDevice());
	const EGLFunctions& egl = device->GetEGL(/makeCurrent=/false);
	EGLDisplay display = device->GetEGLDisplay();

	return mFencesInFlight.Use([&](auto fencesInFlight) {
	ExecutionSerial fenceSerial{0};
	while (!fencesInFlight->empty()) {
	auto [sync, tentativeSerial] = fencesInFlight->front();

	// Fence are added in order, so we can stop searching as soon
	// as we see one that's not ready.
	GLenum result = ClientWaitSync(sync, Nanoseconds(0));
	if (result == EGL_TIMEOUT_EXPIRED) {
	return fenceSerial;
	}
	// Update fenceSerial since fence is ready.
	fenceSerial = tentativeSerial;

	egl.DestroySync(display, sync);

	fencesInFlight->pop_front();

	DAWN_ASSERT(fenceSerial > GetCompletedCommandSerial());
	}
	return fenceSerial;
	});
	}

	void Queue::ForceEventualFlushOfCommands() {
	mHasPendingCommands = true;
	}

	MaybeError Queue::WaitForIdleForDestruction() {
	const OpenGLFunctions& gl = ToBackend(GetDevice())->GetGL();
	gl.Finish();
	DAWN_TRY(CheckPassedSerials());
	DAWN_ASSERT(mFencesInFlight->empty());
	mHasPendingCommands = false;
	return {};
	}

	} // namespace dawn::native::opengl