Compression of the data from vkGetPipelineCacheData.

src/libANGLE/BlobCache.cpp

@@ -14,6 +14,9 @@
 #include "libANGLE/histogram_macros.h"
 #include "platform/PlatformMethods.h"
 
+#define USE_SYSTEM_ZLIB
+#include "compression_utils_portable.h"
+
 namespace egl
 {
 
@@ -29,6 +32,73 @@ enum CacheResult
 
 }  // anonymous namespace
 
+// In oder to store more cache in blob cache, compress cacheData to compressedData
+// before being stored.
+bool CompressBlobCacheData(angle::MemoryBuffer *cacheData, angle::MemoryBuffer *compressedData)
+{
+    uLong uncompressedSize       = static_cast<uLong>(cacheData->size());
+    uLong expectedCompressedSize = zlib_internal::GzipExpectedCompressedSize(uncompressedSize);
+
+    // Allocate memory.
+    if (!compressedData->resize(expectedCompressedSize))
+    {
+        ERR() << "Failed to allocate memory for compression";
+        return false;
+    }
+
+    int zResult =
+        zlib_internal::GzipCompressHelper(compressedData->data(), &expectedCompressedSize,
+                                          cacheData->data(), uncompressedSize, nullptr, nullptr);
+
+    if (zResult != Z_OK)
+    {
+        ERR() << "Failed to compress cache data: " << zResult;
+        return false;
+    }
+
+    // Resize it to expected size.
+    if (!compressedData->resize(expectedCompressedSize))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool DecompressBlobCacheData(const uint8_t *compressedData,
+                             const size_t compressedSize,
+                             angle::MemoryBuffer *uncompressedData)
+{
+    // Call zlib function to decompress.
+    uint32_t uncompressedSize =
+        zlib_internal::GetGzipUncompressedSize(compressedData, compressedSize);
+
+    // Allocate enough memory.
+    if (!uncompressedData->resize(uncompressedSize))
+    {
+        ERR() << "Failed to allocate memory for decompression";
+        return false;
+    }
+
+    uLong destLen = uncompressedSize;
+    int zResult   = zlib_internal::GzipUncompressHelper(
+        uncompressedData->data(), &destLen, compressedData, static_cast<uLong>(compressedSize));
+
+    if (zResult != Z_OK)
+    {
+        ERR() << "Failed to decompress data: " << zResult << "\n";
+        return false;
+    }
+
+    // Resize it to expected size.
+    if (!uncompressedData->resize(destLen))
+    {
+        return false;
+    }
+
+    return true;
+}
+
 BlobCache::BlobCache(size_t maxCacheSizeBytes)
     : mBlobCache(maxCacheSizeBytes), mSetBlobFunc(nullptr), mGetBlobFunc(nullptr)
 {}

src/libANGLE/BlobCache.h

@@ -48,6 +48,11 @@ struct hash<egl::BlobCacheKey>
 namespace egl
 {
 
+bool CompressBlobCacheData(angle::MemoryBuffer *cacheData, angle::MemoryBuffer *compressedData);
+bool DecompressBlobCacheData(const uint8_t *compressedData,
+                             const size_t compressedSize,
+                             angle::MemoryBuffer *uncompressedData);
+
 class BlobCache final : angle::NonCopyable
 {
   public:

src/libANGLE/MemoryProgramCache.cpp

@@ -21,9 +21,6 @@
 #include "libANGLE/renderer/ProgramImpl.h"
 #include "platform/PlatformMethods.h"
 
-#define USE_SYSTEM_ZLIB
-#include "compression_utils_portable.h"
-
 namespace gl
 {
 
@@ -146,18 +143,10 @@ angle::Result MemoryProgramCache::getProgram(const Context *context,
     size_t programSize = 0;
     if (get(context, *hashOut, &binaryProgram, &programSize))
     {
-        uint32_t uncompressedSize =
-            zlib_internal::GetGzipUncompressedSize(binaryProgram.data(), programSize);
-
-        std::vector<uint8_t> uncompressedData(uncompressedSize);
-        uLong destLen = uncompressedSize;
-        int zResult   = zlib_internal::GzipUncompressHelper(uncompressedData.data(), &destLen,
-                                                          binaryProgram.data(),
-                                                          static_cast<uLong>(programSize));
-
-        if (zResult != Z_OK)
+        angle::MemoryBuffer uncompressedData;
+        if (!egl::DecompressBlobCacheData(binaryProgram.data(), programSize, &uncompressedData))
         {
-            ERR() << "Failure to decompressed binary data: " << zResult << "\n";
+            ERR() << "Error decompressing binary data.";
             return angle::Result::Incomplete;
         }
 
@@ -220,33 +209,10 @@ angle::Result MemoryProgramCache::putProgram(const egl::BlobCache::Key &programH
     angle::MemoryBuffer serializedProgram;
     ANGLE_TRY(program->serialize(context, &serializedProgram));
 
-    // Compress the program data
-    uLong uncompressedSize       = static_cast<uLong>(serializedProgram.size());
-    uLong expectedCompressedSize = zlib_internal::GzipExpectedCompressedSize(uncompressedSize);
-
     angle::MemoryBuffer compressedData;
-    if (!compressedData.resize(expectedCompressedSize))
-    {
-        ERR() << "Failed to allocate enough memory to hold compressed program. ("
-              << expectedCompressedSize << " bytes )";
-        return angle::Result::Incomplete;
-    }
-
-    int zResult = zlib_internal::GzipCompressHelper(compressedData.data(), &expectedCompressedSize,
-                                                    serializedProgram.data(), uncompressedSize,
-                                                    nullptr, nullptr);
-
-    if (zResult != Z_OK)
-    {
-        FATAL() << "Error compressing binary data: " << zResult;
-        return angle::Result::Incomplete;
-    }
-
-    // Resize the buffer to the actual compressed size
-    if (!compressedData.resize(expectedCompressedSize))
+    if (!egl::CompressBlobCacheData(&serializedProgram, &compressedData))
     {
-        ERR() << "Failed to resize to actual compressed program size. (" << expectedCompressedSize
-              << " bytes )";
+        ERR() << "Error compressing binary data.";
         return angle::Result::Incomplete;
     }
 

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -165,7 +165,7 @@ class RendererVk : angle::NonCopyable
     const vk::Format &getFormat(angle::FormatID formatID) const { return mFormatTable[formatID]; }
 
     angle::Result getPipelineCacheSize(DisplayVk *displayVk, size_t *pipelineCacheSizeOut);
-    angle::Result syncPipelineCacheVk(DisplayVk *displayVk);
+    angle::Result syncPipelineCacheVk(DisplayVk *displayVk, ContextVk *contextVk);
 
     // Issues a new serial for linked shader modules. Used in the pipeline cache.
     Serial issueShaderSerial();
@@ -376,7 +376,6 @@ class RendererVk : angle::NonCopyable
     void queryDeviceExtensionFeatures(const vk::ExtensionNameList &deviceExtensionNames);
 
     void initFeatures(DisplayVk *display, const vk::ExtensionNameList &extensions);
-    void initPipelineCacheVkKey();
     angle::Result initPipelineCache(DisplayVk *display,
                                     vk::PipelineCache *pipelineCache,
                                     bool *success);
@@ -447,7 +446,6 @@ class RendererVk : angle::NonCopyable
     // a lock.
     std::mutex mPipelineCacheMutex;
     vk::PipelineCache mPipelineCache;
-    egl::BlobCache::Key mPipelineCacheVkBlobKey;
     uint32_t mPipelineCacheVkUpdateTimeout;
     bool mPipelineCacheDirty;
     bool mPipelineCacheInitialized;

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -1543,7 +1543,7 @@ angle::Result WindowSurfaceVk::doDeferredAcquireNextImage(const gl::Context *con
     }
 
     RendererVk *renderer = contextVk->getRenderer();
-    ANGLE_TRY(renderer->syncPipelineCacheVk(displayVk));
+    ANGLE_TRY(renderer->syncPipelineCacheVk(displayVk, contextVk));
 
     return angle::Result::Continue;
 }