skgpu::graphite::DawnComputePipeline Class Reference

#include <DawnComputePipeline.h>

Inheritance diagram for skgpu::graphite::DawnComputePipeline:

Public Member Functions
	~DawnComputePipeline () override=default
const wgpu::ComputePipeline &	dawnComputePipeline () const
const wgpu::BindGroupLayout &	dawnGroupLayout () const
Public Member Functions inherited from skgpu::graphite::ComputePipeline
	~ComputePipeline () override=default
const char *	getResourceType () const override
Public Member Functions inherited from skgpu::graphite::Resource
	Resource (const Resource &)=delete
	Resource (Resource &&)=delete
Resource &	operator= (const Resource &)=delete
Resource &	operator= (Resource &&)=delete
void	ref () const
void	unref () const
void	refCommandBuffer () const
void	unrefCommandBuffer () const
Ownership	ownership () const
skgpu::Budgeted	budgeted () const
size_t	gpuMemorySize () const
UniqueID	uniqueID () const
std::string	getLabel () const
void	setLabel (std::string_view label)
bool	wasDestroyed () const
const GraphiteResourceKey &	key () const
void	setKey (const GraphiteResourceKey &key)
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
virtual void	prepareForReturnToCache (const std::function< void()> &takeRef)

Static Public Member Functions
static sk_sp< DawnComputePipeline >	Make (const DawnSharedContext *, const ComputePipelineDesc &)

Private Member Functions
void	freeGpuData () override

Additional Inherited Members
Protected Member Functions inherited from skgpu::graphite::ComputePipeline
	ComputePipeline (const SharedContext *)
Protected Member Functions inherited from skgpu::graphite::Resource
	Resource (const SharedContext *, Ownership, skgpu::Budgeted, size_t gpuMemorySize, std::string_view label, bool commandBufferRefsAsUsageRefs=false)
virtual	~Resource ()
const SharedContext *	sharedContext () const
virtual void	invokeReleaseProc ()
virtual void	onDumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump, const char *dumpName) const
void	setDeleteASAP ()

Detailed Description

Definition at line 22 of file DawnComputePipeline.h.

Constructor & Destructor Documentation

~DawnComputePipeline()

skgpu::graphite::DawnComputePipeline::~DawnComputePipeline ( )

overridedefault

Member Function Documentation

dawnComputePipeline()

const wgpu::ComputePipeline & skgpu::graphite::DawnComputePipeline::dawnComputePipeline ( ) const

inline

Definition at line 27 of file DawnComputePipeline.h.

{ return fPipeline; }

dawnGroupLayout()

const wgpu::BindGroupLayout & skgpu::graphite::DawnComputePipeline::dawnGroupLayout ( ) const

inline

Definition at line 28 of file DawnComputePipeline.h.

{ return fGroupLayout; }

freeGpuData()

void skgpu::graphite::DawnComputePipeline::freeGpuData ( )

overrideprivatevirtual

Implements skgpu::graphite::Resource.

Definition at line 201 of file DawnComputePipeline.cpp.

{ fPipeline = nullptr; }

Make()

sk_sp< DawnComputePipeline > skgpu::graphite::DawnComputePipeline::Make ( const DawnSharedContext *  sharedContext, const ComputePipelineDesc &  pipelineDesc  )

static

