Use MemoryProgramCache.

src/common/MemoryBuffer.cpp

@@ -84,6 +84,18 @@ void MemoryBuffer::fill(uint8_t datum)
     }
 }
 
+MemoryBuffer::MemoryBuffer(MemoryBuffer &&other) : MemoryBuffer()
+{
+    *this = std::move(other);
+}
+
+MemoryBuffer &MemoryBuffer::operator=(MemoryBuffer &&other)
+{
+    std::swap(mSize, other.mSize);
+    std::swap(mData, other.mData);
+    return *this;
+}
+
 // ScratchBuffer implementation.
 
 ScratchBuffer::ScratchBuffer(uint32_t lifetime) : mLifetime(lifetime), mResetCounter(lifetime)

src/common/MemoryBuffer.h

@@ -21,6 +21,9 @@ class MemoryBuffer final : NonCopyable
     MemoryBuffer();
     ~MemoryBuffer();
 
+    MemoryBuffer(MemoryBuffer &&other);
+    MemoryBuffer &operator=(MemoryBuffer &&other);
+
     bool resize(size_t size);
     size_t size() const;
     bool empty() const { return mSize == 0; }

src/libANGLE/Compiler.cpp

@@ -192,4 +192,9 @@ ShHandle Compiler::getCompilerHandle(GLenum type)
     return *compiler;
 }
 
+const std::string &Compiler::getBuiltinResourcesString(GLenum type)
+{
+    return sh::GetBuiltInResourcesString(getCompilerHandle(type));
+}
+
 }  // namespace gl

src/libANGLE/Compiler.h

@@ -31,6 +31,7 @@ class Compiler final : public RefCountObjectNoID
 
     ShHandle getCompilerHandle(GLenum type);
     ShShaderOutput getShaderOutputType() const { return mOutputType; }
+    const std::string &getBuiltinResourcesString(GLenum type);
 
   private:
     ~Compiler() override;

src/libANGLE/Constants.h

@@ -9,9 +9,19 @@
 #ifndef LIBANGLE_CONSTANTS_H_
 #define LIBANGLE_CONSTANTS_H_
 
