skgpu::graphite::Recorder Class Reference

#include <Recorder.h>

Public Member Functions
	Recorder (const Recorder &)=delete
	Recorder (Recorder &&)=delete
Recorder &	operator= (const Recorder &)=delete
Recorder &	operator= (Recorder &&)=delete
	~Recorder ()
BackendApi	backend () const
std::unique_ptr< Recording >	snap ()
ImageProvider *	clientImageProvider ()
const ImageProvider *	clientImageProvider () const
BackendTexture	createBackendTexture (SkISize dimensions, const TextureInfo &)
bool	updateBackendTexture (const BackendTexture &, const SkPixmap srcData[], int numLevels)
bool	updateCompressedBackendTexture (const BackendTexture &, const void *data, size_t dataSize)
void	deleteBackendTexture (const BackendTexture &)
void	addFinishInfo (const InsertFinishInfo &)
SkCanvas *	makeDeferredCanvas (const SkImageInfo &, const TextureInfo &)
void	freeGpuResources ()
void	performDeferredCleanup (std::chrono::milliseconds msNotUsed)
size_t	currentBudgetedBytes () const
size_t	maxBudgetedBytes () const
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
RecorderPriv	priv ()
const RecorderPriv	priv () const

Friends
class	Context
class	Device
class	RecorderPriv

Detailed Description

Definition at line 75 of file Recorder.h.

Constructor & Destructor Documentation

Recorder() [1/2]

skgpu::graphite::Recorder::Recorder ( const Recorder &  )

delete

Recorder() [2/2]

skgpu::graphite::Recorder::Recorder ( Recorder &&  )

delete

~Recorder()

skgpu::graphite::Recorder::~Recorder

(

)

Definition at line 134 of file Recorder.cpp.

                    {
    ASSERT_SINGLE_OWNER
    // Any finished procs that haven't been passed to a Recording fail
    for (int i = 0; i < fFinishedProcs.size(); ++i) {
        fFinishedProcs[i]->setFailureResult();
    }
 
    for (auto& device : fTrackedDevices) {
        // deregisterDevice() may have left an entry as null previously.
        if (device) {
            device->abandonRecorder();
        }
    }
#if defined(GRAPHITE_TEST_UTILS)
    if (fContext) {
        fContext->priv().deregisterRecorder(this);
    }
#endif
 
    // TODO: needed?
    fStrikeCache->freeAll();
}

Member Function Documentation

addFinishInfo()

void skgpu::graphite::Recorder::addFinishInfo

(

const InsertFinishInfo &

info

)

Definition at line 432 of file Recorder.cpp.

                                                         {
    if (info.fFinishedProc) {
        sk_sp<RefCntedCallback> callback =
                RefCntedCallback::Make(info.fFinishedProc, info.fFinishedContext);
        fFinishedProcs.push_back(std::move(callback));
    }
}

backend()

BackendApi skgpu::graphite::Recorder::backend

(

)

const

Definition at line 157 of file Recorder.cpp.

{ return fSharedContext->backend(); }

clientImageProvider() [1/2]

ImageProvider * skgpu::graphite::Recorder::clientImageProvider ( )

inline

Definition at line 88 of file Recorder.h.

{ return fClientImageProvider.get(); }

clientImageProvider() [2/2]

const ImageProvider * skgpu::graphite::Recorder::clientImageProvider ( ) const

inline

Definition at line 89 of file Recorder.h.

{ return fClientImageProvider.get(); }

createBackendTexture()

BackendTexture skgpu::graphite::Recorder::createBackendTexture	(	SkISize	dimensions,
		const TextureInfo &	info
	)

Creates a new backend gpu texture matching the dimensions and TextureInfo. If an invalid TextureInfo or a TextureInfo Skia can't support is passed in, this will return an invalid BackendTexture. Thus the client should check isValid on the returned BackendTexture to know if it succeeded or not.

If this does return a valid BackendTexture, the caller is required to use Recorder::deleteBackendTexture or Context::deleteBackendTexture to delete the texture. It is safe to use the Context that created this Recorder or any other Recorder created from the same Context to call deleteBackendTexture.

Definition at line 284 of file Recorder.cpp.

                                                                                         {
    ASSERT_SINGLE_OWNER
 
    if (!info.isValid() || info.backend() != this->backend()) {
        return {};
    }
    return fResourceProvider->createBackendTexture(dimensions, info);
}

currentBudgetedBytes()

size_t skgpu::graphite::Recorder::currentBudgetedBytes

(

)

const

Returns the number of bytes of the Recorder's gpu memory cache budget that are currently in use.

Definition at line 463 of file Recorder.cpp.

                                            {
    ASSERT_SINGLE_OWNER
    return fResourceProvider->getResourceCacheCurrentBudgetedBytes();
}

deleteBackendTexture()

