#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

virtual const char *	getResourceType () const =0

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 &)

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, bool commandBufferRefsAsUsageRefs=false)

virtual	~Resource ()

const SharedContext *	sharedContext () const

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.

27{ return fPipeline; }

◆ dawnGroupLayout()

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

inline

Definition at line 28 of file DawnComputePipeline.h.

28{ return fGroupLayout; }

◆ 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;
    if (sharedContext->caps()->setBackendLabels()) {
        pipelineLayoutDesc.label = step->name();
    }
    pipelineLayoutDesc.bindGroupLayoutCount = 1;
    pipelineLayoutDesc.bindGroupLayouts = &bindGroupLayout;
    wgpu::PipelineLayout layout = device.CreatePipelineLayout(&pipelineLayoutDesc);
    if (!layout) {
        return nullptr;
    }
 
    wgpu::ComputePipelineDescriptor descriptor;
    // Always set the label for pipelines, dawn may need it for tracing.
    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

Public Member Functions

Static Public Member Functions