+#include "common/platform.h"
+
 namespace gl
 {
 
+// The size to set for the program cache for default and low-end device cases.
+#if !defined(ANGLE_PLATFORM_ANDROID)
+const size_t kDefaultMaxProgramCacheMemoryBytes = 6 * 1024 * 1024;
+#else
+const size_t kDefaultMaxProgramCacheMemoryBytes = 2 * 1024 * 1024;
+const size_t kLowEndMaxProgramCacheMemoryBytes  = 512 * 1024;
+#endif
+
 enum
 {
     MAX_VERTEX_ATTRIBS         = 16,

src/libANGLE/Context.cpp

@@ -243,6 +243,7 @@ Context::Context(rx::EGLImplFactory *implFactory,
                  const egl::Config *config,
                  const Context *shareContext,
                  TextureManager *shareTextures,
+                 MemoryProgramCache *memoryProgramCache,
                  const egl::AttributeMap &attribs,
                  const egl::DisplayExtensions &displayExtensions,
                  bool robustResourceInit)
@@ -270,6 +271,7 @@ Context::Context(rx::EGLImplFactory *implFactory,
       mCurrentDisplay(static_cast<egl::Display *>(EGL_NO_DISPLAY)),
       mSurfacelessFramebuffer(nullptr),
       mWebGLContext(GetWebGLContext(attribs)),
+      mMemoryProgramCache(memoryProgramCache),
       mScratchBuffer(1000u)
 {
     if (mRobustAccess)
@@ -2739,6 +2741,12 @@ void Context::updateCaps()
 
         mTextureCaps.insert(sizedInternalFormat, formatCaps);
     }
+
+    // If program binary is disabled, blank out the memory cache pointer.
+    if (!mImplementation->getNativeExtensions().getProgramBinary)
+    {
+        mMemoryProgramCache = nullptr;
+    }
 }
 
 void Context::initWorkarounds()

src/libANGLE/Context.h

@@ -43,20 +43,21 @@ class Thread;
 
 namespace gl
 {
+class Buffer;
 class Compiler;
-class Shader;
-class Program;
-class Texture;
-class Framebuffer;
-class Renderbuffer;
 class FenceNV;
 class FenceSync;
+class Framebuffer;
+class MemoryProgramCache;
+class Program;
 class Query;
-class Buffer;
-struct VertexAttribute;
-class VertexArray;
+class Renderbuffer;
 class Sampler;
+class Shader;
+class Texture;
 class TransformFeedback;
+class VertexArray;
+struct VertexAttribute;
 
 class Context final : public ValidationContext
 {
@@ -65,6 +66,7 @@ class Context final : public ValidationContext
             const egl::Config *config,
             const Context *shareContext,
             TextureManager *shareTextures,
+            MemoryProgramCache *memoryProgramCache,
             const egl::AttributeMap &attribs,
             const egl::DisplayExtensions &displayExtensions,
             bool robustResourceInit);
@@ -794,6 +796,8 @@ class Context final : public ValidationContext
 
     void dispatchCompute(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
 
+    MemoryProgramCache *getMemoryProgramCache() const { return mMemoryProgramCache; }
+
     template <EntryPoint EP, typename... ParamsT>
     void gatherParams(ParamsT &&... params);
 
@@ -895,6 +899,7 @@ class Context final : public ValidationContext
     egl::Display *mCurrentDisplay;
     Framebuffer *mSurfacelessFramebuffer;
     bool mWebGLContext;
+    MemoryProgramCache *mMemoryProgramCache;
 
     State::DirtyBits mTexImageDirtyBits;
     State::DirtyObjects mTexImageDirtyObjects;

src/libANGLE/Display.cpp

@@ -372,6 +372,7 @@ Display::Display(EGLenum platform, EGLNativeDisplayType displayId, Device *eglDe
       mDevice(eglDevice),
       mPlatform(platform),
       mTextureManager(nullptr),
+      mMemoryProgramCache(gl::kDefaultMaxProgramCacheMemoryBytes),
       mGlobalTextureShareGroupUsers(0),
       mProxyContext(this)
 {
@@ -491,7 +492,7 @@ Error Display::initialize()
     }
 
     mProxyContext.reset(nullptr);
-    gl::Context *proxyContext = new gl::Context(mImplementation, nullptr, nullptr, nullptr,
+    gl::Context *proxyContext = new gl::Context(mImplementation, nullptr, nullptr, nullptr, nullptr,
                                                 egl::AttributeMap(), mDisplayExtensions, false);
     mProxyContext.reset(proxyContext);
 
@@ -504,6 +505,8 @@ Error Display::terminate()
 {
     ANGLE_TRY(makeCurrent(nullptr, nullptr, nullptr));
 
+    mMemoryProgramCache.clear();
+
     mProxyContext.reset(nullptr);
 
     while (!mContextSet.empty())
@@ -738,9 +741,9 @@ Error Display::createContext(const Config *configuration,
         shareTextures = mTextureManager;
     }
 
-    gl::Context *context =
-        new gl::Context(mImplementation, configuration, shareContext, shareTextures, attribs,
-                        mDisplayExtensions, isRobustResourceInitEnabled());
+    gl::Context *context = new gl::Context(mImplementation, configuration, shareContext,
+                                           shareTextures, &mMemoryProgramCache, attribs,
+                                           mDisplayExtensions, isRobustResourceInitEnabled());
 
     ASSERT(context != nullptr);
     mContextSet.insert(context);

src/libANGLE/Display.h

@@ -19,6 +19,7 @@
 #include "libANGLE/Config.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/LoggingAnnotator.h"
+#include "libANGLE/MemoryProgramCache.h"
 #include "libANGLE/Version.h"
 
 namespace gl
@@ -188,6 +189,7 @@ class Display final : angle::NonCopyable
     angle::LoggingAnnotator mAnnotator;
 
     gl::TextureManager *mTextureManager;
+    gl::MemoryProgramCache mMemoryProgramCache;
     size_t mGlobalTextureShareGroupUsers;
 
     // This gl::Context is a simple proxy to the Display for the GL back-end entry points

src/libANGLE/MemoryProgramCache.cpp

@@ -10,6 +10,7 @@
 #include "libANGLE/MemoryProgramCache.h"
 
 #include <GLSLANG/ShaderVars.h>
+#include <anglebase/sha1.h>
 
 #include "common/version.h"
 #include "libANGLE/BinaryStream.h"
@@ -22,6 +23,7 @@ namespace gl
 
 namespace
 {
+constexpr unsigned int kWarningLimit = 3;
 
 void WriteShaderVar(BinaryOutputStream *stream, const sh::ShaderVariable &var)
 {
@@ -46,8 +48,62 @@ void LoadShaderVar(BinaryInputStream *stream, sh::ShaderVariable *var)
     var->structName = stream->readString();
 }
 
+class HashStream final : angle::NonCopyable
+{
+  public:
+    std::string str() { return mStringStream.str(); }
+
+    template <typename T>
+    HashStream &operator<<(T value)
+    {
+        mStringStream << value << kSeparator;
+        return *this;
+    }
+
+  private:
+    static constexpr char kSeparator = ':';
+    std::ostringstream mStringStream;
+};
+
+HashStream &operator<<(HashStream &stream, const Shader *shader)
+{
+    if (shader)
+    {
+        stream << shader->getSourceString().c_str() << shader->getSourceString().length()
+               << shader->getCompilerResourcesString().c_str();
+    }
+    return stream;
+}
+
+HashStream &operator<<(HashStream &stream, const Program::Bindings &bindings)
+{
+    for (const auto &binding : bindings)
+    {
+        stream << binding.first << binding.second;
+    }
+    return stream;
+}
+
+HashStream &operator<<(HashStream &stream, const std::vector<std::string> &strings)
+{
+    for (const auto &str : strings)
+    {
+        stream << str;
+    }
+    return stream;
+}
+
 }  // anonymous namespace
 
+MemoryProgramCache::MemoryProgramCache(size_t maxCacheSizeBytes)
+    : mProgramBinaryCache(maxCacheSizeBytes), mIssuedWarnings(0)
+{
+}
+
+MemoryProgramCache::~MemoryProgramCache()
+{
+}
+
 // static
 LinkResult MemoryProgramCache::Deserialize(const Context *context,
                                            const Program *program,
@@ -387,4 +443,118 @@ void MemoryProgramCache::Serialize(const Context *context,
     memcpy(binaryOut->data(), stream.data(), stream.length());
 }
 
+// static
+void MemoryProgramCache::ComputeHash(const Context *context,
+                                     const Program *program,
+                                     ProgramHash *hashOut)
+{
+    auto vertexShader   = program->getAttachedVertexShader();
+    auto fragmentShader = program->getAttachedFragmentShader();
+    auto computeShader  = program->getAttachedComputeShader();
+
+    // Compute the program hash. Start with the shader hashes and resource strings.
+    HashStream hashStream;
+    hashStream << vertexShader << fragmentShader << computeShader;
+
+    // Add some ANGLE metadata and Context properties, such as version and back-end.
+    hashStream << ANGLE_COMMIT_HASH << context->getClientMajorVersion()
+               << context->getClientMinorVersion() << context->getString(GL_RENDERER);
+
+    // Hash pre-link program properties.
+    hashStream << program->getAttributeBindings() << program->getUniformLocationBindings()
+               << program->getFragmentInputBindings()
+               << program->getState().getTransformFeedbackVaryingNames()
+               << program->getState().getTransformFeedbackBufferMode();
+
+    // Call the secure SHA hashing function.
+    const std::string &programKey = hashStream.str();
+    angle::base::SHA1HashBytes(reinterpret_cast<const unsigned char *>(programKey.c_str()),
+                               programKey.length(), hashOut->data());
+}
+
+LinkResult MemoryProgramCache::getProgram(const Context *context,
+                                          const Program *program,
+                                          ProgramState *state,
+                                          ProgramHash *hashOut)
+{
+    ComputeHash(context, program, hashOut);
+    const angle::MemoryBuffer *binaryProgram = nullptr;
+    LinkResult result(false);
+    if (get(*hashOut, &binaryProgram))
+    {
+        InfoLog infoLog;
+        ANGLE_TRY_RESULT(Deserialize(context, program, state, binaryProgram->data(),
+                                     binaryProgram->size(), infoLog),
+                         result);
+        if (!result.getResult())
+        {
+            // Cache load failed, evict.
+            if (mIssuedWarnings++ < kWarningLimit)
+            {
+                WARN() << "Failed to load binary from cache: " << infoLog.str();
+
+                if (mIssuedWarnings == kWarningLimit)
+                {
+                    WARN() << "Reaching warning limit for cache load failures, silencing "
+                              "subsequent warnings.";
+                }
+            }
+            remove(*hashOut);
+        }
+    }
+    return result;
+}
+
+bool MemoryProgramCache::get(const ProgramHash &programHash, const angle::MemoryBuffer **programOut)
+{
+    return mProgramBinaryCache.get(programHash, programOut);
+}
+
+void MemoryProgramCache::remove(const ProgramHash &programHash)
+{
+    bool result = mProgramBinaryCache.eraseByKey(programHash);
+    ASSERT(result);
+}
+
+void MemoryProgramCache::put(const ProgramHash &program, angle::MemoryBuffer &&binaryProgram)
+{
+    if (!mProgramBinaryCache.put(program, std::move(binaryProgram), binaryProgram.size()))
+    {
+        ERR() << "Failed to store binary program in memory cache, program is too large.";
+    }
+}
+
+void MemoryProgramCache::putProgram(const ProgramHash &programHash,
+                                    const Context *context,
+                                    const Program *program)
+{
+    angle::MemoryBuffer binaryProgram;
+    Serialize(context, program, &binaryProgram);
+    put(programHash, std::move(binaryProgram));
+}
+
+void MemoryProgramCache::putBinary(const Context *context,
+                                   const Program *program,
+                                   const uint8_t *binary,
+                                   size_t length)
+{
+    // Copy the binary.
+    angle::MemoryBuffer binaryProgram;
+    binaryProgram.resize(length);
+    memcpy(binaryProgram.data(), binary, length);
+
+    // Compute the hash.
+    ProgramHash programHash;
+    ComputeHash(context, program, &programHash);
+
+    // Store the binary.
+    put(programHash, std::move(binaryProgram));
+}
+
+void MemoryProgramCache::clear()
+{
+    mProgramBinaryCache.clear();
+    mIssuedWarnings = 0;
+}
+
 }  // namespace gl

src/libANGLE/MemoryProgramCache.h

@@ -10,8 +10,36 @@
 #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
+{
+// 128-bit program hash key.
+using ProgramHash = std::array<uint8_t, 20>;
+}  // 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
 {
@@ -23,6 +51,9 @@ 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,
@@ -35,6 +66,40 @@ class MemoryProgramCache final : angle::NonCopyable
                                   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);
+
+    // 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);
+
+    // Helper method that copies a user binary.
+    void putBinary(const Context *context,
+                   const Program *program,
+                   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();
+
+  private:
+    // Insert or update a binary program. Program contents are transferred.
+    void put(const ProgramHash &programHash, angle::MemoryBuffer &&binaryProgram);
+
+    angle::SizedMRUCache<ProgramHash, angle::MemoryBuffer> mProgramBinaryCache;
+    unsigned int mIssuedWarnings;
 };
 
 }  // namespace gl

src/libANGLE/Program.cpp

@@ -616,6 +616,20 @@ Error Program::link(const gl::Context *context)
 
     unlink();
 
+    ProgramHash programHash;
+    auto *cache = context->getMemoryProgramCache();
+    if (cache)
+    {
+        ANGLE_TRY_RESULT(cache->getProgram(context, this, &mState, &programHash), mLinked);
+    }
+
+    if (mLinked)
+    {
+        return NoError();
+    }
+
+    // Cache load failed, fall through to normal linking.
+    unlink();
     mInfoLog.reset();
 
     const Caps &caps = data.getCaps();
@@ -747,6 +761,13 @@ Error Program::link(const gl::Context *context)
 
     gatherInterfaceBlockInfo(context);
 
+    // Save to the program cache.
+    if (cache && (mState.mLinkedTransformFeedbackVaryings.empty() ||
+                  !context->getWorkarounds().disableProgramCachingForTransformFeedback))
+    {
+        cache->putProgram(programHash, context, this);
+    }
+
     return NoError();
 }
 
@@ -797,6 +818,10 @@ Error Program::loadBinary(const Context *context,
     const uint8_t *bytes = reinterpret_cast<const uint8_t *>(binary);
     ANGLE_TRY_RESULT(
         MemoryProgramCache::Deserialize(context, this, &mState, bytes, length, mInfoLog), mLinked);
+
+    // Currently we require the full shader text to compute the program hash.
+    // TODO(jmadill): Store the binary in the internal program cache.
+
     return NoError();
 #endif  // #if ANGLE_PROGRAM_BINARY_LOAD == ANGLE_ENABLED
 }

src/libANGLE/Program.h

@@ -504,6 +504,10 @@ class Program final : angle::NonCopyable, public LabeledObject
         std::unordered_map<std::string, GLuint> mBindings;
     };
 
+    const Bindings &getAttributeBindings() const { return mAttributeBindings; }
+    const Bindings &getUniformLocationBindings() const { return mUniformLocationBindings; }
+    const Bindings &getFragmentInputBindings() const { return mFragmentInputBindings; }
+
   private:
     ~Program();
 
@@ -518,7 +522,6 @@ class Program final : angle::NonCopyable, public LabeledObject
     using MergedVaryings = std::map<std::string, VaryingRef>;
 
     void unlink();
-    void resetUniformBlockBindings();
 
     bool linkAttributes(const Context *context, InfoLog &infoLog);
     bool validateUniformBlocksCount(GLuint maxUniformBlocks,

src/libANGLE/Shader.cpp

@@ -469,4 +469,10 @@ const sh::WorkGroupSize &Shader::getWorkGroupSize(const Context *context)
     return mState.mLocalSize;
 }
 
+const std::string &Shader::getCompilerResourcesString() const
+{
+    ASSERT(mBoundCompiler.get());
+    return mBoundCompiler->getBuiltinResourcesString(mState.mShaderType);
+}
+
 }  // namespace gl

src/libANGLE/Shader.h

@@ -118,6 +118,7 @@ class Shader final : angle::NonCopyable, public LabeledObject
     int getInfoLogLength(const Context *context);
     void getInfoLog(const Context *context, GLsizei bufSize, GLsizei *length, char *infoLog);
     int getSourceLength() const;
+    const std::string &getSourceString() const { return mState.getSource(); }
     void getSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
     int getTranslatedSourceLength(const Context *context);
     int getTranslatedSourceWithDebugInfoLength(const Context *context);
@@ -150,6 +151,8 @@ class Shader final : angle::NonCopyable, public LabeledObject
 
     const sh::WorkGroupSize &getWorkGroupSize(const Context *context);
 
+    const std::string &getCompilerResourcesString() const;
+
   private:
     virtual ~Shader();
     static void GetSourceImpl(const std::string &source,

src/libANGLE/SizedMRUCache.h

@@ -25,9 +25,12 @@ class SizedMRUCache final : angle::NonCopyable
     {
     }
 
-    void put(const Key &key, Value &&value, size_t size)
+    bool put(const Key &key, Value &&value, size_t size)
     {
-        ASSERT(size <= mMaximumTotalSize);
+        if (size > mMaximumTotalSize)
+        {
+            return false;
+        }
 
         // Check for existing key.
         eraseByKey(key);
@@ -42,6 +45,8 @@ class SizedMRUCache final : angle::NonCopyable
             mCurrentSize -= iter->second.size;
             mStore.Erase(iter);
         }
+
+        return true;
     }
 
     bool get(const Key &key, const Value **valueOut)

src/libANGLE/SizedMRUCache_unittest.cpp

@@ -29,11 +29,11 @@ TEST(SizedMRUCacheTest, MaxSizedValue)
     constexpr size_t kSize = 32;
     SizedMRUCache<std::string, Blob> sizedCache(kSize);
 
-    sizedCache.put("test", MakeBlob(kSize), kSize);
+    EXPECT_TRUE(sizedCache.put("test", MakeBlob(kSize), kSize));
     EXPECT_EQ(32u, sizedCache.size());
     EXPECT_FALSE(sizedCache.empty());
 
-    sizedCache.put("test2", MakeBlob(kSize), kSize);
+    EXPECT_TRUE(sizedCache.put("test2", MakeBlob(kSize), kSize));
     EXPECT_EQ(32u, sizedCache.size());
     EXPECT_FALSE(sizedCache.empty());
 
@@ -52,7 +52,7 @@ TEST(SizedMRUCacheTest, ManySmallValues)
 
     for (size_t value = 0; value < kSize; ++value)
     {
-        sizedCache.put(value, std::move(value), 1);
+        EXPECT_TRUE(sizedCache.put(value, std::move(value), 1));
 
         const size_t *qvalue = nullptr;
         EXPECT_TRUE(sizedCache.get(value, &qvalue));
@@ -66,13 +66,13 @@ TEST(SizedMRUCacheTest, ManySmallValues)
     EXPECT_FALSE(sizedCache.empty());
 
     // Putting one element evicts the first element.
-    sizedCache.put(kSize, std::move(static_cast<int>(kSize)), 1);
+    EXPECT_TRUE(sizedCache.put(kSize, std::move(static_cast<int>(kSize)), 1));
 
     const size_t *qvalue = nullptr;
     EXPECT_FALSE(sizedCache.get(0, &qvalue));
 
     // Putting one large element cleans out the whole stack.
-    sizedCache.put(kSize + 1, kSize + 1, kSize);
+    EXPECT_TRUE(sizedCache.put(kSize + 1, kSize + 1, kSize));
     EXPECT_EQ(32u, sizedCache.size());
     EXPECT_FALSE(sizedCache.empty());
 
@@ -89,10 +89,19 @@ TEST(SizedMRUCacheTest, ManySmallValues)
     // Put a bunch of items in the cache sequentially.
     for (size_t value = 0; value < kSize * 10; ++value)
     {
-        sizedCache.put(value, std::move(value), 1);
+        EXPECT_TRUE(sizedCache.put(value, std::move(value), 1));
     }
 
     EXPECT_EQ(32u, sizedCache.size());
 }
 
+// Tests putting an oversize element.
+TEST(SizedMRUCacheTest, OversizeValue)
+{
+    constexpr size_t kSize = 32;
+    SizedMRUCache<size_t, size_t> sizedCache(kSize);
+
+    EXPECT_FALSE(sizedCache.put(5, 5, 100));
+}
+
 }  // namespace angle