[Impeller] Retry uncompressed when fixed-rate compression is exhausted (flutter#187586)

Fixes flutter#187564

## Issue

On the Pixel 10 (Tensor G5 / **Imagination PowerVR** GPU), Impeller's
Vulkan backend
crashes the raster thread under GPU pressure:

```
[ERROR:impeller/renderer/backend/vulkan/allocator_vk.cc] Unable to allocate Vulkan Image:
  ErrorCompressionExhaustedEXT Type: Texture2D ... Usage: { ShaderRead, RenderTarget }
[ERROR:impeller/renderer/render_target.cc] Could not create color texture.
[ERROR:impeller/renderer/render_target.cc] Render target does not have color attachment at index 0.
F/libc: Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x0 in tid NNNN (1.raster)
```

(In release builds the same failure surfaces as
`[FATAL:flutter/impeller/display_list/canvas.cc(1471)] Check failed:
back_texture. Context is valid:0`
SIGABRT, or a bare SIGSEGV @ 0x20 on the `*.raster` thread.)

### Root cause

Impeller requests **fixed-rate image compression**
(`VkImageCompressionControlEXT`) for
lossy render targets (`CreateOffscreenMSAA`'s color-resolve texture).
When the PowerVR
driver's fixed-rate-compression resources are exhausted,
`vmaCreateImage` returns
`VK_ERROR_COMPRESSION_EXHAUSTED_EXT`. `AllocatedTextureSourceVK` did not
handle this — it
logged and returned an invalid texture, which became a render target
with no color
attachment, and the raster thread then dereferenced the null texture.

This is a regression: it does **not** reproduce on Flutter 3.41.9, but
does on 3.44.x.
It is PowerVR-specific (the error is tied to the driver's compression
resource pool) and
GPU-state-dependent (it fires once cumulative GPU compression pressure
is high enough).

## Fix

`VK_ERROR_COMPRESSION_EXHAUSTED_EXT` is, per the Vulkan spec, only
returned for fixed-rate
compression requests — so retrying the same allocation **without**
compression is always a
valid recovery. On that error, `AllocatedTextureSourceVK` now unlinks
`VkImageCompressionControlEXT` from the create-info chain and retries
`vmaCreateImage` once
uncompressed (logging a one-time warning). The texture is identical,
just stored
uncompressed; the only cost is on the failure path (a small amount of
extra
memory/bandwidth for the affected texture, instead of a crash).

## Tests

- **Unit test** (`allocator_vk_unittests.cc` →
`RetriesUncompressedOnCompressionExhausted`):
extends the Vulkan mock to advertise fixed-rate compression and to fail
the first
compressed `vkCreateImage` with `VK_ERROR_COMPRESSION_EXHAUSTED_EXT`,
then asserts the
allocator returns a **valid** texture and called `vkCreateImage`
**twice** (compressed
attempt + uncompressed retry). Passes; the other allocator tests are
unaffected.

- **On-device A/B** (Pixel 10, locally-built `android_profile_arm64`,
same repro, same
  GPU-pressured state):

  | Engine | Result |
  |---|---|
| Unpatched | `ErrorCompressionExhausted` → **SIGSEGV** on `1.raster`
(crash) |
| Patched | exhaustion → retry → **survives**; logs `Fixed-rate image
compression exhausted; falling back to uncompressed image allocation` |

## Repro

A pure-Flutter app that stacks enough full-screen `BackdropFilter` /
`saveLayer` offscreen
render targets to exhaust the PowerVR compression pool (see
`lib/main.dart` in the linked
repro). Crashes on the unpatched engine; runs on the patched one. Stable
on either with
`--no-enable-impeller`.

## Environment

- Flutter 3.44.x (regressed from 3.41.9)
- Device: Pixel 10, Android 17 (API 37)
- GPU: Imagination PowerVR (Tensor G5); renderer Impeller / Vulkan

## Pre-launch checklist
- [x] Added a unit test (or explained why not possible).
- [x] Listed any breaking changes (none).
- [x] Signed the [CLA](https://cla.developers.google.com/).

---------

Co-authored-by: John "codefu" McDole <codefu@google.com>

Author: 2 people

engine/src/flutter/impeller/renderer/backend/vulkan/allocator_vk.cc

@@ -5,8 +5,10 @@
 #include "impeller/renderer/backend/vulkan/allocator_vk.h"
 
 #include <memory>
+#include <mutex>
 #include <utility>
 
+#include "flutter/fml/logging.h"
 #include "flutter/fml/memory/ref_ptr.h"
 #include "flutter/fml/trace_event.h"
 #include "impeller/base/allocation_size.h"
@@ -343,34 +345,63 @@ class AllocatedTextureSourceVK final : public TextureSourceVK {
             desc.storage_mode, supports_memoryless_textures));
     alloc_nfo.flags = ToVmaAllocationCreateFlags(desc.storage_mode);
 
-    auto create_info_native =
-        static_cast<vk::ImageCreateInfo::NativeType>(image_info);
-
     VkImage vk_image = VK_NULL_HANDLE;
     VmaAllocation allocation = {};
     VmaAllocationInfo allocation_info = {};
-    {
-      auto result = vk::Result{::vmaCreateImage(allocator,            //
-                                                &create_info_native,  //
-                                                &alloc_nfo,           //
-                                                &vk_image,            //
-                                                &allocation,          //
-                                                &allocation_info      //
-                                                )};
-      if (result != vk::Result::eSuccess) {
-        VALIDATION_LOG << "Unable to allocate Vulkan Image: "
-                       << vk::to_string(result)
-                       << " Type: " << TextureTypeToString(desc.type)
-                       << " Mode: " << StorageModeToString(desc.storage_mode)
-                       << " Usage: " << TextureUsageMaskToString(desc.usage)
-                       << " [VK]Flags: " << vk::to_string(image_info.flags)
-                       << " [VK]Format: " << vk::to_string(image_info.format)
-                       << " [VK]Usage: " << vk::to_string(image_info.usage)
-                       << " [VK]Mem. Flags: "
-                       << vk::to_string(vk::MemoryPropertyFlags(
-                              alloc_nfo.preferredFlags));
-        return;
-      }
+
+    // Performs the VMA image allocation using the current create-info chain.
+    // The native create-info is re-derived from the chain on each call, so an
+    // unlink of the compression-control struct between calls is reflected.
+    const auto try_create_image = [&]() -> vk::Result {
+      vk::ImageCreateInfo::NativeType create_info_native =
+          static_cast<vk::ImageCreateInfo::NativeType>(
+              image_info_chain.get<vk::ImageCreateInfo>());
+      return vk::Result{::vmaCreateImage(allocator,            //
+                                         &create_info_native,  //
+                                         &alloc_nfo,           //
+                                         &vk_image,            //
+                                         &allocation,          //
+                                         &allocation_info      //
+                                         )};
+    };
+
+    // Fixed-rate compression was requested iff a rate was selected above.
+    const bool requested_compression = frc_rate.has_value();
+    vk::Result alloc_result = try_create_image();
+
+    // Some drivers (e.g. PowerVR) can return VK_ERROR_COMPRESSION_EXHAUSTED_EXT
+    // when fixed-rate compression resources are depleted. Per the Vulkan spec
+    // this error is only returned for fixed-rate compression requests, so
+    // retrying without compression is a valid recovery. Without it the
+    // allocation fails, the texture is invalid, and the resulting null render
+    // target crashes the raster thread.
+    if (alloc_result == vk::Result::eErrorCompressionExhaustedEXT &&
+        requested_compression) {
+      static std::once_flag warn_once;
+      std::call_once(warn_once, [] {
+        FML_LOG(WARNING)
+            << "Fixed-rate image compression exhausted; falling back to "
+               "uncompressed image allocation. (This message is logged once.)";
+      });
+      // The compression-control struct is only present here because compression
+      // was requested above, so unlinking it once is safe (no double-unlink).
+      image_info_chain.unlink<vk::ImageCompressionControlEXT>();
+      alloc_result = try_create_image();
+    }
+
+    if (alloc_result != vk::Result::eSuccess) {
+      VALIDATION_LOG << "Unable to allocate Vulkan Image: "
+                     << vk::to_string(alloc_result)
+                     << " Type: " << TextureTypeToString(desc.type)
+                     << " Mode: " << StorageModeToString(desc.storage_mode)
+                     << " Usage: " << TextureUsageMaskToString(desc.usage)
+                     << " [VK]Flags: " << vk::to_string(image_info.flags)
+                     << " [VK]Format: " << vk::to_string(image_info.format)
+                     << " [VK]Usage: " << vk::to_string(image_info.usage)
+                     << " [VK]Mem. Flags: "
+                     << vk::to_string(
+                            vk::MemoryPropertyFlags(alloc_nfo.preferredFlags));
+      return;
     }
 
     auto image = vk::Image{vk_image};

engine/src/flutter/impeller/renderer/backend/vulkan/allocator_vk_unittests.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <algorithm>
+
 #include "flutter/testing/testing.h"  // IWYU pragma: keep
 #include "gtest/gtest.h"
 #include "impeller/base/allocation_size.h"
@@ -93,6 +95,41 @@ TEST(AllocatorVKTest, ImageResourceKeepsVulkanDeviceAlive) {
   ASSERT_TRUE(weak_allocator.lock());
 }
 
+TEST(AllocatorVKTest, RetriesUncompressedOnCompressionExhausted) {
+  // Advertise fixed-rate compression support, then force the first (compressed)
+  // vkCreateImage to fail with VK_ERROR_COMPRESSION_EXHAUSTED_EXT, as the
+  // PowerVR driver does when its fixed-rate-compression resources are depleted.
+  auto const context =
+      MockVulkanContextBuilder()
+          .SetDeviceExtensions(
+              {"VK_KHR_swapchain", "VK_EXT_image_compression_control"})
+          .SetCompressionExhaustedCreateImageFailures(1)
+          .Build();
+  ASSERT_TRUE(context);
+  auto allocator = context->GetResourceAllocator();
+  ASSERT_TRUE(allocator);
+
+  // A lossy (fixed-rate-compressed) render target. The first compressed
+  // allocation fails with COMPRESSION_EXHAUSTED; the allocator must retry
+  // without compression and still produce a valid texture instead of returning
+  // null (a null render target previously crashed the raster thread).
+  auto texture = allocator->CreateTexture(TextureDescriptor{
+      .storage_mode = StorageMode::kDevicePrivate,
+      .format = PixelFormat::kR8G8B8A8UNormInt,
+      .size = {64, 64},
+      .usage = TextureUsage::kRenderTarget | TextureUsage::kShaderRead,
+      .compression_type = CompressionType::kLossy,
+  });
+
+  ASSERT_TRUE(texture);
+  EXPECT_TRUE(texture->IsValid());
+
+  // vkCreateImage was called twice: the compressed attempt (which failed with
+  // COMPRESSION_EXHAUSTED) and the uncompressed retry (which succeeded).
+  auto const called = GetMockVulkanFunctions(context->GetDevice());
+  EXPECT_EQ(std::count(called->begin(), called->end(), "vkCreateImage"), 2);
+}
+
 #ifdef IMPELLER_DEBUG
 
 TEST(AllocatorVKTest, RecreateSwapchainWhenSizeChanges) {

engine/src/flutter/impeller/renderer/backend/vulkan/test/mock_vulkan.cc

@@ -122,6 +122,9 @@ struct MockVulkanState {
       wait_for_fences_callback;
   std::function<std::remove_pointer_t<PFN_vkAcquireNextImageKHR>>
       acquire_next_image_callback;
+  // When > 0, the next vkCreateImage for a fixed-rate-compressed image returns
+  // VK_ERROR_COMPRESSION_EXHAUSTED_EXT and decrements (models PowerVR).
+  int compression_exhausted_create_image_failures = 0;
 };
 
 class MockVulkanStatePtr {
@@ -242,6 +245,52 @@ void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
   }
 }
 
+void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+                                  VkPhysicalDeviceFeatures2* pFeatures) {
+  // Advertise the features the mock supports by walking the pNext chain.
+  auto* next = reinterpret_cast<VkBaseOutStructure*>(pFeatures->pNext);
+  while (next != nullptr) {
+    if (next->sType ==
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT) {
+      reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+          next)
+          ->imageCompressionControl = VK_TRUE;
+    }
+    next = next->pNext;
+  }
+}
+
+VkResult vkGetPhysicalDeviceImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties) {
+  // Report fixed-rate compression support when it is queried (i.e. the input
+  // carries a VkImageCompressionControlEXT and the output a
+  // VkImageCompressionPropertiesEXT).
+  bool compression_requested = false;
+  const auto* in =
+      reinterpret_cast<const VkBaseInStructure*>(pImageFormatInfo->pNext);
+  while (in != nullptr) {
+    if (in->sType == VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT) {
+      compression_requested = true;
+    }
+    in = in->pNext;
+  }
+  auto* out =
+      reinterpret_cast<VkBaseOutStructure*>(pImageFormatProperties->pNext);
+  while (compression_requested && out != nullptr) {
+    if (out->sType == VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT) {
+      auto* props = reinterpret_cast<VkImageCompressionPropertiesEXT*>(out);
+      props->imageCompressionFlags =
+          VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT;
+      props->imageCompressionFixedRateFlags =
+          VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT;
+    }
+    out = out->pNext;
+  }
+  return VK_SUCCESS;
+}
+
 void vkGetPhysicalDeviceQueueFamilyProperties(
     VkPhysicalDevice physicalDevice,
     uint32_t* pQueueFamilyPropertyCount,
@@ -368,6 +417,21 @@ VkResult vkCreateImage(VkDevice device,
                        const VkImageCreateInfo* pCreateInfo,
                        const VkAllocationCallbacks* pAllocator,
                        VkImage* pImage) {
+  reinterpret_cast<MockDevice*>(device)->AddCalledFunction("vkCreateImage");
+  // Simulate VK_ERROR_COMPRESSION_EXHAUSTED_EXT for fixed-rate-compressed image
+  // creates (the spec only returns this error for compression requests).
+  if (g_mock_vulkan_state &&
+      g_mock_vulkan_state->compression_exhausted_create_image_failures > 0) {
+    const auto* next =
+        reinterpret_cast<const VkBaseInStructure*>(pCreateInfo->pNext);
+    while (next != nullptr) {
+      if (next->sType == VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT) {
+        g_mock_vulkan_state->compression_exhausted_create_image_failures--;
+        return VK_ERROR_COMPRESSION_EXHAUSTED_EXT;
+      }
+      next = next->pNext;
+    }
+  }
   *pImage = reinterpret_cast<VkImage>(0xD0D0CACA);
   return VK_SUCCESS;
 }
@@ -907,6 +971,14 @@ PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance,
         vkGetPhysicalDeviceFormatProperties);
   } else if (strcmp("vkGetPhysicalDeviceProperties", pName) == 0) {
     return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceProperties);
