skgpu::graphite::RecorderPriv Class Reference

#include <RecorderPriv.h>

Public Member Functions
void	add (sk_sp< Task >)
void	flushTrackedDevices ()
const Caps *	caps () const
ResourceProvider *	resourceProvider ()
const RuntimeEffectDictionary *	runtimeEffectDictionary () const
RuntimeEffectDictionary *	runtimeEffectDictionary ()
const ShaderCodeDictionary *	shaderCodeDictionary () const
ShaderCodeDictionary *	shaderCodeDictionary ()
const RendererProvider *	rendererProvider () const
Protected	isProtected () const
UniformDataCache *	uniformDataCache ()
TextureDataCache *	textureDataCache ()
DrawBufferManager *	drawBufferManager ()
UploadBufferManager *	uploadBufferManager ()
AtlasProvider *	atlasProvider ()
TokenTracker *	tokenTracker ()
sktext::gpu::StrikeCache *	strikeCache ()
sktext::gpu::TextBlobRedrawCoordinator *	textBlobCache ()
ProxyCache *	proxyCache ()
void	addPendingRead (const TextureProxy *)
uint32_t	uniqueID () const
size_t	getResourceCacheLimit () const

Static Public Member Functions
static sk_sp< TextureProxy >	CreateCachedProxy (Recorder *, const SkBitmap &, std::string_view label)

Friends
class	Recorder

Detailed Description

Definition at line 26 of file RecorderPriv.h.

Member Function Documentation

add()

void skgpu::graphite::RecorderPriv::add

(

sk_sp< Task >

task

)

Definition at line 485 of file Recorder.cpp.

                                       {
    ASSERT_SINGLE_OWNER_PRIV
    fRecorder->fRootTaskList->add(std::move(task));
}

addPendingRead()

void skgpu::graphite::RecorderPriv::addPendingRead

(

const TextureProxy *

proxy

)

Definition at line 480 of file Recorder.cpp.

                                                           {
    ASSERT_SINGLE_OWNER_PRIV
    fRecorder->fProxyReadCounts->increment(proxy);
}

atlasProvider()

AtlasProvider * skgpu::graphite::RecorderPriv::atlasProvider ( )

inline

Definition at line 61 of file RecorderPriv.h.

{ return fRecorder->fAtlasProvider.get(); }

caps()

const Caps * skgpu::graphite::RecorderPriv::caps ( ) const

inline

Definition at line 31 of file RecorderPriv.h.

{ return fRecorder->fSharedContext->caps(); }

CreateCachedProxy()

sk_sp< TextureProxy > skgpu::graphite::RecorderPriv::CreateCachedProxy ( Recorder *  recorder, const SkBitmap &  bitmap, std::string_view  label  )

static

Definition at line 544 of file Recorder.cpp.

                                                                          {
    SkASSERT(!bitmap.isNull());
 
    if (!recorder) {
        return nullptr;
    }
    return recorder->priv().proxyCache()->findOrCreateCachedProxy(recorder,
                                                                  bitmap,
                                                                  std::move(label));
}

drawBufferManager()

DrawBufferManager * skgpu::graphite::RecorderPriv::drawBufferManager ( )

inline

Definition at line 58 of file RecorderPriv.h.

{ return fRecorder->fDrawBufferManager.get(); }

flushTrackedDevices()

void skgpu::graphite::RecorderPriv::flushTrackedDevices

(

)

Definition at line 490 of file Recorder.cpp.

                                       {
    ASSERT_SINGLE_OWNER_PRIV
 
    // If this is the initial flushTrackedDevices() call, fFlushingTrackedDevicesIndex will be -1
    // so we start iterating at 0. We remember the starting device index to perform clean up only
    // when it was 0 to prevent modifying the underlying data structure while iterating over it.
    // However, when flushing one device it may register new devices as well as recursively call
    // flushTrackedDevices(). In that case, it picks up the next device after the current one that
    // triggered the recursive flush since all prior devices have been flushed are in progress
    // (and they should not be flushed while in an unfinished flush). When the control flow returns
    // to the outer flushTrackedDevices(), it will pick up with wherever the inner flush had ended.
    // TODO(b/330864257): Once paint data is extracted at draw time (so picture shaders are rendered
    // to images before a flush instead of inside a flush), we can simplify this and assert that
    // flushTrackedDevices() is not recursively called and that devices are not added or removed
    // while flushing.
    const int startingIndex = fRecorder->fFlushingDevicesIndex;
    while (fRecorder->fFlushingDevicesIndex < fRecorder->fTrackedDevices.size() - 1) {
        // Advance before calling flushPendingWorkToRecorder() so that any re-entrant clal to
        // flushTrackedDevices() will skip the current device.
        fRecorder->fFlushingDevicesIndex++;
        // Entries may be set to null from a call to deregisterDevice(), which will be cleaned up
        // along with any immutable or uniquely held Devices once everything is flushed.
        Device* device = fRecorder->fTrackedDevices[fRecorder->fFlushingDevicesIndex].get();
        if (device) {
            device->flushPendingWorkToRecorder();
        }
    }
 
    // Issue next upload flush token. This is only used by the atlasing code which
    // always uses this method. Calling in Device::flushPendingWorkToRecorder may
    // miss parent device flushes, increment too often, and lead to atlas corruption.
    this->tokenTracker()->issueFlushToken();
 
    if (startingIndex < 0) {
        // Initial call to flushTrackedDevices() so cleanup null/immutable devices and reset the
        // loop index.
        int i = 0;
        while (i < fRecorder->fTrackedDevices.size()) {
            Device* device = fRecorder->fTrackedDevices[i].get();
            if (!device || !device->recorder() || device->unique()) {
                if (device) {
                    device->abandonRecorder(); // Keep ~Device() happy
                }
                fRecorder->fTrackedDevices.removeShuffle(i);
                // Keep i as-is to process what was just shuffled to the ith index.
            } else {
                i++;
            }
        }
 
        fRecorder->fFlushingDevicesIndex = -1;
    }
}

