corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1712963: Simplify mValid handling in some WebGPU classes. r=webgpu-reviewers,nical

Browse Source 
Primarily this standardizes ComputePassEncoder, RenderBundleEncoder and
RenderPassEncoder on the "if (!mValid)" pattern for early exits for ffi
functions. It also attempts to make each class have at most two ways to
become invalid:

1) RenderBundleEncoder and RenderPassEncoder can become invalid at
construction time.
2) Those classes and ComputePassEncoder all now have an implementation
of their ::Cleanup method, which is called from the destructor, and the
Cleanup method is responsible for making the object invalid and
releasing internal resources (possibly by calling another method).

Together these changes make it easier to reason about what mValid means
for these classes, and what is the state of their internal resources.

Differential Revision: https://phabricator.services.mozilla.com/D208183
This commit is contained in:
Brad Werth
2024-04-23 15:28:22 +00:00
parent 004090bf97
commit b1a7f826f6
5 changed files with 175 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
dom/webgpu/ComputePassEncoder.cpp
View File

@@ -38,65 +38,73 @@ ComputePassEncoder::ComputePassEncoder(
CommandEncoder* const aParent, const dom::GPUComputePassDescriptor& aDesc)
: ChildOf(aParent), mPass(BeginComputePass(aParent->mId, aDesc)) {}
ComputePassEncoder::~ComputePassEncoder() {
ComputePassEncoder::~ComputePassEncoder() { Cleanup(); }
void ComputePassEncoder::Cleanup() {
if (mValid) {
mValid = false;
End();
}
}
void ComputePassEncoder::SetBindGroup(
uint32_t aSlot, const BindGroup& aBindGroup,
const dom::Sequence<uint32_t>& aDynamicOffsets) {
if (mValid) {
mUsedBindGroups.AppendElement(&aBindGroup);
ffi::wgpu_recorded_compute_pass_set_bind_group(
mPass.get(), aSlot, aBindGroup.mId, aDynamicOffsets.Elements(),
aDynamicOffsets.Length());
if (!mValid) {
return;
}
mUsedBindGroups.AppendElement(&aBindGroup);
ffi::wgpu_recorded_compute_pass_set_bind_group(
mPass.get(), aSlot, aBindGroup.mId, aDynamicOffsets.Elements(),
aDynamicOffsets.Length());
}
void ComputePassEncoder::SetPipeline(const ComputePipeline& aPipeline) {
if (mValid) {
mUsedPipelines.AppendElement(&aPipeline);
ffi::wgpu_recorded_compute_pass_set_pipeline(mPass.get(), aPipeline.mId);
if (!mValid) {
return;
}
mUsedPipelines.AppendElement(&aPipeline);
ffi::wgpu_recorded_compute_pass_set_pipeline(mPass.get(), aPipeline.mId);
}
void ComputePassEncoder::DispatchWorkgroups(uint32_t workgroupCountX,
uint32_t workgroupCountY,
uint32_t workgroupCountZ) {
if (mValid) {
ffi::wgpu_recorded_compute_pass_dispatch_workgroups(
mPass.get(), workgroupCountX, workgroupCountY, workgroupCountZ);
if (!mValid) {
return;
}
ffi::wgpu_recorded_compute_pass_dispatch_workgroups(
mPass.get(), workgroupCountX, workgroupCountY, workgroupCountZ);
}
void ComputePassEncoder::DispatchWorkgroupsIndirect(
const Buffer& aIndirectBuffer, uint64_t aIndirectOffset) {
if (mValid) {
ffi::wgpu_recorded_compute_pass_dispatch_workgroups_indirect(
mPass.get(), aIndirectBuffer.mId, aIndirectOffset);
if (!mValid) {
return;
}
ffi::wgpu_recorded_compute_pass_dispatch_workgroups_indirect(
mPass.get(), aIndirectBuffer.mId, aIndirectOffset);
}
void ComputePassEncoder::PushDebugGroup(const nsAString& aString) {
if (mValid) {
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_compute_pass_push_debug_group(mPass.get(), utf8.get(),
0);
if (!mValid) {
return;
}
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_compute_pass_push_debug_group(mPass.get(), utf8.get(), 0);
}
void ComputePassEncoder::PopDebugGroup() {
if (mValid) {
ffi::wgpu_recorded_compute_pass_pop_debug_group(mPass.get());
if (!mValid) {
return;
}
ffi::wgpu_recorded_compute_pass_pop_debug_group(mPass.get());
}
void ComputePassEncoder::InsertDebugMarker(const nsAString& aString) {
if (mValid) {
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_compute_pass_insert_debug_marker(mPass.get(), utf8.get(),
0);
if (!mValid) {
return;
}
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_compute_pass_insert_debug_marker(mPass.get(), utf8.get(),
0);
}
void ComputePassEncoder::End() {

2
dom/webgpu/ComputePassEncoder.h
View File

@@ -41,7 +41,7 @@ class ComputePassEncoder final : public ObjectBase,
private:
virtual ~ComputePassEncoder();
void Cleanup() {}
void Cleanup();
std::unique_ptr<ffi::WGPURecordedComputePass, ffiWGPUComputePassDeleter>
mPass;

103
dom/webgpu/RenderBundleEncoder.cpp
View File

@@ -72,7 +72,7 @@ RenderBundleEncoder::RenderBundleEncoder(
const dom::GPURenderBundleEncoderDescriptor& aDesc)
: ChildOf(aParent),
mEncoder(CreateRenderBundleEncoder(aParent->mId, aDesc, aBridge)) {
mValid = mEncoder.get() != nullptr;
mValid = !!mEncoder;
}
RenderBundleEncoder::~RenderBundleEncoder() { Cleanup(); }
@@ -80,100 +80,112 @@ RenderBundleEncoder::~RenderBundleEncoder() { Cleanup(); }
void RenderBundleEncoder::Cleanup() {
if (mValid) {
mValid = false;
mEncoder.release();
}
}
void RenderBundleEncoder::SetBindGroup(
uint32_t aSlot, const BindGroup& aBindGroup,
const dom::Sequence<uint32_t>& aDynamicOffsets) {
if (mValid) {
mUsedBindGroups.AppendElement(&aBindGroup);
ffi::wgpu_render_bundle_set_bind_group(
mEncoder.get(), aSlot, aBindGroup.mId, aDynamicOffsets.Elements(),
aDynamicOffsets.Length());
if (!mValid) {
return;
}
mUsedBindGroups.AppendElement(&aBindGroup);
ffi::wgpu_render_bundle_set_bind_group(mEncoder.get(), aSlot, aBindGroup.mId,
aDynamicOffsets.Elements(),
aDynamicOffsets.Length());
}
void RenderBundleEncoder::SetPipeline(const RenderPipeline& aPipeline) {
if (mValid) {
mUsedPipelines.AppendElement(&aPipeline);
ffi::wgpu_render_bundle_set_pipeline(mEncoder.get(), aPipeline.mId);
if (!mValid) {
return;
}
mUsedPipelines.AppendElement(&aPipeline);
ffi::wgpu_render_bundle_set_pipeline(mEncoder.get(), aPipeline.mId);
}
void RenderBundleEncoder::SetIndexBuffer(
const Buffer& aBuffer, const dom::GPUIndexFormat& aIndexFormat,
uint64_t aOffset, uint64_t aSize) {
if (mValid) {
mUsedBuffers.AppendElement(&aBuffer);
const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
? ffi::WGPUIndexFormat_Uint32
: ffi::WGPUIndexFormat_Uint16;
ffi::wgpu_render_bundle_set_index_buffer(mEncoder.get(), aBuffer.mId,
iformat, aOffset, aSize);
if (!mValid) {
return;
}
mUsedBuffers.AppendElement(&aBuffer);
const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
? ffi::WGPUIndexFormat_Uint32
: ffi::WGPUIndexFormat_Uint16;
ffi::wgpu_render_bundle_set_index_buffer(mEncoder.get(), aBuffer.mId, iformat,
aOffset, aSize);
}
void RenderBundleEncoder::SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer,
uint64_t aOffset, uint64_t aSize) {
if (mValid) {
mUsedBuffers.AppendElement(&aBuffer);
ffi::wgpu_render_bundle_set_vertex_buffer(mEncoder.get(), aSlot,
aBuffer.mId, aOffset, aSize);
if (!mValid) {
return;
}
mUsedBuffers.AppendElement(&aBuffer);
ffi::wgpu_render_bundle_set_vertex_buffer(mEncoder.get(), aSlot, aBuffer.mId,
aOffset, aSize);
}
void RenderBundleEncoder::Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
uint32_t aFirstVertex, uint32_t aFirstInstance) {
if (mValid) {
ffi::wgpu_render_bundle_draw(mEncoder.get(), aVertexCount, aInstanceCount,
aFirstVertex, aFirstInstance);
if (!mValid) {
return;
}
ffi::wgpu_render_bundle_draw(mEncoder.get(), aVertexCount, aInstanceCount,
aFirstVertex, aFirstInstance);
}
void RenderBundleEncoder::DrawIndexed(uint32_t aIndexCount,
uint32_t aInstanceCount,
uint32_t aFirstIndex, int32_t aBaseVertex,
uint32_t aFirstInstance) {
if (mValid) {
ffi::wgpu_render_bundle_draw_indexed(mEncoder.get(), aIndexCount,
aInstanceCount, aFirstIndex,
aBaseVertex, aFirstInstance);
if (!mValid) {
return;
}
ffi::wgpu_render_bundle_draw_indexed(mEncoder.get(), aIndexCount,
aInstanceCount, aFirstIndex, aBaseVertex,
aFirstInstance);
}
void RenderBundleEncoder::DrawIndirect(const Buffer& aIndirectBuffer,
uint64_t aIndirectOffset) {
if (mValid) {
ffi::wgpu_render_bundle_draw_indirect(mEncoder.get(), aIndirectBuffer.mId,
aIndirectOffset);
if (!mValid) {
return;
}
ffi::wgpu_render_bundle_draw_indirect(mEncoder.get(), aIndirectBuffer.mId,
aIndirectOffset);
}
void RenderBundleEncoder::DrawIndexedIndirect(const Buffer& aIndirectBuffer,
uint64_t aIndirectOffset) {
if (mValid) {
ffi::wgpu_render_bundle_draw_indexed_indirect(
mEncoder.get(), aIndirectBuffer.mId, aIndirectOffset);
if (!mValid) {
return;
}
ffi::wgpu_render_bundle_draw_indexed_indirect(
mEncoder.get(), aIndirectBuffer.mId, aIndirectOffset);
}
void RenderBundleEncoder::PushDebugGroup(const nsAString& aString) {
if (mValid) {
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_render_bundle_push_debug_group(mEncoder.get(), utf8.get());
if (!mValid) {
return;
}
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_render_bundle_push_debug_group(mEncoder.get(), utf8.get());
}
void RenderBundleEncoder::PopDebugGroup() {
if (mValid) {
ffi::wgpu_render_bundle_pop_debug_group(mEncoder.get());
if (!mValid) {
return;
}
ffi::wgpu_render_bundle_pop_debug_group(mEncoder.get());
}
void RenderBundleEncoder::InsertDebugMarker(const nsAString& aString) {
if (mValid) {
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_render_bundle_insert_debug_marker(mEncoder.get(), utf8.get());
if (!mValid) {
return;
}
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_render_bundle_insert_debug_marker(mEncoder.get(), utf8.get());
}
already_AddRefed<RenderBundle> RenderBundleEncoder::Finish(
@@ -189,11 +201,8 @@ already_AddRefed<RenderBundle> RenderBundleEncoder::Finish(
ipc::ByteBuf bb;
RawId id;
if (mValid) {
mValid = false;
auto* encoder = mEncoder.release();
id = ffi::wgpu_client_create_render_bundle(bridge->GetClient(), encoder,
deviceId, &desc, ToFFI(&bb));
id = ffi::wgpu_client_create_render_bundle(
bridge->GetClient(), mEncoder.get(), deviceId, &desc, ToFFI(&bb));
} else {
id = ffi::wgpu_client_create_render_bundle_error(
@@ -204,6 +213,8 @@ already_AddRefed<RenderBundle> RenderBundleEncoder::Finish(
bridge->SendDeviceAction(deviceId, std::move(bb));
}
Cleanup();
RefPtr<RenderBundle> bundle = new RenderBundle(mParent, id);
return bundle.forget();
}

148
dom/webgpu/RenderPassEncoder.cpp
View File

@@ -157,8 +157,8 @@ ffi::WGPURecordedRenderPass* BeginRenderPass(
RenderPassEncoder::RenderPassEncoder(CommandEncoder* const aParent,
const dom::GPURenderPassDescriptor& aDesc)
: ChildOf(aParent), mPass(BeginRenderPass(aParent, aDesc)) {
if (!mPass) {
mValid = false;
mValid = !!mPass;
if (!mValid) {
return;
}
@@ -171,149 +171,165 @@ RenderPassEncoder::RenderPassEncoder(CommandEncoder* const aParent,
}
}
RenderPassEncoder::~RenderPassEncoder() {
RenderPassEncoder::~RenderPassEncoder() { Cleanup(); }
void RenderPassEncoder::Cleanup() {
if (mValid) {
mValid = false;
End();
}
}
void RenderPassEncoder::SetBindGroup(
uint32_t aSlot, const BindGroup& aBindGroup,
const dom::Sequence<uint32_t>& aDynamicOffsets) {
if (mValid) {
mUsedBindGroups.AppendElement(&aBindGroup);
ffi::wgpu_recorded_render_pass_set_bind_group(
mPass.get(), aSlot, aBindGroup.mId, aDynamicOffsets.Elements(),
aDynamicOffsets.Length());
if (!mValid) {
return;
}
mUsedBindGroups.AppendElement(&aBindGroup);
ffi::wgpu_recorded_render_pass_set_bind_group(
mPass.get(), aSlot, aBindGroup.mId, aDynamicOffsets.Elements(),
aDynamicOffsets.Length());
}
void RenderPassEncoder::SetPipeline(const RenderPipeline& aPipeline) {
if (mValid) {
mUsedPipelines.AppendElement(&aPipeline);
ffi::wgpu_recorded_render_pass_set_pipeline(mPass.get(), aPipeline.mId);
if (!mValid) {
return;
}
mUsedPipelines.AppendElement(&aPipeline);
ffi::wgpu_recorded_render_pass_set_pipeline(mPass.get(), aPipeline.mId);
}
void RenderPassEncoder::SetIndexBuffer(const Buffer& aBuffer,
const dom::GPUIndexFormat& aIndexFormat,
uint64_t aOffset, uint64_t aSize) {
if (mValid) {
mUsedBuffers.AppendElement(&aBuffer);
const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
? ffi::WGPUIndexFormat_Uint32
: ffi::WGPUIndexFormat_Uint16;
ffi::wgpu_recorded_render_pass_set_index_buffer(mPass.get(), aBuffer.mId,
iformat, aOffset, aSize);
if (!mValid) {
return;
}
mUsedBuffers.AppendElement(&aBuffer);
const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
? ffi::WGPUIndexFormat_Uint32
: ffi::WGPUIndexFormat_Uint16;
ffi::wgpu_recorded_render_pass_set_index_buffer(mPass.get(), aBuffer.mId,
iformat, aOffset, aSize);
}
void RenderPassEncoder::SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer,
uint64_t aOffset, uint64_t aSize) {
if (mValid) {
mUsedBuffers.AppendElement(&aBuffer);
ffi::wgpu_recorded_render_pass_set_vertex_buffer(
mPass.get(), aSlot, aBuffer.mId, aOffset, aSize);
if (!mValid) {
return;
}
mUsedBuffers.AppendElement(&aBuffer);
ffi::wgpu_recorded_render_pass_set_vertex_buffer(mPass.get(), aSlot,
aBuffer.mId, aOffset, aSize);
}
void RenderPassEncoder::Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
uint32_t aFirstVertex, uint32_t aFirstInstance) {
if (mValid) {
ffi::wgpu_recorded_render_pass_draw(mPass.get(), aVertexCount,
aInstanceCount, aFirstVertex,
aFirstInstance);
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_draw(mPass.get(), aVertexCount, aInstanceCount,
aFirstVertex, aFirstInstance);
}
void RenderPassEncoder::DrawIndexed(uint32_t aIndexCount,
uint32_t aInstanceCount,
uint32_t aFirstIndex, int32_t aBaseVertex,
uint32_t aFirstInstance) {
if (mValid) {
ffi::wgpu_recorded_render_pass_draw_indexed(mPass.get(), aIndexCount,
aInstanceCount, aFirstIndex,
aBaseVertex, aFirstInstance);
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_draw_indexed(mPass.get(), aIndexCount,
aInstanceCount, aFirstIndex,
aBaseVertex, aFirstInstance);
}
void RenderPassEncoder::DrawIndirect(const Buffer& aIndirectBuffer,
uint64_t aIndirectOffset) {
if (mValid) {
ffi::wgpu_recorded_render_pass_draw_indirect(
mPass.get(), aIndirectBuffer.mId, aIndirectOffset);
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_draw_indirect(mPass.get(), aIndirectBuffer.mId,
aIndirectOffset);
}
void RenderPassEncoder::DrawIndexedIndirect(const Buffer& aIndirectBuffer,
uint64_t aIndirectOffset) {
if (mValid) {
ffi::wgpu_recorded_render_pass_draw_indexed_indirect(
mPass.get(), aIndirectBuffer.mId, aIndirectOffset);
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_draw_indexed_indirect(
mPass.get(), aIndirectBuffer.mId, aIndirectOffset);
}
void RenderPassEncoder::SetViewport(float x, float y, float width, float height,
float minDepth, float maxDepth) {
if (mValid) {
ffi::wgpu_recorded_render_pass_set_viewport(mPass.get(), x, y, width,
height, minDepth, maxDepth);
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_set_viewport(mPass.get(), x, y, width, height,
minDepth, maxDepth);
}
void RenderPassEncoder::SetScissorRect(uint32_t x, uint32_t y, uint32_t width,
uint32_t height) {
if (mValid) {
ffi::wgpu_recorded_render_pass_set_scissor_rect(mPass.get(), x, y, width,
height);
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_set_scissor_rect(mPass.get(), x, y, width,
height);
}
void RenderPassEncoder::SetBlendConstant(
const dom::DoubleSequenceOrGPUColorDict& color) {
if (mValid) {
ffi::WGPUColor aColor = ConvertColor(color);
ffi::wgpu_recorded_render_pass_set_blend_constant(mPass.get(), &aColor);
if (!mValid) {
return;
}
ffi::WGPUColor aColor = ConvertColor(color);
ffi::wgpu_recorded_render_pass_set_blend_constant(mPass.get(), &aColor);
}
void RenderPassEncoder::SetStencilReference(uint32_t reference) {
if (mValid) {
ffi::wgpu_recorded_render_pass_set_stencil_reference(mPass.get(),
reference);
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_set_stencil_reference(mPass.get(), reference);
}
void RenderPassEncoder::ExecuteBundles(
const dom::Sequence<OwningNonNull<RenderBundle>>& aBundles) {
if (mValid) {
nsTArray<ffi::WGPURenderBundleId> renderBundles(aBundles.Length());
for (const auto& bundle : aBundles) {
mUsedRenderBundles.AppendElement(bundle);
renderBundles.AppendElement(bundle->mId);
}
ffi::wgpu_recorded_render_pass_execute_bundles(
mPass.get(), renderBundles.Elements(), renderBundles.Length());
if (!mValid) {
return;
}
nsTArray<ffi::WGPURenderBundleId> renderBundles(aBundles.Length());
for (const auto& bundle : aBundles) {
mUsedRenderBundles.AppendElement(bundle);
renderBundles.AppendElement(bundle->mId);
}
ffi::wgpu_recorded_render_pass_execute_bundles(
mPass.get(), renderBundles.Elements(), renderBundles.Length());
}
void RenderPassEncoder::PushDebugGroup(const nsAString& aString) {
if (mValid) {
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_render_pass_push_debug_group(mPass.get(), utf8.get(), 0);
if (!mValid) {
return;
}
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_render_pass_push_debug_group(mPass.get(), utf8.get(), 0);
}
void RenderPassEncoder::PopDebugGroup() {
if (mValid) {
ffi::wgpu_recorded_render_pass_pop_debug_group(mPass.get());
if (!mValid) {
return;
}
ffi::wgpu_recorded_render_pass_pop_debug_group(mPass.get());
}
void RenderPassEncoder::InsertDebugMarker(const nsAString& aString) {
if (mValid) {
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_render_pass_insert_debug_marker(mPass.get(), utf8.get(),
0);
if (!mValid) {
return;
}
const NS_ConvertUTF16toUTF8 utf8(aString);
ffi::wgpu_recorded_render_pass_insert_debug_marker(mPass.get(), utf8.get(),
0);
}
void RenderPassEncoder::End() {

2
dom/webgpu/RenderPassEncoder.h
View File

@@ -49,7 +49,7 @@ class RenderPassEncoder final : public ObjectBase,
protected:
virtual ~RenderPassEncoder();
void Cleanup() {}
void Cleanup();
std::unique_ptr<ffi::WGPURecordedRenderPass, ffiWGPURenderPassDeleter> mPass;
// keep all the used objects alive while the pass is recorded