tor-browser

BlobCache.h (6233B)

---

//
// Copyright 2018 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.
//
// BlobCache: Stores compiled and linked programs 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.

#ifndef LIBANGLE_BLOB_CACHE_H_
#define LIBANGLE_BLOB_CACHE_H_

#include <array>
#include <cstring>

#include <anglebase/sha1.h>
#include "common/MemoryBuffer.h"
#include "common/hash_utils.h"
#include "libANGLE/Error.h"
#include "libANGLE/SizedMRUCache.h"

namespace gl
{
class Context;
}  // namespace gl

namespace egl
{
// 160-bit SHA-1 hash key used for hasing a program.  BlobCache opts in using fixed keys for
// simplicity and efficiency.
static constexpr size_t kBlobCacheKeyLength = angle::base::kSHA1Length;
using BlobCacheKey                          = std::array<uint8_t, kBlobCacheKeyLength>;
}  // namespace egl

namespace std
{
template <>
struct hash<egl::BlobCacheKey>
{
   // Simple routine to hash four ints.
   size_t operator()(const egl::BlobCacheKey &key) const
   {
       return angle::ComputeGenericHash(key.data(), key.size());
   }
};
}  // namespace std

namespace egl
{

bool CompressBlobCacheData(const size_t cacheSize,
                          const uint8_t *cacheData,
                          angle::MemoryBuffer *compressedData);
bool DecompressBlobCacheData(const uint8_t *compressedData,
                            const size_t compressedSize,
                            angle::MemoryBuffer *uncompressedData);

class BlobCache final : angle::NonCopyable
{
 public:
   // 160-bit SHA-1 hash key used for hasing a program.  BlobCache opts in using fixed keys for
   // simplicity and efficiency.
   static constexpr size_t kKeyLength = kBlobCacheKeyLength;
   using Key                          = BlobCacheKey;
   class Value
   {
     public:
       Value() : mPtr(nullptr), mSize(0) {}
       Value(const uint8_t *ptr, size_t sz) : mPtr(ptr), mSize(sz) {}

       // A very basic struct to hold the pointer and size together.  The objects of this class
       // don't own the memory.
       const uint8_t *data() { return mPtr; }
       size_t size() { return mSize; }

       const uint8_t &operator[](size_t pos) const
       {
           ASSERT(pos < mSize);
           return mPtr[pos];
       }

     private:
       const uint8_t *mPtr;
       size_t mSize;
   };
   enum class CacheSource
   {
       Memory,
       Disk,
   };

   explicit BlobCache(size_t maxCacheSizeBytes);
   ~BlobCache();

   // Store a key-blob pair in the cache.  If application callbacks are set, the application cache
   // will be used.  Otherwise the value is cached in this object.
   void put(const BlobCache::Key &key, angle::MemoryBuffer &&value);

   // Store a key-blob pair in the cache, but compress the blob before insertion. Returns false if
   // compression fails, returns true otherwise.
   bool compressAndPut(const BlobCache::Key &key,
                       angle::MemoryBuffer &&uncompressedValue,
                       size_t *compressedSize);

   // Store a key-blob pair in the application cache, only if application callbacks are set.
   void putApplication(const BlobCache::Key &key, const angle::MemoryBuffer &value);

   // Store a key-blob pair in the cache without making callbacks to the application.  This is used
   // to repopulate this object's cache on startup without generating callback calls.
   void populate(const BlobCache::Key &key,
                 angle::MemoryBuffer &&value,
                 CacheSource source = CacheSource::Disk);

   // Check if the cache contains the blob corresponding to this key.  If application callbacks are
   // set, those will be used.  Otherwise they key is looked up in this object's cache.
   [[nodiscard]] bool get(angle::ScratchBuffer *scratchBuffer,
                          const BlobCache::Key &key,
                          BlobCache::Value *valueOut,
                          size_t *bufferSizeOut);

   // For querying the contents of the cache.
   [[nodiscard]] bool getAt(size_t index,
                            const BlobCache::Key **keyOut,
                            BlobCache::Value *valueOut);

   enum class GetAndDecompressResult
   {
       GetSuccess,
       NotFound,
       DecompressFailure,
   };
   [[nodiscard]] GetAndDecompressResult getAndDecompress(
       angle::ScratchBuffer *scratchBuffer,
       const BlobCache::Key &key,
       angle::MemoryBuffer *uncompressedValueOut);

   // Evict a blob from the binary cache.
   void remove(const BlobCache::Key &key);

   // Empty the cache.
   void clear() { mBlobCache.clear(); }

   // Resize the cache. Discards current contents.
   void resize(size_t maxCacheSizeBytes) { mBlobCache.resize(maxCacheSizeBytes); }

   // Returns the number of entries in the cache.
   size_t entryCount() const { return mBlobCache.entryCount(); }

   // Reduces the current cache size and returns the number of bytes freed.
   size_t trim(size_t limit) { return mBlobCache.shrinkToSize(limit); }

   // Returns the current cache size in bytes.
   size_t size() const { return mBlobCache.size(); }

   // Returns whether the cache is empty
   bool empty() const { return mBlobCache.empty(); }

   // Returns the maximum cache size in bytes.
   size_t maxSize() const { return mBlobCache.maxSize(); }

   void setBlobCacheFuncs(EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get);

   bool areBlobCacheFuncsSet() const;

   bool isCachingEnabled() const { return areBlobCacheFuncsSet() || maxSize() > 0; }

   std::mutex &getMutex() { return mBlobCacheMutex; }

 private:
   // This internal cache is used only if the application is not providing caching callbacks
   using CacheEntry = std::pair<angle::MemoryBuffer, CacheSource>;

   mutable std::mutex mBlobCacheMutex;
   angle::SizedMRUCache<BlobCache::Key, CacheEntry> mBlobCache;

   EGLSetBlobFuncANDROID mSetBlobFunc;
   EGLGetBlobFuncANDROID mGetBlobFunc;
};

}  // namespace egl

#endif  // LIBANGLE_MEMORY_PROGRAM_CACHE_H_