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

• Show log

  Commit

• Hash : 785e8a0b
  Author :
  Date : 2018-10-04T17:42:00
  

  Remove gl::LinkResult.
  
  Instead of returning a small struct from LinkProgram calls we use
  angle::Result. Linking can have 3 cases:
  
  - the link was successful -> angle::Result::Continue
  - the link failed -> angle::Result::Incomplete
  - there was an internal error -> angle::Result::Stop
  
  Note that any unexpected Incomplete is still an error. Each function
  that accepts Incomplete must check explicitly.
  
  This is the last user of ErrorOrResult.
  
  Bug: angleproject:2491
  Change-Id: Idba23be27efe4b561720a4bdd8fe486b40779497
  Reviewed-on: https://chromium-review.googlesource.com/c/1255645
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@google.com>
  

Download

• src/libANGLE/MemoryProgramCache.h

• //
  // Copyright 2017-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.
  //
  // MemoryProgramCache: 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_MEMORY_PROGRAM_CACHE_H_
  #define LIBANGLE_MEMORY_PROGRAM_CACHE_H_
  
  #include <array>
  
  #include "common/MemoryBuffer.h"
  #include "libANGLE/BlobCache.h"
  #include "libANGLE/Error.h"
  
  namespace gl
  {
  class Context;
  class InfoLog;
  class Program;
  class ProgramState;
  
  class MemoryProgramCache final : angle::NonCopyable
  {
    public:
      explicit MemoryProgramCache(egl::BlobCache &blobCache);
      ~MemoryProgramCache();
  
      // Writes a program's binary to the output memory buffer.
      static void Serialize(const Context *context,
                            const Program *program,
                            angle::MemoryBuffer *binaryOut);
  
      // Loads program state according to the specified binary blob.
      static angle::Result Deserialize(const Context *context,
                                       const Program *program,
                                       ProgramState *state,
                                       const uint8_t *binary,
                                       size_t length,
                                       InfoLog &infoLog);
  
      static void ComputeHash(const Context *context,
                              const Program *program,
                              egl::BlobCache::Key *hashOut);
  
      // Check if the cache contains a binary matching the specified program.
      bool get(const Context *context,
               const egl::BlobCache::Key &programHash,
               egl::BlobCache::Value *programOut);
  
      // For querying the contents of the cache.
      bool getAt(size_t index,
                 const egl::BlobCache::Key **hashOut,
                 egl::BlobCache::Value *programOut);
  
      // Evict a program from the binary cache.
      void remove(const egl::BlobCache::Key &programHash);
  
      // Helper method that serializes a program.
      void putProgram(const egl::BlobCache::Key &programHash,
                      const Context *context,
                      const Program *program);
  
      // Same as putProgram but computes the hash.
      void updateProgram(const Context *context, const Program *program);
  
      // Store a binary directly.  TODO(syoussefi): deprecated.  Will be removed once Chrome supports
      // EGL_ANDROID_blob_cache. http://anglebug.com/2516
      void putBinary(const egl::BlobCache::Key &programHash, const uint8_t *binary, size_t length);
  
      // Check the cache, and deserialize and load the program if found. Evict existing hash if load
      // fails.
      angle::Result getProgram(const Context *context,
                               const Program *program,
                               ProgramState *state,
                               egl::BlobCache::Key *hashOut);
  
      // Empty the cache.
      void clear();
  
      // Resize the cache. Discards current contents.
      void resize(size_t maxCacheSizeBytes);
  
      // Returns the number of entries in the cache.
      size_t entryCount() const;
  
      // Reduces the current cache size and returns the number of bytes freed.
      size_t trim(size_t limit);
  
      // Returns the current cache size in bytes.
      size_t size() const;
  
      // Returns the maximum cache size in bytes.
      size_t maxSize() const;
  
    private:
      egl::BlobCache &mBlobCache;
      unsigned int mIssuedWarnings;
  };
  
  }  // namespace gl
  
  #endif  // LIBANGLE_MEMORY_PROGRAM_CACHE_H_
  

Download