sk_gpu_test::MemoryCache Class Reference

#include <MemoryCache.h>

Inheritance diagram for sk_gpu_test::MemoryCache:

Public Member Functions
	MemoryCache ()=default
	MemoryCache (const MemoryCache &)=delete
MemoryCache &	operator= (const MemoryCache &)=delete
void	reset ()
sk_sp< SkData >	load (const SkData &key) override
void	store (const SkData &key, const SkData &data, const SkString &description) override
int	numCacheMisses () const
int	numCacheStores () const
void	resetCacheStats ()
void	writeShadersToDisk (const char *path, GrBackendApi backend)
template<typename Fn >
void	foreach (Fn &&fn)
Public Member Functions inherited from GrContextOptions::PersistentCache
virtual	~PersistentCache ()=default
virtual sk_sp< SkData >	load (const SkData &key)=0
virtual void	store (const SkData &, const SkData &)
virtual void	store (const SkData &key, const SkData &data, const SkString &)

Additional Inherited Members
Protected Member Functions inherited from GrContextOptions::PersistentCache
	PersistentCache ()=default
	PersistentCache (const PersistentCache &)=delete
PersistentCache &	operator= (const PersistentCache &)=delete

Detailed Description

This class can be used to maintain an in memory record of all programs cached by GrContext. It can be shared by multiple GrContexts so long as those GrContexts are created with the same options and will have the same GrCaps (e.g. same backend, same GL context creation parameters, ...).

Definition at line 25 of file MemoryCache.h.

Constructor & Destructor Documentation

MemoryCache() [1/2]

sk_gpu_test::MemoryCache::MemoryCache ( )

default

MemoryCache() [2/2]

sk_gpu_test::MemoryCache::MemoryCache ( const MemoryCache &  )

delete

Member Function Documentation

foreach()

template<typename Fn >

void sk_gpu_test::MemoryCache::foreach ( Fn &&  fn )

inline

Definition at line 47 of file MemoryCache.h.

                          {
        for (auto it = fMap.begin(); it != fMap.end(); ++it) {
            fn(it->first.fKey, it->second.fData, it->second.fDescription, it->second.fHitCount);
        }
    }

load()

sk_sp< SkData > sk_gpu_test::MemoryCache::load ( const SkData &  key )

overridevirtual

Returns the data for the key if it exists in the cache, otherwise returns null.

Implements GrContextOptions::PersistentCache.

Definition at line 39 of file MemoryCache.cpp.

                                                 {
    auto result = fMap.find(key);
    if (result == fMap.end()) {
        if (LOG_MEMORY_CACHE) {
            SkDebugf("Load Key: %s\n\tNot Found.\n\n", data_to_str(key).c_str());
        }
        ++fCacheMissCnt;
        return nullptr;
    }
    if (LOG_MEMORY_CACHE) {
        SkDebugf("Load Key: %s\n\tFound Data: %s\n\n", data_to_str(key).c_str(),
                 data_to_str(*result->second.fData).c_str());
    }
    result->second.fHitCount++;
    return result->second.fData;
}

numCacheMisses()

int sk_gpu_test::MemoryCache::numCacheMisses ( ) const

inline

Definition at line 37 of file MemoryCache.h.

{ return fCacheMissCnt; }

numCacheStores()

int sk_gpu_test::MemoryCache::numCacheStores ( ) const

inline

Definition at line 38 of file MemoryCache.h.

{ return fCacheStoreCnt; }

operator=()

MemoryCache & sk_gpu_test::MemoryCache::operator= ( const MemoryCache &  )

delete

reset()

void sk_gpu_test::MemoryCache::reset ( )

inline

Definition at line 30 of file MemoryCache.h.

                 {
        this->resetCacheStats();
        fMap.clear();
    }

resetCacheStats()

void sk_gpu_test::MemoryCache::resetCacheStats ( )

inline

Definition at line 39 of file MemoryCache.h.

                           {
        fCacheMissCnt = 0;
        fCacheStoreCnt = 0;
    }