void skgpu::graphite::Recorder::deleteBackendTexture

(

const BackendTexture &

texture

)

Called to delete the passed in BackendTexture. This should only be called if the BackendTexture was created by calling Recorder::createBackendTexture on a Recorder that is associated with the same Context. If the BackendTexture is not valid or does not match the BackendApi of the Recorder then nothing happens.

Otherwise this will delete/release the backend object that is wrapped in the BackendTexture. The BackendTexture will be reset to an invalid state and should not be used again.

Definition at line 423 of file Recorder.cpp.

                                                                 {
    ASSERT_SINGLE_OWNER
 
    if (!texture.isValid() || texture.backend() != this->backend()) {
        return;
    }
    fResourceProvider->deleteBackendTexture(texture);
}

dumpMemoryStatistics()

void skgpu::graphite::Recorder::dumpMemoryStatistics

(

SkTraceMemoryDump *

traceMemoryDump

)

const

Enumerates all cached GPU resources owned by the Recorder and dumps their memory to traceMemoryDump.

Definition at line 473 of file Recorder.cpp.

                                                                            {
    ASSERT_SINGLE_OWNER
    fResourceProvider->dumpMemoryStatistics(traceMemoryDump);
    // TODO: What is the graphite equivalent for the text blob cache and how do we print out its
    // used bytes here (see Ganesh implementation).
}

freeGpuResources()

void skgpu::graphite::Recorder::freeGpuResources

(

)

Frees GPU resources created and held by the Recorder. Can be called to reduce GPU memory pressure. Any resources that are still in use (e.g. being used by work submitted to the GPU) will not be deleted by this call. If the caller wants to make sure all resources are freed, then they should first make sure to submit and wait on any outstanding work.

Definition at line 440 of file Recorder.cpp.

                                {
    ASSERT_SINGLE_OWNER
 
    // We don't want to free the Uniform/TextureDataCaches or the Draw/UploadBufferManagers since
    // all their resources need to be held on to until a Recording is snapped. And once snapped, all
    // their held resources are released. The StrikeCache and TextBlobCache don't hold onto any Gpu
    // resources.
 
    // The AtlasProvider gives out refs to TextureProxies so it should be safe to clear its pool
    // in the middle of Recording since those using the previous TextureProxies will have refs on
    // them.
    fAtlasProvider->clearTexturePool();
 
    fResourceProvider->freeGpuResources();
}

makeDeferredCanvas()

SkCanvas * skgpu::graphite::Recorder::makeDeferredCanvas	(	const SkImageInfo &	imageInfo,
		const TextureInfo &	textureInfo
	)

Definition at line 235 of file Recorder.cpp.

                                                                       {
    // Mipmaps can't reasonably be kept valid on a deferred surface with no actual texture.
    if (textureInfo.mipmapped() == Mipmapped::kYes) {
        SKGPU_LOG_W("Requested a deferred canvas with mipmapping; this is not supported");
        return nullptr;
    }
 
    if (fTargetProxyCanvas) {
        // Require snapping before requesting another canvas.
        SKGPU_LOG_W("Requested a new deferred canvas before snapping the previous one");
        return nullptr;
    }
 
    fTargetProxyData = std::make_unique<Recording::LazyProxyData>(textureInfo);
    // Use kLoad for the initial load op since the purpose of a deferred canvas is to draw on top
    // of an existing, late-bound texture.
    fTargetProxyDevice = Device::Make(this,
                                      fTargetProxyData->refLazyProxy(),
                                      imageInfo.dimensions(),
                                      imageInfo.colorInfo(),
                                      {},
                                      LoadOp::kLoad);
    fTargetProxyCanvas = std::make_unique<SkCanvas>(fTargetProxyDevice);
    return fTargetProxyCanvas.get();
}

maxBudgetedBytes()

size_t skgpu::graphite::Recorder::maxBudgetedBytes

(

)

const

Returns the size of Recorder's gpu memory cache budget in bytes.

Definition at line 468 of file Recorder.cpp.

                                        {
    ASSERT_SINGLE_OWNER
    return fResourceProvider->getResourceCacheLimit();
}

operator=() [1/2]

Recorder & skgpu::graphite::Recorder::operator= ( const Recorder &  )

delete

operator=() [2/2]

Recorder & skgpu::graphite::Recorder::operator= ( Recorder &&  )

delete

performDeferredCleanup()

void skgpu::graphite::Recorder::performDeferredCleanup

(

std::chrono::milliseconds

msNotUsed

)

Purge GPU resources on the Recorder that haven't been used in the past 'msNotUsed' milliseconds or are otherwise marked for deletion, regardless of whether the context is under budget.

Definition at line 456 of file Recorder.cpp.

                                                                     {
    ASSERT_SINGLE_OWNER
 
    auto purgeTime = skgpu::StdSteadyClock::now() - msNotUsed;
    fResourceProvider->purgeResourcesNotUsedSince(purgeTime);
}