getResourceCacheLimit()

size_t skgpu::graphite::RecorderPriv::getResourceCacheLimit

(

)

const

Definition at line 557 of file Recorder.cpp.

                                                 {
    return fRecorder->fResourceProvider->getResourceCacheLimit();
}

isProtected()

Protected skgpu::graphite::RecorderPriv::isProtected ( ) const

inline

Definition at line 52 of file RecorderPriv.h.

                                  {
        return fRecorder->fSharedContext->isProtected();
    }

proxyCache()

ProxyCache * skgpu::graphite::RecorderPriv::proxyCache ( )

inline

Definition at line 67 of file RecorderPriv.h.

{ return this->resourceProvider()->proxyCache(); }

rendererProvider()

const RendererProvider * skgpu::graphite::RecorderPriv::rendererProvider ( ) const

inline

Definition at line 48 of file RecorderPriv.h.

                                                     {
        return fRecorder->fSharedContext->rendererProvider();
    }

resourceProvider()

ResourceProvider * skgpu::graphite::RecorderPriv::resourceProvider ( )

inline

Definition at line 33 of file RecorderPriv.h.

{ return fRecorder->fResourceProvider; }

runtimeEffectDictionary() [1/2]

RuntimeEffectDictionary * skgpu::graphite::RecorderPriv::runtimeEffectDictionary ( )

inline

Definition at line 38 of file RecorderPriv.h.

                                                       {
        return fRecorder->fRuntimeEffectDict.get();
    }

runtimeEffectDictionary() [2/2]

const RuntimeEffectDictionary * skgpu::graphite::RecorderPriv::runtimeEffectDictionary ( ) const

inline

Definition at line 35 of file RecorderPriv.h.

                                                                   {
        return fRecorder->fRuntimeEffectDict.get();
    }

shaderCodeDictionary() [1/2]

ShaderCodeDictionary * skgpu::graphite::RecorderPriv::shaderCodeDictionary ( )

inline

Definition at line 44 of file RecorderPriv.h.

                                                 {
        return fRecorder->fSharedContext->shaderCodeDictionary();
    }

shaderCodeDictionary() [2/2]

const ShaderCodeDictionary * skgpu::graphite::RecorderPriv::shaderCodeDictionary ( ) const

inline

Definition at line 41 of file RecorderPriv.h.

                                                             {
        return fRecorder->fSharedContext->shaderCodeDictionary();
    }

strikeCache()

sktext::gpu::StrikeCache * skgpu::graphite::RecorderPriv::strikeCache ( )

inline

Definition at line 63 of file RecorderPriv.h.

{ return fRecorder->fStrikeCache.get(); }

textBlobCache()

sktext::gpu::TextBlobRedrawCoordinator * skgpu::graphite::RecorderPriv::textBlobCache ( )

inline

Definition at line 64 of file RecorderPriv.h.

                                                        {
        return fRecorder->fTextBlobCache.get();
    }

textureDataCache()

TextureDataCache * skgpu::graphite::RecorderPriv::textureDataCache ( )

inline

Definition at line 57 of file RecorderPriv.h.

{ return fRecorder->fTextureDataCache.get(); }

tokenTracker()

TokenTracker * skgpu::graphite::RecorderPriv::tokenTracker ( )

inline

Definition at line 62 of file RecorderPriv.h.

{ return fRecorder->fTokenTracker.get(); }

uniformDataCache()

UniformDataCache * skgpu::graphite::RecorderPriv::uniformDataCache ( )

inline

Definition at line 56 of file RecorderPriv.h.

{ return fRecorder->fUniformDataCache.get(); }

uniqueID()

uint32_t skgpu::graphite::RecorderPriv::uniqueID ( ) const

inline

Definition at line 76 of file RecorderPriv.h.

{ return fRecorder->fUniqueID; }

uploadBufferManager()

UploadBufferManager * skgpu::graphite::RecorderPriv::uploadBufferManager ( )

inline

Definition at line 59 of file RecorderPriv.h.

{ return fRecorder->fUploadBufferManager.get(); }

Friends And Related Function Documentation

Recorder

friend class Recorder

friend

Definition at line 103 of file RecorderPriv.h.

---

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

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