skgpu::graphite::QueueManager Class Reference

#include <QueueManager.h>

Inheritance diagram for skgpu::graphite::QueueManager:

Public Member Functions
virtual	~QueueManager ()
bool	addRecording (const InsertRecordingInfo &, Context *)
bool	addTask (Task *, Context *)
bool	addFinishInfo (const InsertFinishInfo &, ResourceProvider *, SkSpan< const sk_sp< Buffer > > buffersToAsyncMap={})
bool	submitToGpu ()
bool	hasUnfinishedGpuWork ()
void	checkForFinishedWork (SyncToCpu)
void	returnCommandBuffer (std::unique_ptr< CommandBuffer >)
virtual void	tick () const
void	addUploadBufferManagerRefs (UploadBufferManager *)

Protected Types
using	OutstandingSubmission = std::unique_ptr< GpuWorkSubmission >

Protected Member Functions
	QueueManager (const SharedContext *sharedContext)

Protected Attributes
const SharedContext *	fSharedContext
std::unique_ptr< CommandBuffer >	fCurrentCommandBuffer

Private Member Functions
virtual std::unique_ptr< CommandBuffer >	getNewCommandBuffer (ResourceProvider *)=0
virtual OutstandingSubmission	onSubmitToGpu ()=0

Detailed Description

Definition at line 32 of file QueueManager.h.

Member Typedef Documentation

OutstandingSubmission

using skgpu::graphite::QueueManager::OutstandingSubmission = std::unique_ptr<GpuWorkSubmission>

protected

Definition at line 65 of file QueueManager.h.

Constructor & Destructor Documentation

~QueueManager()

skgpu::graphite::QueueManager::~QueueManager ( )

virtual

Definition at line 37 of file QueueManager.cpp.

                            {
    if (fSharedContext->caps()->allowCpuSync()) {
        this->checkForFinishedWork(SyncToCpu::kYes);
    } else if (!fOutstandingSubmissions.empty()) {
        SKGPU_LOG_F("When ContextOptions::fNeverYieldToWebGPU is specified all GPU work must be "
                    "finished before destroying Context.");
    }
}

QueueManager()

skgpu::graphite::QueueManager::QueueManager ( const SharedContext *  sharedContext )

protected

Definition at line 32 of file QueueManager.cpp.

        : fSharedContext(sharedContext)
        , fOutstandingSubmissions(sizeof(OutstandingSubmission), kDefaultOutstandingAllocCnt) {
}

Member Function Documentation

addFinishInfo()

bool skgpu::graphite::QueueManager::addFinishInfo	(	const InsertFinishInfo &	info,
		ResourceProvider *	resourceProvider,
		SkSpan< const sk_sp< Buffer > >	buffersToAsyncMap = {}
	)

Definition at line 191 of file QueueManager.cpp.

                                                                                {
    sk_sp<RefCntedCallback> callback;
    if (info.fFinishedProc) {
        callback = RefCntedCallback::Make(info.fFinishedProc, info.fFinishedContext);
    }
 
    if (!this->setupCommandBuffer(resourceProvider)) {
        if (callback) {
            callback->setFailureResult();
        }
        SKGPU_LOG_E("CommandBuffer creation failed");
        return false;
    }
 
    if (callback) {
        fCurrentCommandBuffer->addFinishedProc(std::move(callback));
    }
    fCurrentCommandBuffer->addBuffersToAsyncMapOnSubmit(buffersToAsyncMap);
 
    return true;
}

addRecording()

bool skgpu::graphite::QueueManager::addRecording	(	const InsertRecordingInfo &	info,
		Context *	context
	)

