1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
//
// Copyright 2022 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// MemoryShaderCache: Stores compiled shader in memory so they don't
// always have to be re-compiled. Can be used in conjunction with the platform
// layer to warm up the cache from disk.
#include "libANGLE/MemoryShaderCache.h"
#include <GLSLANG/ShaderVars.h>
#include <anglebase/sha1.h>
#include "common/angle_version_info.h"
#include "common/utilities.h"
#include "libANGLE/BinaryStream.h"
#include "libANGLE/Compiler.h"
#include "libANGLE/Context.h"
#include "libANGLE/Debug.h"
#include "libANGLE/Uniform.h"
#include "libANGLE/histogram_macros.h"
#include "libANGLE/renderer/ShaderImpl.h"
#include "platform/PlatformMethods.h"
namespace gl
{
namespace
{
void ComputeHash(const Context *context,
const Shader *shader,
const ShCompileOptions &compileOptions,
const ShCompilerInstance &compilerInstance,
egl::BlobCache::Key *hashOut)
{
BinaryOutputStream hashStream;
// Compute the shader hash. Start with the shader hashes and resource strings.
hashStream.writeEnum(shader->getType());
hashStream.writeString(shader->getSourceString());
// Include the commit hash
hashStream.writeString(angle::GetANGLECommitHash());
hashStream.writeEnum(Compiler::SelectShaderSpec(context->getState()));
hashStream.writeEnum(compilerInstance.getShaderOutputType());
hashStream.writeBytes(reinterpret_cast<const uint8_t *>(&compileOptions),
sizeof(compileOptions));
// Include the ShBuiltInResources, which represent the extensions and constants used by the
// shader.
const ShBuiltInResources resources = compilerInstance.getBuiltInResources();
hashStream.writeBytes(reinterpret_cast<const uint8_t *>(&resources), sizeof(resources));
// Call the secure SHA hashing function.
const std::vector<uint8_t> &shaderKey = hashStream.getData();
angle::base::SHA1HashBytes(shaderKey.data(), shaderKey.size(), hashOut->data());
}
} // namespace
MemoryShaderCache::MemoryShaderCache(egl::BlobCache &blobCache) : mBlobCache(blobCache) {}
MemoryShaderCache::~MemoryShaderCache() {}
angle::Result MemoryShaderCache::getShader(const Context *context,
Shader *shader,
const ShCompileOptions &compileOptions,
const ShCompilerInstance &compilerInstance,
egl::BlobCache::Key *hashOut)
{
// If caching is effectively disabled, don't bother calculating the hash.
if (!mBlobCache.isCachingEnabled())
{
return angle::Result::Incomplete;
}
ComputeHash(context, shader, compileOptions, compilerInstance, hashOut);
angle::MemoryBuffer uncompressedData;
switch (mBlobCache.getAndDecompress(context->getScratchBuffer(), *hashOut, &uncompressedData))
{
case egl::BlobCache::GetAndDecompressResult::DecompressFailure:
ANGLE_PERF_WARNING(context->getState().getDebug(), GL_DEBUG_SEVERITY_LOW,
"Error decompressing shader binary data from cache.");
return angle::Result::Incomplete;
case egl::BlobCache::GetAndDecompressResult::NotFound:
return angle::Result::Incomplete;
case egl::BlobCache::GetAndDecompressResult::GetSuccess:
angle::Result result = shader->loadBinary(context, uncompressedData.data(),
static_cast<int>(uncompressedData.size()));
{
std::scoped_lock<std::mutex> lock(mHistogramMutex);
ANGLE_HISTOGRAM_BOOLEAN("GPU.ANGLE.ShaderCache.LoadBinarySuccess",
result == angle::Result::Continue);
}
ANGLE_TRY(result);
if (result == angle::Result::Continue)
return angle::Result::Continue;
// Cache load failed, evict.
ANGLE_PERF_WARNING(context->getState().getDebug(), GL_DEBUG_SEVERITY_LOW,
"Failed to load shader binary from cache.");
mBlobCache.remove(*hashOut);
return angle::Result::Incomplete;
}
UNREACHABLE();
return angle::Result::Incomplete;
}
angle::Result MemoryShaderCache::putShader(const Context *context,
const egl::BlobCache::Key &shaderHash,
const Shader *shader)
{
// If caching is effectively disabled, don't bother serializing the shader.
if (!mBlobCache.isCachingEnabled())
{
return angle::Result::Incomplete;
}
angle::MemoryBuffer serializedShader;
ANGLE_TRY(shader->serialize(nullptr, &serializedShader));
size_t compressedSize;
if (!mBlobCache.compressAndPut(shaderHash, std::move(serializedShader), &compressedSize))
{
ANGLE_PERF_WARNING(context->getState().getDebug(), GL_DEBUG_SEVERITY_LOW,
"Error compressing shader binary data for insertion into cache.");
return angle::Result::Incomplete;
}
{
std::scoped_lock<std::mutex> lock(mHistogramMutex);
ANGLE_HISTOGRAM_COUNTS("GPU.ANGLE.ShaderCache.ShaderBinarySizeBytes",
static_cast<int>(compressedSize));
}
return angle::Result::Continue;
}
void MemoryShaderCache::clear()
{
mBlobCache.clear();
}
size_t MemoryShaderCache::maxSize() const
{
return mBlobCache.maxSize();
}
} // namespace gl
|
