Fix Vulkan subgroup size control crash by targeting Vulkan 1.3 core

Summary:

Fixes a native Vulkan compute pipeline creation crash
(-3 VK_ERROR_INITIALIZATION_FAILED) on Android 16 (API 36) drivers.
VK_EXT_subgroup_size_control was promoted to core in Vulkan 1.3, so those
drivers no longer advertise it as a separate device extension. ExecuTorch
targeted a Vulkan 1.1 instance, where the feature is neither core nor
available as an extension, yet the physical device still reported it as
supported. Chaining VkPhysicalDeviceSubgroupSizeControlFeaturesEXT into
VkDeviceCreateInfo.pNext without a valid enable route is invalid usage and
crashes device/pipeline creation.

This raises the requested instance apiVersion to Vulkan 1.3 (capped at the
loader-supported version, falling back to 1.1) so the feature can be used via
the core path, and gates subgroup size control per device: it is enabled only
when the extension is enabled, or when both the instance and the physical
device are at 1.3+. Otherwise the related capability flags are cleared so
downstream shader dispatch does not request an unsupported subgroup size.

On Android 16 devices this restores subgroup size control via the core route
rather than disabling it.

Authored with Claude.

Fixes #11754.

Test Plan:

Export and run a Vulkan-delegated model on an Android 16 (API 36) device and
confirm compute pipelines create successfully. Also verify on a Vulkan 1.1
device that the feature falls back cleanly without crashing.

Reviewers:

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: SS-JIA

backends/vulkan/runtime/vk_api/Adapter.cpp

@@ -10,6 +10,7 @@
 
 #include <executorch/backends/vulkan/runtime/vk_api/Adapter.h>
 
+#include <cstring>
 #include <iomanip>
 #include <sstream>
 
@@ -83,7 +84,7 @@ void populate_queue_info(
 }
 
 VkDevice create_logical_device(
-    const PhysicalDevice& physical_device,
+    PhysicalDevice& physical_device,
     const uint32_t num_queues_to_create,
     std::vector<Adapter::Queue>& queues,
     std::vector<uint32_t>& queue_usage) {
@@ -217,15 +218,46 @@ VkDevice create_logical_device(
 #endif /* VK_NV_cooperative_matrix2 */
 
 #ifdef VK_EXT_subgroup_size_control
-  // Only enable the feature struct if the extension was actually requested
-  // and the feature flag is set on the physical device. The extension itself
-  // is filtered into enabled_device_extensions by
-  // find_requested_device_extensions.
+  // The subgroup size control feature struct may only be chained into
+  // VkDeviceCreateInfo.pNext if the feature is actually going to be enabled on
+  // the logical device. It can be enabled via two routes:
+  //   1. The VK_EXT_subgroup_size_control extension is enabled, or
+  //   2. It is available as core (promoted to core in Vulkan 1.3), which
+  //      requires both the instance and the physical device to be at 1.3+.
+  // On Vulkan 1.3-core drivers the extension is frequently not advertised as a
+  // separate string, so checking enabled_device_extensions alone is not
+  // sufficient. Chaining the struct without either route being available is
+  // invalid usage and crashes device/pipeline creation with
+  // VK_ERROR_INITIALIZATION_FAILED.
+  bool subgroup_size_control_extension_enabled = false;
+  for (const auto& ext : enabled_device_extensions) {
+    if (strcmp(ext, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME) == 0) {
+      subgroup_size_control_extension_enabled = true;
+      break;
+    }
+  }
+
+  bool subgroup_size_control_core_available = false;
+#if defined(VK_VERSION_1_3)
+  const bool device_supports_1_3 = physical_device.api_version_major > 1 ||
+      (physical_device.api_version_major == 1 &&
+       physical_device.api_version_minor >= 3);
+  const bool instance_supports_1_3 =
+      select_instance_api_version() >= VK_API_VERSION_1_3;
+  subgroup_size_control_core_available =
+      device_supports_1_3 && instance_supports_1_3;
+#endif /* VK_VERSION_1_3 */
+
   VkPhysicalDeviceSubgroupSizeControlFeaturesEXT subgroup_size_control_features{
       physical_device.subgroup_size_control_features};
-  if (physical_device.supports_subgroup_size_control) {
+  if (physical_device.supports_subgroup_size_control &&
+      (subgroup_size_control_extension_enabled ||
+       subgroup_size_control_core_available)) {
     subgroup_size_control_features.pNext = extension_list_top;
     extension_list_top = &subgroup_size_control_features;
+  } else {
+    physical_device.supports_subgroup_size_control = false;
+    physical_device.supports_compute_full_subgroups = false;
   }
 #endif /* VK_EXT_subgroup_size_control */
 

backends/vulkan/runtime/vk_api/Device.cpp

@@ -40,6 +40,24 @@ DeviceType determine_device_type(const std::string& device_name) {
 
 } // namespace
 
+uint32_t select_instance_api_version() {
+  uint32_t requested_version = VK_API_VERSION_1_1;
+#if defined(VK_VERSION_1_3)
+  auto enumerate_instance_version =
+      (PFN_vkEnumerateInstanceVersion)vkGetInstanceProcAddr(
+          VK_NULL_HANDLE, "vkEnumerateInstanceVersion");
+  if (enumerate_instance_version != nullptr) {
+    uint32_t loader_version = 0;
+    if (enumerate_instance_version(&loader_version) == VK_SUCCESS) {
+      requested_version = loader_version < VK_API_VERSION_1_3
+          ? loader_version
+          : VK_API_VERSION_1_3;
+    }
+  }
+#endif /* VK_VERSION_1_3 */
+  return requested_version;
+}
+
 PhysicalDevice::PhysicalDevice(
     VkInstance instance_handle,
     VkPhysicalDevice physical_device_handle)

backends/vulkan/runtime/vk_api/Device.h

@@ -118,6 +118,13 @@ struct DeviceHandle final {
   ~DeviceHandle();
 };
 
+// Returns the Vulkan instance apiVersion that ExecuTorch should request. Aims
+// for Vulkan 1.3 (which exposes VK_EXT_subgroup_size_control as core, so it can
+// be used without a separately advertised extension) but never exceeds the
+// version the loader supports. Falls back to 1.1 on loaders that predate
+// vkEnumerateInstanceVersion.
+uint32_t select_instance_api_version();
+
 void find_requested_device_extensions(
     VkPhysicalDevice physical_device,
     std::vector<const char*>& enabled_extensions,

backends/vulkan/runtime/vk_api/Runtime.cpp

@@ -87,7 +87,7 @@ VkInstance create_instance(const RuntimeConfig& config) {
       0, // applicationVersion
       nullptr, // pEngineName
       0, // engineVersion
-      VK_API_VERSION_1_1, // apiVersion
+      select_instance_api_version(), // apiVersion
   };
 
   std::vector<const char*> enabled_layers;