store()

void sk_gpu_test::MemoryCache::store ( const SkData &  key, const SkData &  data, const SkString &    )

overridevirtual

Stores data in the cache, indexed by key. description provides a human-readable version of the key.

Reimplemented from GrContextOptions::PersistentCache.

Definition at line 56 of file MemoryCache.cpp.

                                                                                          {
    if (LOG_MEMORY_CACHE) {
        SkDebugf("Store Key: %s\n\tData: %s\n\n", data_to_str(key).c_str(),
                 data_to_str(data).c_str());
    }
    ++fCacheStoreCnt;
    fMap[Key(key)] = Value(data, description);
}

writeShadersToDisk()

void sk_gpu_test::MemoryCache::writeShadersToDisk	(	const char *	path,
		GrBackendApi	backend
	)

Definition at line 65 of file MemoryCache.cpp.

                                                                       {
    if (GrBackendApi::kOpenGL != api && GrBackendApi::kVulkan != api) {
        return;
    }
 
    for (auto it = fMap.begin(); it != fMap.end(); ++it) {
        SkMD5 hash;
        size_t bytesToHash = it->first.fKey->size();
#if defined(SK_VULKAN)
        if (GrBackendApi::kVulkan == api) {
            // Vulkan stores two kinds of data in the cache (shaders and pipelines). The last four
            // bytes of the key identify which one we have. We only want to extract shaders.
            // Additionally, we don't want to hash the tag bytes, so we get the same keys as GL,
            // which is good for cross-checking code generation and performance.
            GrVkGpu::PersistentCacheKeyType vkKeyType;
            SkASSERT(bytesToHash >= sizeof(vkKeyType));
            bytesToHash -= sizeof(vkKeyType);
            memcpy(&vkKeyType, it->first.fKey->bytes() + bytesToHash, sizeof(vkKeyType));
            if (vkKeyType != GrVkGpu::kShader_PersistentCacheKeyType) {
                continue;
            }
        }
#endif
        hash.write(it->first.fKey->bytes(), bytesToHash);
        SkMD5::Digest digest = hash.finish();
        SkString md5 = digest.toLowercaseHexString();
 
        SkSL::Program::Interface interfacesIgnored[kGrShaderTypeCount];
        std::string shaders[kGrShaderTypeCount];
        const SkData* data = it->second.fData.get();
        const SkString& description = it->second.fDescription;
        SkReadBuffer reader(data->data(), data->size());
        GrPersistentCacheUtils::GetType(&reader); // Shader type tag
        GrPersistentCacheUtils::UnpackCachedShaders(&reader, shaders,
                                                    interfacesIgnored, kGrShaderTypeCount);
 
        // Even with the SPIR-V switches, it seems like we must use .spv, or malisc tries to
        // run glslang on the input.
        {
            const char* ext = GrBackendApi::kOpenGL == api ? "frag" : "frag.spv";
            SkString filename = SkStringPrintf("%s/%s.%s", path, md5.c_str(), ext);
            SkFILEWStream file(filename.c_str());
            file.write(shaders[kFragment_GrShaderType].c_str(),
                       shaders[kFragment_GrShaderType].size());
        }
        {
            const char* ext = GrBackendApi::kOpenGL == api ? "vert" : "vert.spv";
            SkString filename = SkStringPrintf("%s/%s.%s", path, md5.c_str(), ext);
            SkFILEWStream file(filename.c_str());
            file.write(shaders[kVertex_GrShaderType].c_str(),
                       shaders[kVertex_GrShaderType].size());
        }
 
        if (!description.isEmpty()) {
            const char* ext = "key";
            SkString filename = SkStringPrintf("%s/%s.%s", path, md5.c_str(), ext);
            SkFILEWStream file(filename.c_str());
            file.write(description.c_str(), description.size());
        }
    }
}

---

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

• third_party/skia/tools/gpu/MemoryCache.h
• third_party/skia/tools/gpu/MemoryCache.cpp