xref: /aosp_15_r20/external/skia/tools/gpu/MemoryCache.cpp (revision c8dee2aa9b3f27cf6c858bd81872bdeb2c07ed17)
1 /*
2  * Copyright 2018 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #include "src/base/SkBase64.h"
9 #include "src/core/SkMD5.h"
10 #include "src/core/SkReadBuffer.h"
11 #include "src/gpu/ganesh/GrPersistentCacheUtils.h"
12 #include "tools/gpu/MemoryCache.h"
13 
14 #if defined(SK_VULKAN)
15 #include "src/gpu/ganesh/vk/GrVkGpu.h"
16 #endif
17 
18 // Change this to 1 to log cache hits/misses/stores using SkDebugf.
19 #define LOG_MEMORY_CACHE 0
20 
data_to_str(const SkData & data)21 static SkString data_to_str(const SkData& data) {
22     size_t encodeLength = SkBase64::EncodedSize(data.size());
23     SkString str;
24     str.resize(encodeLength);
25     SkBase64::Encode(data.data(), data.size(), str.data());
26     static constexpr size_t kMaxLength = 60;
27     static constexpr char kTail[] = "...";
28     static const size_t kTailLen = strlen(kTail);
29     bool overlength = encodeLength > kMaxLength;
30     if (overlength) {
31         str = SkString(str.c_str(), kMaxLength - kTailLen);
32         str.append(kTail);
33     }
34     return str;
35 }
36 
37 namespace sk_gpu_test {
38 
load(const SkData & key)39 sk_sp<SkData> MemoryCache::load(const SkData& key) {
40     auto result = fMap.find(key);
41     if (result == fMap.end()) {
42         if (LOG_MEMORY_CACHE) {
43             SkDebugf("Load Key: %s\n\tNot Found.\n\n", data_to_str(key).c_str());
44         }
45         ++fCacheMissCnt;
46         return nullptr;
47     }
48     if (LOG_MEMORY_CACHE) {
49         SkDebugf("Load Key: %s\n\tFound Data: %s\n\n", data_to_str(key).c_str(),
50                  data_to_str(*result->second.fData).c_str());
51     }
52     result->second.fHitCount++;
53     return result->second.fData;
54 }
55 
store(const SkData & key,const SkData & data,const SkString & description)56 void MemoryCache::store(const SkData& key, const SkData& data, const SkString& description) {
57     if (LOG_MEMORY_CACHE) {
58         SkDebugf("Store Key: %s\n\tData: %s\n\n", data_to_str(key).c_str(),
59                  data_to_str(data).c_str());
60     }
61     ++fCacheStoreCnt;
62     fMap[Key(key)] = Value(data, description);
63 }
64 
writeShadersToDisk(const char * path,GrBackendApi api)65 void MemoryCache::writeShadersToDisk(const char* path, GrBackendApi api) {
66     if (GrBackendApi::kOpenGL != api && GrBackendApi::kVulkan != api) {
67         return;
68     }
69 
70     for (auto it = fMap.begin(); it != fMap.end(); ++it) {
71         SkMD5 hash;
72         size_t bytesToHash = it->first.fKey->size();
73 #if defined(SK_VULKAN)
74         if (GrBackendApi::kVulkan == api) {
75             // Vulkan stores two kinds of data in the cache (shaders and pipelines). The last four
76             // bytes of the key identify which one we have. We only want to extract shaders.
77             // Additionally, we don't want to hash the tag bytes, so we get the same keys as GL,
78             // which is good for cross-checking code generation and performance.
79             GrVkGpu::PersistentCacheKeyType vkKeyType;
80             SkASSERT(bytesToHash >= sizeof(vkKeyType));
81             bytesToHash -= sizeof(vkKeyType);
82             memcpy(&vkKeyType, it->first.fKey->bytes() + bytesToHash, sizeof(vkKeyType));
83             if (vkKeyType != GrVkGpu::kShader_PersistentCacheKeyType) {
84                 continue;
85             }
86         }
87 #endif
88         hash.write(it->first.fKey->bytes(), bytesToHash);
89         SkMD5::Digest digest = hash.finish();
90         SkString md5 = digest.toLowercaseHexString();
91 
92         SkSL::Program::Interface interfacesIgnored[kGrShaderTypeCount];
93         std::string shaders[kGrShaderTypeCount];
94         const SkData* data = it->second.fData.get();
95         const SkString& description = it->second.fDescription;
96         SkReadBuffer reader(data->data(), data->size());
97         GrPersistentCacheUtils::GetType(&reader); // Shader type tag
98         GrPersistentCacheUtils::UnpackCachedShaders(&reader, shaders,
99                                                     interfacesIgnored, kGrShaderTypeCount);
100 
101         // Even with the SPIR-V switches, it seems like we must use .spv, or malisc tries to
102         // run glslang on the input.
103         {
104             const char* ext = GrBackendApi::kOpenGL == api ? "frag" : "frag.spv";
105             SkString filename = SkStringPrintf("%s/%s.%s", path, md5.c_str(), ext);
106             SkFILEWStream file(filename.c_str());
107             file.write(shaders[kFragment_GrShaderType].c_str(),
108                        shaders[kFragment_GrShaderType].size());
109         }
110         {
111             const char* ext = GrBackendApi::kOpenGL == api ? "vert" : "vert.spv";
112             SkString filename = SkStringPrintf("%s/%s.%s", path, md5.c_str(), ext);
113             SkFILEWStream file(filename.c_str());
114             file.write(shaders[kVertex_GrShaderType].c_str(),
115                        shaders[kVertex_GrShaderType].size());
116         }
117 
118         if (!description.isEmpty()) {
119             const char* ext = "key";
120             SkString filename = SkStringPrintf("%s/%s.%s", path, md5.c_str(), ext);
121             SkFILEWStream file(filename.c_str());
122             file.write(description.c_str(), description.size());
123         }
124     }
125 }
126 
127 }  // namespace sk_gpu_test
128