Definition at line 77 of file DawnComputePipeline.cpp.

                                                                                              {
    auto [shaderModule, entryPointName] = compile_shader_module(sharedContext, pipelineDesc);
    if (!shaderModule) {
        return nullptr;
    }
 
    const ComputeStep* step = pipelineDesc.computeStep();
 
    // ComputeStep resources are listed in the order that they must be declared in the shader. This
    // order is then used for the index assignment using an "indexed by order" policy that has
    // backend-specific semantics. The semantics on Dawn is to assign the index number in increasing
    // order.
    //
    // All resources get assigned to a single bind group at index 0.
    SkASSERT(!sharedContext->caps()->resourceBindingRequirements().fDistinctIndexRanges);
    std::vector<wgpu::BindGroupLayoutEntry> bindGroupLayoutEntries;
    auto resources = step->resources();
 
    // Sampled textures count as 2 resources (1 texture and 1 sampler). All other types count as 1.
    size_t resourceCount = 0;
    for (const ComputeStep::ResourceDesc& r : resources) {
        resourceCount++;
        if (r.fType == ComputeStep::ResourceType::kSampledTexture) {
            resourceCount++;
        }
    }
 
    bindGroupLayoutEntries.reserve(resourceCount);
    int declarationIndex = 0;
    for (const ComputeStep::ResourceDesc& r : resources) {
        bindGroupLayoutEntries.emplace_back();
        uint32_t bindingIndex = bindGroupLayoutEntries.size() - 1;
 
        wgpu::BindGroupLayoutEntry& entry = bindGroupLayoutEntries.back();
        entry.binding = bindingIndex;
        entry.visibility = wgpu::ShaderStage::Compute;
        switch (r.fType) {
            case ComputeStep::ResourceType::kUniformBuffer:
                entry.buffer.type = wgpu::BufferBindingType::Uniform;
                break;
            case ComputeStep::ResourceType::kStorageBuffer:
            case ComputeStep::ResourceType::kIndirectBuffer:
                entry.buffer.type = wgpu::BufferBindingType::Storage;
                break;
            case ComputeStep::ResourceType::kReadOnlyStorageBuffer:
                entry.buffer.type = wgpu::BufferBindingType::ReadOnlyStorage;
                break;
            case ComputeStep::ResourceType::kReadOnlyTexture:
                entry.texture.sampleType = wgpu::TextureSampleType::Float;
                entry.texture.viewDimension = wgpu::TextureViewDimension::e2D;
                break;
            case ComputeStep::ResourceType::kWriteOnlyStorageTexture: {
                entry.storageTexture.access = wgpu::StorageTextureAccess::WriteOnly;
                entry.storageTexture.viewDimension = wgpu::TextureViewDimension::e2D;
 
                auto [_, colorType] = step->calculateTextureParameters(declarationIndex, r);
                auto textureInfo = sharedContext->caps()->getDefaultStorageTextureInfo(colorType);
                entry.storageTexture.format = textureInfo.dawnTextureSpec().getViewFormat();
                break;
            }
            case ComputeStep::ResourceType::kSampledTexture: {
                entry.sampler.type = wgpu::SamplerBindingType::Filtering;
 
                // Add an additional entry for the texture.
                bindGroupLayoutEntries.emplace_back();
                wgpu::BindGroupLayoutEntry& texEntry = bindGroupLayoutEntries.back();
                texEntry.binding = bindingIndex + 1;
                texEntry.visibility = wgpu::ShaderStage::Compute;
                texEntry.texture.sampleType = wgpu::TextureSampleType::Float;
                texEntry.texture.viewDimension = wgpu::TextureViewDimension::e2D;
                break;
            }
        }
        declarationIndex++;
    }
 
    const wgpu::Device& device = sharedContext->device();
 
    // All resources of a ComputeStep currently get assigned to a single bind group at index 0.
    wgpu::BindGroupLayoutDescriptor bindGroupLayoutDesc;
    bindGroupLayoutDesc.entryCount = bindGroupLayoutEntries.size();
    bindGroupLayoutDesc.entries = bindGroupLayoutEntries.data();
    wgpu::BindGroupLayout bindGroupLayout = device.CreateBindGroupLayout(&bindGroupLayoutDesc);
    if (!bindGroupLayout) {
        return nullptr;
    }
 
    wgpu::PipelineLayoutDescriptor pipelineLayoutDesc;
    pipelineLayoutDesc.label = step->name();
    pipelineLayoutDesc.bindGroupLayoutCount = 1;
    pipelineLayoutDesc.bindGroupLayouts = &bindGroupLayout;
    wgpu::PipelineLayout layout = device.CreatePipelineLayout(&pipelineLayoutDesc);
    if (!layout) {
        return nullptr;
    }
 
    wgpu::ComputePipelineDescriptor descriptor;
    descriptor.label = step->name();
    descriptor.compute.module = std::move(shaderModule);
    descriptor.compute.entryPoint = entryPointName.c_str();
    descriptor.layout = std::move(layout);
 
    std::optional<DawnErrorChecker> errorChecker;
    if (sharedContext->dawnCaps()->allowScopedErrorChecks()) {
        errorChecker.emplace(sharedContext);
    }
    wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&descriptor);
    SkASSERT(pipeline);
    if (errorChecker.has_value() && errorChecker->popErrorScopes() != DawnErrorType::kNoError) {
        return nullptr;
    }
 
    return sk_sp<DawnComputePipeline>(new DawnComputePipeline(
            sharedContext, std::move(pipeline), std::move(bindGroupLayout)));
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/graphite/dawn/DawnComputePipeline.h
• third_party/skia/src/gpu/graphite/dawn/DawnComputePipeline.cpp