skgpu::graphite::DispatchGroup Class Reference

#include <DispatchGroup.h>

Classes
class	Builder
struct	Dispatch

Public Member Functions
	~DispatchGroup ()
const skia_private::TArray< Dispatch > &	dispatches () const
const ComputePipeline *	getPipeline (size_t index) const
const Texture *	getTexture (size_t index) const
const Sampler *	getSampler (size_t index) const
bool	prepareResources (ResourceProvider *)
void	addResourceRefs (CommandBuffer *) const
sk_sp< Task >	snapChildTask ()

Friends
class	DispatchGroupBuilder

Detailed Description

DispatchGroup groups a series of compute pipeline dispatches that need to execute sequentially (i.e. with a barrier). Dispatches are stored in the order that they will be encoded in the eventual command buffer.

A DispatchGroup can be constructed from a series of ComputeSteps using a Builder. The Builder verifies that the data flow specification between successive ComputeSteps are compatible. The resources required by a ComputeStep (such as Buffers and TextureProxies) are created by the Builder as they get added.

Once a DispatchGroup is finalized, it is immutable. It contains the complete ResourceBinding list for each dispatch. A list of finalized DispatchGroups can be submitted to the command buffer in a ComputeTask.

Definition at line 61 of file DispatchGroup.h.

Constructor & Destructor Documentation

~DispatchGroup()

skgpu::graphite::DispatchGroup::~DispatchGroup ( )

default

Member Function Documentation

addResourceRefs()

void skgpu::graphite::DispatchGroup::addResourceRefs

(

CommandBuffer *

commandBuffer

)

const

Definition at line 66 of file DispatchGroup.cpp.

                                                                      {
    for (int i = 0; i < fPipelines.size(); ++i) {
        commandBuffer->trackResource(fPipelines[i]);
    }
    for (int i = 0; i < fTextures.size(); ++i) {
        commandBuffer->trackCommandBufferResource(fTextures[i]->refTexture());
    }
}

dispatches()

const skia_private::TArray< Dispatch > & skgpu::graphite::DispatchGroup::dispatches ( ) const

inline

Definition at line 77 of file DispatchGroup.h.

{ return fDispatchList; }

getPipeline()

const ComputePipeline * skgpu::graphite::DispatchGroup::getPipeline ( size_t  index ) const

inline

Definition at line 79 of file DispatchGroup.h.

{ return fPipelines[index].get(); }

getSampler()

const Sampler * skgpu::graphite::DispatchGroup::getSampler

(

size_t

index

)

const

Definition at line 89 of file DispatchGroup.cpp.

                                                           {
    SkASSERT(index < SkToSizeT(fSamplers.size()));
    SkASSERT(fSamplers[index]);
    return fSamplers[index].get();
}

getTexture()

const Texture * skgpu::graphite::DispatchGroup::getTexture

(

size_t

index

)

const

Definition at line 82 of file DispatchGroup.cpp.

                                                           {
    SkASSERT(index < SkToSizeT(fTextures.size()));
    SkASSERT(fTextures[index]);
    SkASSERT(fTextures[index]->texture());
    return fTextures[index]->texture();
}

prepareResources()

bool skgpu::graphite::DispatchGroup::prepareResources

(

ResourceProvider *

resourceProvider

)

Definition at line 27 of file DispatchGroup.cpp.

                                                                       {
    fPipelines.reserve(fPipelines.size() + fPipelineDescs.size());
    for (const ComputePipelineDesc& desc : fPipelineDescs) {
        auto pipeline = resourceProvider->findOrCreateComputePipeline(desc);
        if (!pipeline) {
            SKGPU_LOG_W("Failed to create ComputePipeline for dispatch group. Dropping group!");
            return false;
        }
        fPipelines.push_back(std::move(pipeline));
    }
 
    for (int i = 0; i < fTextures.size(); ++i) {
        if (!fTextures[i]->textureInfo().isValid()) {
            SKGPU_LOG_W("Failed to validate bound texture. Dropping dispatch group!");
            return false;
        }
        if (!TextureProxy::InstantiateIfNotLazy(resourceProvider, fTextures[i].get())) {
            SKGPU_LOG_W("Failed to instantiate bound texture. Dropping dispatch group!");
            return false;
        }
    }
 
    for (const SamplerDesc& desc : fSamplerDescs) {
        sk_sp<Sampler> sampler = resourceProvider->findOrCreateCompatibleSampler(desc);
        if (!sampler) {
            SKGPU_LOG_W("Failed to create sampler. Dropping dispatch group!");
            return false;
        }
        fSamplers.push_back(std::move(sampler));
    }
 
    // The DispatchGroup may be long lived on a Recording and we no longer need the descriptors
    // once we've created pipelines.
    fPipelineDescs.clear();
    fSamplerDescs.clear();
 
    return true;
}

snapChildTask()

sk_sp< Task > skgpu::graphite::DispatchGroup::snapChildTask

(

)

Definition at line 75 of file DispatchGroup.cpp.

                                         {
    if (fClearList.empty()) {
        return nullptr;
    }
    return ClearBuffersTask::Make(std::move(fClearList));
}

Friends And Related Function Documentation

DispatchGroupBuilder

friend class DispatchGroupBuilder

friend

Definition at line 91 of file DispatchGroup.h.

---

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

• third_party/skia/src/gpu/graphite/compute/DispatchGroup.h
• third_party/skia/src/gpu/graphite/compute/DispatchGroup.cpp