+  } else if (strcmp("vkGetPhysicalDeviceFeatures2", pName) == 0 ||
+             strcmp("vkGetPhysicalDeviceFeatures2KHR", pName) == 0) {
+    return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceFeatures2);
+  } else if (strcmp("vkGetPhysicalDeviceImageFormatProperties2", pName) == 0 ||
+             strcmp("vkGetPhysicalDeviceImageFormatProperties2KHR", pName) ==
+                 0) {
+    return reinterpret_cast<PFN_vkVoidFunction>(
+        vkGetPhysicalDeviceImageFormatProperties2);
   } else if (strcmp("vkGetPhysicalDeviceQueueFamilyProperties", pName) == 0) {
     return reinterpret_cast<PFN_vkVoidFunction>(
         vkGetPhysicalDeviceQueueFamilyProperties);
@@ -1097,6 +1169,8 @@ std::shared_ptr<ContextVK> MockVulkanContextBuilder::Build() {
   g_mock_vulkan_state->acquire_next_image_callback =
       acquire_next_image_callback_;
   g_mock_vulkan_state->wait_for_fences_callback = wait_for_fences_callback_;
+  g_mock_vulkan_state->compression_exhausted_create_image_failures =
+      compression_exhausted_create_image_failures_;
   settings.embedder_data = embedder_data_;
   std::shared_ptr<ContextVK> result = ContextVK::Create(std::move(settings));
   return result;

engine/src/flutter/impeller/renderer/backend/vulkan/test/mock_vulkan.h

@@ -134,6 +134,17 @@ class MockVulkanContextBuilder {
     return *this;
   }
 
+  /// Make the next `count` calls to vkCreateImage for a fixed-rate-compressed
+  /// image (one carrying a VkImageCompressionControlEXT in its pNext chain)
+  /// fail with VK_ERROR_COMPRESSION_EXHAUSTED_EXT. Also advertises the
+  /// VK_EXT_image_compression_control feature/format support so the
+  /// fixed-rate-compression path is exercised.
+  MockVulkanContextBuilder& SetCompressionExhaustedCreateImageFailures(
+      int count) {
+    compression_exhausted_create_image_failures_ = count;
+    return *this;
+  }
+
  private:
   std::function<void(ContextVK::Settings&)> settings_callback_;
   std::vector<std::string> instance_extensions_;
@@ -151,6 +162,7 @@ class MockVulkanContextBuilder {
       acquire_next_image_callback_;
   std::function<std::remove_pointer_t<PFN_vkWaitForFences>>
       wait_for_fences_callback_;
+  int compression_exhausted_create_image_failures_ = 0;
 };
 
 /// @brief Override the image size returned by all swapchain images.