priv() [1/2]

RecorderPriv skgpu::graphite::Recorder::priv ( )

inline

Definition at line 106 of file RecorderPriv.h.

                                   {
    return RecorderPriv(this);
}

priv() [2/2]

const RecorderPriv skgpu::graphite::Recorder::priv ( ) const

inline

Definition at line 110 of file RecorderPriv.h.

                                               {  // NOLINT(readability-const-return-type)
    return RecorderPriv(const_cast<Recorder*>(this));
}

snap()

std::unique_ptr< Recording > skgpu::graphite::Recorder::snap

(

)

Definition at line 159 of file Recorder.cpp.

                                        {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    ASSERT_SINGLE_OWNER
    this->priv().flushTrackedDevices();
 
    std::unordered_set<sk_sp<TextureProxy>, Recording::ProxyHash> nonVolatileLazyProxies;
    std::unordered_set<sk_sp<TextureProxy>, Recording::ProxyHash> volatileLazyProxies;
    fTextureDataCache->foreach([&](const TextureDataBlock* block) {
        for (int j = 0; j < block->numTextures(); ++j) {
            const TextureDataBlock::SampledTexture& tex = block->texture(j);
 
            if (tex.first->isLazy()) {
                if (tex.first->isVolatile()) {
                    volatileLazyProxies.insert(tex.first);
                } else {
                    nonVolatileLazyProxies.insert(tex.first);
                }
            }
        }
    });
 
    std::unique_ptr<Recording::LazyProxyData> targetProxyData;
    if (fTargetProxyData) {
        targetProxyData = std::move(fTargetProxyData);
        fTargetProxyDevice.reset();
        fTargetProxyCanvas.reset();
    }
 
    // The scratch resources only need to be tracked until prepareResources() is finished, so
    // Recorder doesn't hold a persistent manager and it can be deleted when snap() returns.
    ScratchResourceManager scratchManager{fResourceProvider, std::move(fProxyReadCounts)};
    fProxyReadCounts = std::make_unique<ProxyReadCountMap>();
 
    // In both the "task failed" case and the "everything is discarded" case, there's no work that
    // needs to be done in insertRecording(). However, we use nullptr as a failure signal, so
    // kDiscard will return a non-null Recording that has no tasks in it.
    if (fDrawBufferManager->hasMappingFailed() ||
        fRootTaskList->prepareResources(fResourceProvider,
                                        &scratchManager,
                                        fRuntimeEffectDict.get()) == Task::Status::kFail) {
        // Leaving 'fTrackedDevices' alone since they were flushed earlier and could still be
        // attached to extant SkSurfaces.
        fDrawBufferManager = std::make_unique<DrawBufferManager>(fResourceProvider,
                                                                 fSharedContext->caps(),
                                                                 fUploadBufferManager.get());
        fTextureDataCache = std::make_unique<TextureDataCache>();
        fUniformDataCache = std::make_unique<UniformDataCache>();
        fRootTaskList->reset();
        fRuntimeEffectDict->reset();
        return nullptr;
    }
 
    std::unique_ptr<Recording> recording(new Recording(fNextRecordingID++,
                                                       fUniqueID,
                                                       std::move(nonVolatileLazyProxies),
                                                       std::move(volatileLazyProxies),
                                                       std::move(targetProxyData),
                                                       std::move(fFinishedProcs)));
 
    // Allow the buffer managers to add any collected tasks for data transfer or initialization
    // before moving the root task list to the Recording.
    fDrawBufferManager->transferToRecording(recording.get());
    fUploadBufferManager->transferToRecording(recording.get());
    recording->priv().addTasks(std::move(*fRootTaskList));
 
    SkASSERT(!fRootTaskList->hasTasks());
    fRuntimeEffectDict->reset();
    fTextureDataCache = std::make_unique<TextureDataCache>();
    fUniformDataCache = std::make_unique<UniformDataCache>();
    if (!this->priv().caps()->requireOrderedRecordings()) {
        fAtlasProvider->textAtlasManager()->evictAtlases();
    }
 
    return recording;
}

updateBackendTexture()

bool skgpu::graphite::Recorder::updateBackendTexture	(	const BackendTexture &	backendTex,
		const SkPixmap	srcData[],
		int	numLevels
	)