Definition at line 66 of file QueueManager.cpp.

                                                                                 {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    sk_sp<RefCntedCallback> callback;
    if (info.fFinishedProc) {
        callback = RefCntedCallback::Make(info.fFinishedProc, info.fFinishedContext);
    }
 
    SkASSERT(info.fRecording);
    if (!info.fRecording) {
        if (callback) {
            callback->setFailureResult();
        }
        SKGPU_LOG_E("No valid Recording passed into addRecording call");
        return false;
    }
 
    if (this->fSharedContext->caps()->requireOrderedRecordings()) {
        uint32_t* recordingID = fLastAddedRecordingIDs.find(info.fRecording->priv().recorderID());
        if (recordingID &&
            info.fRecording->priv().uniqueID() != *recordingID+1) {
            if (callback) {
                callback->setFailureResult();
            }
            SKGPU_LOG_E("Recordings are expected to be replayed in order");
            return false;
        }
 
        // Note the new Recording ID.
        fLastAddedRecordingIDs.set(info.fRecording->priv().recorderID(),
                                   info.fRecording->priv().uniqueID());
    }
 
    if (info.fTargetSurface &&
        !static_cast<const SkSurface_Base*>(info.fTargetSurface)->isGraphiteBacked()) {
        if (callback) {
            callback->setFailureResult();
        }
        info.fRecording->priv().setFailureResultForFinishedProcs();
        SKGPU_LOG_E("Target surface passed into addRecording call is not graphite-backed");
        return false;
    }
 
    auto resourceProvider = context->priv().resourceProvider();
    if (!this->setupCommandBuffer(resourceProvider)) {
        if (callback) {
            callback->setFailureResult();
        }
        info.fRecording->priv().setFailureResultForFinishedProcs();
        SKGPU_LOG_E("CommandBuffer creation failed");
        return false;
    }
 
    if (info.fRecording->priv().hasNonVolatileLazyProxies()) {
        if (!info.fRecording->priv().instantiateNonVolatileLazyProxies(resourceProvider)) {
            if (callback) {
                callback->setFailureResult();
            }
            info.fRecording->priv().setFailureResultForFinishedProcs();
            SKGPU_LOG_E("Non-volatile PromiseImage instantiation has failed");
            return false;
        }
    }
 
    if (info.fRecording->priv().hasVolatileLazyProxies()) {
        if (!info.fRecording->priv().instantiateVolatileLazyProxies(resourceProvider)) {
            if (callback) {
                callback->setFailureResult();
            }
            info.fRecording->priv().setFailureResultForFinishedProcs();
            info.fRecording->priv().deinstantiateVolatileLazyProxies();
            SKGPU_LOG_E("Volatile PromiseImage instantiation has failed");
            return false;
        }
    }
 
    fCurrentCommandBuffer->addWaitSemaphores(info.fNumWaitSemaphores, info.fWaitSemaphores);
    if (!info.fRecording->priv().addCommands(context,
                                             fCurrentCommandBuffer.get(),
                                             static_cast<Surface*>(info.fTargetSurface),
                                             info.fTargetTranslation)) {
        if (callback) {
            callback->setFailureResult();
        }
        info.fRecording->priv().setFailureResultForFinishedProcs();
        info.fRecording->priv().deinstantiateVolatileLazyProxies();
        SKGPU_LOG_E("Adding Recording commands to the CommandBuffer has failed");
        return false;
    }
    fCurrentCommandBuffer->addSignalSemaphores(info.fNumSignalSemaphores, info.fSignalSemaphores);
    if (info.fTargetTextureState) {
        fCurrentCommandBuffer->prepareSurfaceForStateUpdate(info.fTargetSurface,
                                                            info.fTargetTextureState);
    }
 
    if (callback) {
        fCurrentCommandBuffer->addFinishedProc(std::move(callback));
    }
 
    info.fRecording->priv().deinstantiateVolatileLazyProxies();
 
    return true;
}

addTask()

bool skgpu::graphite::QueueManager::addTask	(	Task *	task,
		Context *	context
	)

Definition at line 170 of file QueueManager.cpp.

                                             {
    SkASSERT(task);
    if (!task) {
        SKGPU_LOG_E("No valid Task passed into addTask call");
        return false;
    }
 
    if (!this->setupCommandBuffer(context->priv().resourceProvider())) {
        SKGPU_LOG_E("CommandBuffer creation failed");
        return false;
    }
 
    if (task->addCommands(context, fCurrentCommandBuffer.get(), {}) == Task::Status::kFail) {
        SKGPU_LOG_E("Adding Task commands to the CommandBuffer has failed");
        return false;
    }
 
    return true;
}

addUploadBufferManagerRefs()

void skgpu::graphite::QueueManager::addUploadBufferManagerRefs

(

UploadBufferManager *

uploadManager

)

Definition at line 276 of file QueueManager.cpp.

                                                                                {
    SkASSERT(fCurrentCommandBuffer);
    uploadManager->transferToCommandBuffer(fCurrentCommandBuffer.get());
}

checkForFinishedWork()

