skgpu::graphite::ComputeTask Class Reference

#include <ComputeTask.h>

Inheritance diagram for skgpu::graphite::ComputeTask:

Public Types
using	DispatchGroupList = skia_private::STArray< 1, std::unique_ptr< DispatchGroup > >
Public Types inherited from skgpu::graphite::Task
enum class	Status { kSuccess , kDiscard , kFail }

Public Member Functions
	~ComputeTask () override
Status	prepareResources (ResourceProvider *, const RuntimeEffectDictionary *) override
Status	addCommands (Context *, CommandBuffer *, ReplayTargetData) override
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< ComputeTask >	Make (DispatchGroupList dispatchGroups)

Detailed Description

ComputeTask handles preparing and recording DispatchGroups into a series of compute dispatches within a command buffer. It is guaranteed that dispatches within a DispatchGroup will be executed sequentially.

Definition at line 26 of file ComputeTask.h.

Member Typedef Documentation

DispatchGroupList

using skgpu::graphite::ComputeTask::DispatchGroupList = skia_private::STArray<1, std::unique_ptr<DispatchGroup> >

Definition at line 28 of file ComputeTask.h.

Constructor & Destructor Documentation

~ComputeTask()

skgpu::graphite::ComputeTask::~ComputeTask ( )

overridedefault

Member Function Documentation

addCommands()

Task::Status skgpu::graphite::ComputeTask::addCommands ( Context *  ctx, CommandBuffer *  commandBuffer, ReplayTargetData  rtd  )

overridevirtual

Implements skgpu::graphite::Task.

Definition at line 50 of file ComputeTask.cpp.

                                                                                                    {
    if (fDispatchGroups.empty()) {
        return Status::kDiscard;
    }
    SkASSERT(fDispatchGroups.size() == fChildTasks.size());
    const std::unique_ptr<DispatchGroup>* currentSpanPtr = &fDispatchGroups[0];
    size_t currentSpanSize = 0u;
    for (int i = 0; i < fDispatchGroups.size(); ++i) {
        // If the next DispatchGroup has a dependent task, then encode the accumulated span as a
        // compute pass now. CommandBuffer encodes each compute pass with a separate encoder, so
        // the dependent task can use a non-compute encoder if needed.
        Task* child = fChildTasks[i].get();
        if (child) {
            if (currentSpanSize > 0u) {
                if (!commandBuffer->addComputePass({currentSpanPtr, currentSpanSize})) {
                    return Status::kFail;
                }
                currentSpanPtr = &fDispatchGroups[i];
                currentSpanSize = 0u;
            }
 
            Status status = child->addCommands(ctx, commandBuffer, rtd);
            if (status == Status::kFail) {
                return Status::kFail;
            } else if (status == Status::kDiscard) {
                fChildTasks[i].reset();
            }
        }
        currentSpanSize++;
    }
    return (currentSpanSize == 0u ||
            commandBuffer->addComputePass({currentSpanPtr, currentSpanSize})) ? Status::kSuccess
                                                                              : Status::kFail;
}

Make()

sk_sp< ComputeTask > skgpu::graphite::ComputeTask::Make ( DispatchGroupList  dispatchGroups )

static

Definition at line 17 of file ComputeTask.cpp.

                                                                     {
    return sk_sp<ComputeTask>(new ComputeTask(std::move(dispatchGroups)));
}

prepareResources()

Task::Status skgpu::graphite::ComputeTask::prepareResources ( ResourceProvider *  provider, const RuntimeEffectDictionary *  rtd  )

overridevirtual

Implements skgpu::graphite::Task.

Definition at line 30 of file ComputeTask.cpp.

                                                                               {
    for (auto& child : fChildTasks) {
        if (child) {
            Status status = child->prepareResources(provider, rtd);
            if (status == Status::kFail) {
                return Status::kFail;
            } else if (status == Status::kDiscard) {
                child.reset();
            }
        }
    }
    for (const auto& group : fDispatchGroups) {
        if (!group->prepareResources(provider)) {
            return Status::kFail;
        }
    }
    return Status::kSuccess;
}

---

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

• third_party/skia/src/gpu/graphite/task/ComputeTask.h
• third_party/skia/src/gpu/graphite/task/ComputeTask.cpp