From 0a7aebadfbb3534284546aa3ca8612314c08f136 Mon Sep 17 00:00:00 2001
From: Miguel Costa <miguel.costa@qt.io>
Date: Tue, 26 Jun 2018 16:56:45 +0200
Subject: Update ANGLE to chromium/3280

Change-Id: I0802c0d7486f772d361f87a544d6c5af937f4ca1
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
---
 .../angle/src/libANGLE/MemoryProgramCache.h        | 130 +++++++++++++++++++++
 1 file changed, 130 insertions(+)
 create mode 100644 src/3rdparty/angle/src/libANGLE/MemoryProgramCache.h

(limited to 'src/3rdparty/angle/src/libANGLE/MemoryProgramCache.h')

diff --git a/src/3rdparty/angle/src/libANGLE/MemoryProgramCache.h b/src/3rdparty/angle/src/libANGLE/MemoryProgramCache.h
new file mode 100644
index 0000000000..044bd48ecc
--- /dev/null
+++ b/src/3rdparty/angle/src/libANGLE/MemoryProgramCache.h
@@ -0,0 +1,130 @@
+//
+// 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.
+//
+// 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/Error.h"
+#include "libANGLE/SizedMRUCache.h"
+
+namespace gl
+{
+// 160-bit SHA-1 hash key.
+constexpr size_t kProgramHashLength = 20;
+using ProgramHash                   = std::array<uint8_t, kProgramHashLength>;
+}  // namespace gl
+
+namespace std
+{
+template <>
+struct hash<gl::ProgramHash>
+{
+    // Simple routine to hash four ints.
+    size_t operator()(const gl::ProgramHash &programHash) const
+    {
+        unsigned int hash = 0;
+        for (uint32_t num : programHash)
+        {
+            hash *= 37;
+            hash += num;
+        }
+        return hash;
+    }
+};
+}  // namespace std
+
+namespace gl
+{
+class Context;
+class InfoLog;
+class Program;
+class ProgramState;
+
+class MemoryProgramCache final : angle::NonCopyable
+{
+  public:
+    MemoryProgramCache(size_t maxCacheSizeBytes);
+    ~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 LinkResult 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, ProgramHash *hashOut);
+
+    // Check if the cache contains a binary matching the specified program.
+    bool get(const ProgramHash &programHash, const angle::MemoryBuffer **programOut);
+
+    // For querying the contents of the cache.
+    bool getAt(size_t index, ProgramHash *hashOut, const angle::MemoryBuffer **programOut);
+
+    // Evict a program from the binary cache.
+    void remove(const ProgramHash &programHash);
+
+    // Helper method that serializes a program.
+    void putProgram(const ProgramHash &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.
+    void putBinary(const ProgramHash &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.
+    LinkResult getProgram(const Context *context,
+                          const Program *program,
+                          ProgramState *state,
+                          ProgramHash *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:
+    enum class CacheSource
+    {
+        PutProgram,
+        PutBinary,
+    };
+
+    using CacheEntry = std::pair<angle::MemoryBuffer, CacheSource>;
+    angle::SizedMRUCache<ProgramHash, CacheEntry> mProgramBinaryCache;
+    unsigned int mIssuedWarnings;
+};
+
+}  // namespace gl
+
+#endif  // LIBANGLE_MEMORY_PROGRAM_CACHE_H_
-- 
cgit v1.2.3