void skgpu::graphite::QueueManager::checkForFinishedWork

(

SyncToCpu

sync

)

Definition at line 243 of file QueueManager.cpp.

                                                      {
    TRACE_EVENT1("skia.gpu", TRACE_FUNC, "sync", sync == SyncToCpu::kYes);
 
    if (sync == SyncToCpu::kYes) {
        SkASSERT(fSharedContext->caps()->allowCpuSync());
        // wait for the last submission to finish
        OutstandingSubmission* back = (OutstandingSubmission*)fOutstandingSubmissions.back();
        if (back) {
            (*back)->waitUntilFinished(fSharedContext);
        }
    }
 
    // Iterate over all the outstanding submissions to see if any have finished. The work
    // submissions are in order from oldest to newest, so we start at the front to check if they
    // have finished. If so we pop it off and move onto the next.
    // Repeat till we find a submission that has not finished yet (and all others afterwards are
    // also guaranteed to not have finished).
    OutstandingSubmission* front = (OutstandingSubmission*)fOutstandingSubmissions.front();
    while (front && (*front)->isFinished(fSharedContext)) {
        // Make sure we remove before deleting as deletion might try to kick off another submit
        // (though hopefully *not* in Graphite).
        fOutstandingSubmissions.pop_front();
        // Since we used placement new we are responsible for calling the destructor manually.
        front->~OutstandingSubmission();
        front = (OutstandingSubmission*)fOutstandingSubmissions.front();
    }
    SkASSERT(sync == SyncToCpu::kNo || fOutstandingSubmissions.empty());
}

getNewCommandBuffer()

virtual std::unique_ptr< CommandBuffer > skgpu::graphite::QueueManager::getNewCommandBuffer ( ResourceProvider *  )

privatepure virtual

Implemented in skgpu::graphite::DawnQueueManager, skgpu::graphite::MtlQueueManager, and skgpu::graphite::VulkanQueueManager.

hasUnfinishedGpuWork()

bool skgpu::graphite::QueueManager::hasUnfinishedGpuWork

(

)

Definition at line 241 of file QueueManager.cpp.

{ return !fOutstandingSubmissions.empty(); }

onSubmitToGpu()

virtual OutstandingSubmission skgpu::graphite::QueueManager::onSubmitToGpu ( )

privatepure virtual

Implemented in skgpu::graphite::DawnQueueManager, skgpu::graphite::MtlQueueManager, and skgpu::graphite::VulkanQueueManager.

returnCommandBuffer()

void skgpu::graphite::QueueManager::returnCommandBuffer

(

std::unique_ptr< CommandBuffer >

commandBuffer

)

Definition at line 272 of file QueueManager.cpp.

                                                                                 {
    fAvailableCommandBuffers.push_back(std::move(commandBuffer));
}

submitToGpu()

bool skgpu::graphite::QueueManager::submitToGpu

(

)

Definition at line 215 of file QueueManager.cpp.

                               {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    if (!fCurrentCommandBuffer) {
        // We warn because this probably representative of a bad client state, where they don't
        // need to submit but didn't notice, but technically the submit itself is fine (no-op), so
        // we return true.
        SKGPU_LOG_D("Submit called with no active command buffer!");
        return true;
    }
 
#ifdef SK_DEBUG
    if (!fCurrentCommandBuffer->hasWork()) {
        SKGPU_LOG_D("Submitting empty command buffer!");
    }
#endif
 
    auto submission = this->onSubmitToGpu();
    if (!submission) {
        return false;
    }
 
    new (fOutstandingSubmissions.push_back()) OutstandingSubmission(std::move(submission));
    return true;
}

tick()

virtual void skgpu::graphite::QueueManager::tick ( ) const

inlinevirtual

Reimplemented in skgpu::graphite::DawnQueueManager.

Definition at line 58 of file QueueManager.h.

{}

Member Data Documentation

fCurrentCommandBuffer

std::unique_ptr<CommandBuffer> skgpu::graphite::QueueManager::fCurrentCommandBuffer

protected

Definition at line 68 of file QueueManager.h.

fSharedContext

const SharedContext* skgpu::graphite::QueueManager::fSharedContext

protected

Definition at line 67 of file QueueManager.h.

---

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

• third_party/skia/src/gpu/graphite/QueueManager.h
• third_party/skia/src/gpu/graphite/QueueManager.cpp