MemoryShaderCache.cpp

Enable keyboard shortcuts

//

// 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