kc3-lang/angle/src/libANGLE/SizedMRUCache.h

• Show log

  Commit

• Hash : 5d01d538
  Author :
  Date : 2020-05-12T18:13:52
  

  Resolve Bad Binary Link Failures
  
  When ANGLE_PROGRAM_BINARY_LOAD is enabled, Program::loadBinary
  unconditionally returns angle::Result::Continue to the caller. The
  caller, gl::Program::link, postpones the resolution of the link
  until resolveLinkImpl.
  
  Unfortunately, resolveLinkImpl is not able to tell whether the link
  failed because the shader from the developer is bad or because the
  loaded binary is not compatible with the backend. The former case
  should fail link. In the latter case, we should fallback to linking
  the program from the original shader sources. The loaded binary could
  be read from the on-disk shader cache and be corrupted or serialized
  with different revision and subsystem id than the currently loaded
  ANGLE backend.
  
  This fix adjusts Program::loadBinary and ProgramD3D::load so that
  angle::Result::Incomplete is returned to gl::Program::link when the
  binary is incompatible with the backend.  gl::Program:link falls back
  to compilation from original shader sources.
  
  Since no code checks the return value of SizedMRUCache::eraseByKey,
  modified it to now return void.
  
  Bug: chromium:1079497
  Change-Id: Id5271d7badad8627563e87859d1c9fdb81de5785
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2197944
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Commit-Queue: Rafael Cintron <rafael.cintron@microsoft.com>
  

Download

• src/libANGLE/SizedMRUCache.h

• //
  // Copyright 2017 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.
  //
  // SizedMRUCache.h: A hashing map that stores blobs of sized, untyped data.
  
  #ifndef LIBANGLE_SIZED_MRU_CACHE_H_
  #define LIBANGLE_SIZED_MRU_CACHE_H_
  
  #include <anglebase/containers/mru_cache.h>
  
  namespace angle
  {
  
  template <typename Key, typename Value>
  class SizedMRUCache final : angle::NonCopyable
  {
    public:
      SizedMRUCache(size_t maximumTotalSize)
          : mMaximumTotalSize(maximumTotalSize),
            mCurrentSize(0),
            mStore(SizedMRUCacheStore::NO_AUTO_EVICT)
      {}
  
      // Returns nullptr on failure.
      const Value *put(const Key &key, Value &&value, size_t size)
      {
          if (size > mMaximumTotalSize)
          {
              return nullptr;
          }
  
          // Check for existing key.
          eraseByKey(key);
  
          auto retVal = mStore.Put(key, ValueAndSize(std::move(value), size));
          mCurrentSize += size;
  
          shrinkToSize(mMaximumTotalSize);
  
          return &retVal->second.value;
      }
  
      bool get(const Key &key, const Value **valueOut)
      {
          const auto &iter = mStore.Get(key);
          if (iter == mStore.end())
          {
              return false;
          }
          *valueOut = &iter->second.value;
          return true;
      }
  
      bool getAt(size_t index, const Key **keyOut, const Value **valueOut)
      {
          if (index < mStore.size())
          {
              auto it = mStore.begin();
              std::advance(it, index);
              *keyOut   = &it->first;
              *valueOut = &it->second.value;
              return true;
          }
          *valueOut = nullptr;
          return false;
      }
  
      bool empty() const { return mStore.empty(); }
  
      void clear()
      {
          mStore.Clear();
          mCurrentSize = 0;
      }
  
      void eraseByKey(const Key &key)
      {
          // Check for existing key.
          auto existing = mStore.Peek(key);
          if (existing != mStore.end())
          {
              mCurrentSize -= existing->second.size;
              mStore.Erase(existing);
          }
      }
  
      size_t entryCount() const { return mStore.size(); }
  
      size_t size() const { return mCurrentSize; }
  
      // Also discards the cache contents.
      void resize(size_t maximumTotalSize)
      {
          clear();
          mMaximumTotalSize = maximumTotalSize;
      }
  
      // Reduce current memory usage.
      size_t shrinkToSize(size_t limit)
      {
          size_t initialSize = mCurrentSize;
  
          while (mCurrentSize > limit)
          {
              ASSERT(!mStore.empty());
              auto iter = mStore.rbegin();
              mCurrentSize -= iter->second.size;
              mStore.Erase(iter);
          }
  
          return (initialSize - mCurrentSize);
      }
  
      size_t maxSize() const { return mMaximumTotalSize; }
  
    private:
      struct ValueAndSize
      {
          ValueAndSize() : value(), size(0) {}
          ValueAndSize(Value &&value, size_t size) : value(std::move(value)), size(size) {}
          ValueAndSize(ValueAndSize &&other) : ValueAndSize() { *this = std::move(other); }
          ValueAndSize &operator=(ValueAndSize &&other)
          {
              std::swap(value, other.value);
              std::swap(size, other.size);
              return *this;
          }
  
          Value value;
          size_t size;
      };
  
      using SizedMRUCacheStore = base::HashingMRUCache<Key, ValueAndSize>;
  
      size_t mMaximumTotalSize;
      size_t mCurrentSize;
      SizedMRUCacheStore mStore;
  };
  
  // Helper function used in a few places.
  template <typename T>
  void TrimCache(size_t maxStates, size_t gcLimit, const char *name, T *cache)
  {
      const size_t kGarbageCollectionLimit = maxStates / 2 + gcLimit;
  
      if (cache->size() >= kGarbageCollectionLimit)
      {
          WARN() << "Overflowed the " << name << " cache limit of " << (maxStates / 2)
                 << " elements, removing the least recently used to make room.";
          cache->ShrinkToSize(maxStates / 2);
      }
  }
  }  // namespace angle
  #endif  // LIBANGLE_SIZED_MRU_CACHE_H_
  

Download