If possible, updates a backend texture with the provided pixmap data. The client should check the return value to see if the update was successful. The client is required to insert a Recording into the Context and call submit to send the upload work to the gpu. The backend texture must be compatible with the provided pixmap(s). Compatible, in this case, means that the backend format is compatible with the base pixmap's colortype. The src data can be deleted when this call returns. If the backend texture is mip mapped, the data for all the mipmap levels must be provided. In the mipmapped case all the colortypes of the provided pixmaps must be the same. Additionally, all the miplevels must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount). Note: the pixmap's alphatypes and colorspaces are ignored. For the Vulkan backend after a successful update the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 314 of file Recorder.cpp.

                                                   {
    ASSERT_SINGLE_OWNER
 
    if (!backendTex.isValid() || backendTex.backend() != this->backend()) {
        return false;
    }
 
    if (!srcData || numLevels <= 0) {
        return false;
    }
 
    // If the texture has MIP levels then we require that the full set is overwritten.
    int numExpectedLevels = 1;
    if (backendTex.info().mipmapped() == Mipmapped::kYes) {
        numExpectedLevels = SkMipmap::ComputeLevelCount(backendTex.dimensions().width(),
                                                        backendTex.dimensions().height()) + 1;
    }
    if (numLevels != numExpectedLevels) {
        return false;
    }
 
    SkColorType ct = srcData[0].colorType();
 
    if (!this->priv().caps()->areColorTypeAndTextureInfoCompatible(ct, backendTex.info())) {
        return false;
    }
 
    sk_sp<Texture> texture = this->priv().resourceProvider()->createWrappedTexture(backendTex, "");
    if (!texture) {
        return false;
    }
 
    sk_sp<TextureProxy> proxy = TextureProxy::Wrap(std::move(texture));
 
    std::vector<MipLevel> mipLevels;
    mipLevels.resize(numLevels);
 
    for (int i = 0; i < numLevels; ++i) {
        SkASSERT(srcData[i].addr());
        SkASSERT(srcData[i].info().colorInfo() == srcData[0].info().colorInfo());
 
        mipLevels[i].fPixels = srcData[i].addr();
        mipLevels[i].fRowBytes = srcData[i].rowBytes();
    }
 
    // Src and dst colorInfo are the same
    const SkColorInfo& colorInfo = srcData[0].info().colorInfo();
    // Add UploadTask to Recorder
    UploadInstance upload = UploadInstance::Make(this,
                                                 std::move(proxy),
                                                 colorInfo, colorInfo,
                                                 mipLevels,
                                                 SkIRect::MakeSize(backendTex.dimensions()),
                                                 std::make_unique<ImageUploadContext>());
    if (!upload.isValid()) {
        SKGPU_LOG_E("Recorder::updateBackendTexture: Could not create UploadInstance");
        return false;
    }
    sk_sp<Task> uploadTask = UploadTask::Make(std::move(upload));
 
    // Need to flush any pending work in case it depends on this texture
    this->priv().flushTrackedDevices();
 
    this->priv().add(std::move(uploadTask));
 
    return true;
}

updateCompressedBackendTexture()

bool skgpu::graphite::Recorder::updateCompressedBackendTexture	(	const BackendTexture &	backendTex,
		const void *	data,
		size_t	dataSize
	)

If possible, updates a compressed backend texture filled with the provided raw data. The client should check the return value to see if the update was successful. The client is required to insert a Recording into the Context and call submit to send the upload work to the gpu. If the backend texture is mip mapped, the data for all the mipmap levels must be provided. Additionally, all the miplevels must be sized correctly (please see SkMipMap::ComputeLevelSize and ComputeLevelCount). For the Vulkan backend after a successful update the layout of the created VkImage will be: VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL

Definition at line 384 of file Recorder.cpp.

                                                               {
    ASSERT_SINGLE_OWNER
 
    if (!backendTex.isValid() || backendTex.backend() != this->backend()) {
        return false;
    }
 
    if (!data) {
        return false;
    }
 
    sk_sp<Texture> texture = this->priv().resourceProvider()->createWrappedTexture(backendTex, "");
    if (!texture) {
        return false;
    }
 
    sk_sp<TextureProxy> proxy = TextureProxy::Wrap(std::move(texture));
 
    // Add UploadTask to Recorder
    UploadInstance upload = UploadInstance::MakeCompressed(this,
                                                           std::move(proxy),
                                                           data,
                                                           dataSize);
    if (!upload.isValid()) {
        SKGPU_LOG_E("Recorder::updateBackendTexture: Could not create UploadInstance");
        return false;
    }
    sk_sp<Task> uploadTask = UploadTask::Make(std::move(upload));
 
    // Need to flush any pending work in case it depends on this texture
    this->priv().flushTrackedDevices();
 
    this->priv().add(std::move(uploadTask));
 
    return true;
}

Friends And Related Function Documentation

Context

friend class Context

friend

Definition at line 206 of file Recorder.h.

Device

friend class Device

friend

Definition at line 207 of file Recorder.h.

RecorderPriv

friend class RecorderPriv

friend

Definition at line 208 of file Recorder.h.

---

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

• third_party/skia/include/gpu/graphite/Recorder.h
• third_party/skia/src/gpu/graphite/Recorder.cpp
• third_party/skia/src/gpu/graphite/RecorderPriv.h