kc3-lang/angle/src/libANGLE/MemoryShaderCache.cpp

• Show log

  Commit

• Hash : ba4b6913
  Author :
  Date : 2022-08-23T09:34:27
  

  Fix data race in BlobCache
  
  * Re-enable shader cache feature
  * Improve BlobCache thread-safety test
  * Improve EGLProgramCacheControlTest to not check the size
    of the BlobCache, since the shader cache interferes with this.
  * Include the arguments to ConstructCompiler() and Compile()
    in the key hash for the shader cache.
  
  Bug: angleproject:7036
  Change-Id: Ied4e11f9160552f2f9358d99b5656315239ba856
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3851161
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Eddie Hatfield <eddiehatfield@google.com>
  

Download

• src/libANGLE/MemoryShaderCache.cpp

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

Download