[Impeller] Report pipeline creation feedback to logs and traces. (#43227)

Piping the feedback to logs is disabled by default but can be enabled by patching the source for now. If reading from logs gets to be useful, we can move it behind a flag. In traces, enabled by default, pipeline cache hits and misses will be shown via counters. The time taken to create a pipeline variant is already covered by existing traces.

This patch also sets up infrastructure in the impeller::CapabilitiesVK to quickly enable optional device extensions.

Pipeline feedback will only be reported if the device supports `VK_EXT_pipeline_creation_feedback`.

Example of logs:

```
E/flutter ( 2011): >>>>>>
E/flutter ( 2011): Pipeline 'GaussianBlurAlphaDecal Pipeline' Time: 48.60ms Cache Hit: 0 Base Accel: 0 Thread: 481449901232
E/flutter ( 2011):  Stage 1: Time: 12.91ms Cache Hit: 0 Base Accel: 0 Thread: 481449901232
E/flutter ( 2011):  Stage 2: Time: 15.10ms Cache Hit: 0 Base Accel: 0 Thread: 481449901232
E/flutter ( 2011): <<<<<<
```

Author: chinmaygarde

impeller/base/timing.h

@@ -8,6 +8,7 @@
 
 namespace impeller {
 
+using MillisecondsF = std::chrono::duration<float, std::milli>;
 using SecondsF = std::chrono::duration<float>;
 using Clock = std::chrono::high_resolution_clock;
 using TimePoint = std::chrono::time_point<std::chrono::high_resolution_clock>;

impeller/renderer/backend/vulkan/capabilities_vk.cc

@@ -54,7 +54,7 @@ bool CapabilitiesVK::AreValidationsEnabled() const {
   return enable_validations_;
 }
 
-std::optional<std::vector<std::string>> CapabilitiesVK::GetRequiredLayers()
+std::optional<std::vector<std::string>> CapabilitiesVK::GetEnabledLayers()
     const {
   std::vector<std::string> required;
 
@@ -71,7 +71,7 @@ std::optional<std::vector<std::string>> CapabilitiesVK::GetRequiredLayers()
 }
 
 std::optional<std::vector<std::string>>
-CapabilitiesVK::GetRequiredInstanceExtensions() const {
+CapabilitiesVK::GetEnabledInstanceExtensions() const {
   std::vector<std::string> required;
 
   if (!HasExtension("VK_KHR_surface")) {
@@ -150,9 +150,29 @@ CapabilitiesVK::GetRequiredInstanceExtensions() const {
   return required;
 }
 
-std::optional<std::vector<std::string>>
-CapabilitiesVK::GetRequiredDeviceExtensions(
-    const vk::PhysicalDevice& physical_device) const {
+static const char* GetDeviceExtensionName(OptionalDeviceExtensionVK ext) {
+  switch (ext) {
+    case OptionalDeviceExtensionVK::kEXTPipelineCreationFeedback:
+      return VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME;
+    case OptionalDeviceExtensionVK::kLast:
+      return "Unknown";
+  }
+  return "Unknown";
+}
+
+static void IterateOptionalDeviceExtensions(
+    const std::function<void(OptionalDeviceExtensionVK)>& it) {
+  if (!it) {
+    return;
+  }
+  for (size_t i = 0;
+       i < static_cast<uint32_t>(OptionalDeviceExtensionVK::kLast); i++) {
+    it(static_cast<OptionalDeviceExtensionVK>(i));
+  }
+}
+
+static std::optional<std::set<std::string>> GetSupportedDeviceExtensions(
+    const vk::PhysicalDevice& physical_device) {
   auto device_extensions = physical_device.enumerateDeviceExtensionProperties();
   if (device_extensions.result != vk::Result::eSuccess) {
     return std::nullopt;
@@ -161,21 +181,42 @@ CapabilitiesVK::GetRequiredDeviceExtensions(
   std::set<std::string> exts;
   for (const auto& device_extension : device_extensions.value) {
     exts.insert(device_extension.extensionName);
+  };
+
+  return exts;
+}
+
+std::optional<std::vector<std::string>>
+CapabilitiesVK::GetEnabledDeviceExtensions(
+    const vk::PhysicalDevice& physical_device) const {
+  auto exts = GetSupportedDeviceExtensions(physical_device);
+
+  if (!exts.has_value()) {
+    return std::nullopt;
   }
 
-  std::vector<std::string> required;
+  std::vector<std::string> enabled;
 
-  if (exts.find("VK_KHR_swapchain") == exts.end()) {
+  if (exts->find("VK_KHR_swapchain") == exts->end()) {
     VALIDATION_LOG << "Device does not support the swapchain extension.";
     return std::nullopt;
   }
-  required.push_back("VK_KHR_swapchain");
+  enabled.push_back("VK_KHR_swapchain");
 
   // Required for non-conformant implementations like MoltenVK.
-  if (exts.find("VK_KHR_portability_subset") != exts.end()) {
-    required.push_back("VK_KHR_portability_subset");
+  if (exts->find("VK_KHR_portability_subset") != exts->end()) {
+    enabled.push_back("VK_KHR_portability_subset");
   }
-  return required;
+
+  // Enable all optional extensions if the device supports it.
+  IterateOptionalDeviceExtensions([&](auto ext) {
+    auto ext_name = GetDeviceExtensionName(ext);
+    if (exts->find(ext_name) != exts->end()) {
+      enabled.push_back(ext_name);
+    }
+  });
+
+  return enabled;
 }
 
 static bool HasSuitableColorFormat(const vk::PhysicalDevice& device,
@@ -227,7 +268,7 @@ static bool HasRequiredQueues(const vk::PhysicalDevice& physical_device) {
 }
 
 std::optional<vk::PhysicalDeviceFeatures>
-CapabilitiesVK::GetRequiredDeviceFeatures(
+CapabilitiesVK::GetEnabledDeviceFeatures(
     const vk::PhysicalDevice& device) const {
   if (!PhysicalDeviceSupportsRequiredFormats(device)) {
     VALIDATION_LOG << "Device doesn't support the required formats.";
@@ -244,7 +285,7 @@ CapabilitiesVK::GetRequiredDeviceFeatures(
     return std::nullopt;
   }
 
-  if (!GetRequiredDeviceExtensions(device).has_value()) {
+  if (!GetEnabledDeviceExtensions(device).has_value()) {
     VALIDATION_LOG << "Device doesn't support the required queues.";
     return std::nullopt;
   }
@@ -282,7 +323,7 @@ void CapabilitiesVK::SetOffscreenFormat(PixelFormat pixel_format) const {
   color_format_ = pixel_format;
 }
 
-bool CapabilitiesVK::SetDevice(const vk::PhysicalDevice& device) {
+bool CapabilitiesVK::SetPhysicalDevice(const vk::PhysicalDevice& device) {
   if (HasSuitableDepthStencilFormat(device, vk::Format::eS8Uint)) {
     depth_stencil_format_ = PixelFormat::kS8UInt;
   } else if (HasSuitableDepthStencilFormat(device,
@@ -307,6 +348,21 @@ bool CapabilitiesVK::SetDevice(const vk::PhysicalDevice& device) {
              .supportedOperations &
          vk::SubgroupFeatureFlagBits::eArithmetic);
 
+  // Determine the optional device extensions this physical device supports.
+  {
+    optional_device_extensions_.clear();
+    auto exts = GetSupportedDeviceExtensions(device);
+    if (!exts.has_value()) {
+      return false;
+    }
+    IterateOptionalDeviceExtensions([&](auto ext) {
+      auto ext_name = GetDeviceExtensionName(ext);
+      if (exts->find(ext_name) != exts->end()) {
+        optional_device_extensions_.insert(ext);
+      }
+    });
+  }
+
   return true;
 }
 
@@ -348,7 +404,7 @@ bool CapabilitiesVK::SupportsCompute() const {
 
 // |Capabilities|
 bool CapabilitiesVK::SupportsComputeSubgroups() const {
-  // Set by |SetDevice|.
+  // Set by |SetPhysicalDevice|.
   return supports_compute_subgroups_;
 }
 
@@ -381,4 +437,10 @@ CapabilitiesVK::GetPhysicalDeviceProperties() const {
   return device_properties_;
 }
 
+bool CapabilitiesVK::HasOptionalDeviceExtension(
+    OptionalDeviceExtensionVK extension) const {
+  return optional_device_extensions_.find(extension) !=
+         optional_device_extensions_.end();
+}
+
 }  // namespace impeller

impeller/renderer/backend/vulkan/capabilities_vk.h

@@ -18,6 +18,12 @@ namespace impeller {
 
 class ContextVK;
 
+enum class OptionalDeviceExtensionVK : uint32_t {
+  // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_pipeline_creation_feedback.html
+  kEXTPipelineCreationFeedback,
+  kLast,
+};
+
 //------------------------------------------------------------------------------
 /// @brief      The Vulkan layers and extensions wrangler.
 ///
@@ -32,17 +38,20 @@ class CapabilitiesVK final : public Capabilities,
 
   bool AreValidationsEnabled() const;
 
-  std::optional<std::vector<std::string>> GetRequiredLayers() const;
+  bool HasOptionalDeviceExtension(OptionalDeviceExtensionVK extension) const;
+
+  std::optional<std::vector<std::string>> GetEnabledLayers() const;
 
-  std::optional<std::vector<std::string>> GetRequiredInstanceExtensions() const;
+  std::optional<std::vector<std::string>> GetEnabledInstanceExtensions() const;
 
-  std::optional<std::vector<std::string>> GetRequiredDeviceExtensions(
+  std::optional<std::vector<std::string>> GetEnabledDeviceExtensions(
       const vk::PhysicalDevice& physical_device) const;
 
-  std::optional<vk::PhysicalDeviceFeatures> GetRequiredDeviceFeatures(
+  std::optional<vk::PhysicalDeviceFeatures> GetEnabledDeviceFeatures(
       const vk::PhysicalDevice& physical_device) const;
 
-  [[nodiscard]] bool SetDevice(const vk::PhysicalDevice& physical_device);
+  [[nodiscard]] bool SetPhysicalDevice(
+      const vk::PhysicalDevice& physical_device);
 
   const vk::PhysicalDeviceProperties& GetPhysicalDeviceProperties() const;
 
@@ -90,6 +99,7 @@ class CapabilitiesVK final : public Capabilities,
  private:
   const bool enable_validations_;
   std::map<std::string, std::set<std::string>> exts_;
+  std::set<OptionalDeviceExtensionVK> optional_device_extensions_;
   mutable PixelFormat color_format_ = PixelFormat::kUnknown;
   PixelFormat depth_stencil_format_ = PixelFormat::kUnknown;
   vk::PhysicalDeviceProperties device_properties_;

impeller/renderer/backend/vulkan/context_vk.cc

@@ -48,7 +48,7 @@ static std::optional<vk::PhysicalDevice> PickPhysicalDevice(
     const CapabilitiesVK& caps,
     const vk::Instance& instance) {
   for (const auto& device : instance.enumeratePhysicalDevices().value) {
-    if (caps.GetRequiredDeviceFeatures(device).has_value()) {
+    if (caps.GetEnabledDeviceFeatures(device).has_value()) {
       return device;
     }
   }
@@ -149,8 +149,8 @@ void ContextVK::Setup(Settings settings) {
 
   gHasValidationLayers = caps->AreValidationsEnabled();
 
-  auto enabled_layers = caps->GetRequiredLayers();
-  auto enabled_extensions = caps->GetRequiredInstanceExtensions();
+  auto enabled_layers = caps->GetEnabledLayers();
+  auto enabled_extensions = caps->GetEnabledInstanceExtensions();
 
   if (!enabled_layers.has_value() || !enabled_extensions.has_value()) {
     VALIDATION_LOG << "Device has insufficient capabilities.";
@@ -277,7 +277,7 @@ void ContextVK::Setup(Settings settings) {
   /// Create the logical device.
   ///
   auto enabled_device_extensions =
-      caps->GetRequiredDeviceExtensions(device_holder->physical_device);
+      caps->GetEnabledDeviceExtensions(device_holder->physical_device);
   if (!enabled_device_extensions.has_value()) {
     // This shouldn't happen since we already did device selection. But doesn't
     // hurt to check again.
@@ -292,9 +292,9 @@ void ContextVK::Setup(Settings settings) {
   const auto queue_create_infos = GetQueueCreateInfos(
       {graphics_queue.value(), compute_queue.value(), transfer_queue.value()});
 
-  const auto required_features =
-      caps->GetRequiredDeviceFeatures(device_holder->physical_device);
-  if (!required_features.has_value()) {
+  const auto enabled_features =
+      caps->GetEnabledDeviceFeatures(device_holder->physical_device);
+  if (!enabled_features.has_value()) {
     // This shouldn't happen since the device can't be picked if this was not
     // true. But doesn't hurt to check.
     return;
@@ -304,7 +304,7 @@ void ContextVK::Setup(Settings settings) {
 
   device_info.setQueueCreateInfos(queue_create_infos);
   device_info.setPEnabledExtensionNames(enabled_device_extensions_c);
-  device_info.setPEnabledFeatures(&required_features.value());
+  device_info.setPEnabledFeatures(&enabled_features.value());
   // Device layers are deprecated and ignored.
 
   {
@@ -317,7 +317,7 @@ void ContextVK::Setup(Settings settings) {
     device_holder->device = std::move(device_result.value);
   }
 
-  if (!caps->SetDevice(device_holder->physical_device)) {
+  if (!caps->SetPhysicalDevice(device_holder->physical_device)) {
     VALIDATION_LOG << "Capabilities could not be updated.";
     return;
   }

impeller/renderer/backend/vulkan/pipeline_cache_vk.cc

@@ -186,4 +186,8 @@ void PipelineCacheVK::PersistCacheToDisk() const {
   }
 }
 
+const CapabilitiesVK* PipelineCacheVK::GetCapabilities() const {
+  return CapabilitiesVK::Cast(caps_.get());
+}
+
 }  // namespace impeller

impeller/renderer/backend/vulkan/pipeline_cache_vk.h

@@ -31,6 +31,8 @@ class PipelineCacheVK {
 
   vk::UniquePipeline CreatePipeline(const vk::ComputePipelineCreateInfo& info);
 
+  const CapabilitiesVK* GetCapabilities() const;
+
   void PersistCacheToDisk() const;
 
  private: