Revert "Arm backend: Enable host memory capabilities." (pytorch#23321)

Reverts pytorch#23303

Internal CI failure:

* buck build --flagfile fbcode//mode/dev
fbcode//executorch/backends/arm/test:vgf_vulkan_features_test

```
Action failed: fbcode//executorch/backends/arm/test:vgf_vulkan_features_test (cfg:dev-linux-x86_64-fbcode-platform010-clang21-asan-ubsan-dev#dcaca8713064f6c2) (cxx_compile vgf_vulkan_features_test.cpp (pic))
Remote command returned non-zero exit code 1
Remote action, reproduce with: `frecli cas download-action 35b31f514f0f231bd45441aa904bf1592019feca624b6240b92c9007f3d1a4cb:148`
Stdout: <empty>
Stderr:
In file included from fbcode/executorch/backends/arm/test/vgf_vulkan_features_test.cpp:13:
buck-out/v2/art/fbcode/executorch/backends/arm/runtime/__vgf_backend__/1d6a408b7fe8847c/buck-headers/executorch/backends/arm/runtime/VGFSetup.h:15:10: fatal error: 'executorch/runtime/backend/interface.h' file not found
   15 | #include <executorch/runtime/backend/interface.h>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1 error generated.
```

cc @digantdesai @freddan80 @per @zingo @oscarandersson8218 @mansnils
@Sebastian-Larsson @robell @rascani

Author: metascroy

backends/arm/runtime/VGFBackend.cpp

@@ -103,13 +103,9 @@ VkResult vkml_allocate_basics(
     VkCommandPool* command_pool,
     uint32_t* queue_family_index,
     bool request_neural_statistics,
-    bool* neural_statistics_device_enabled,
-    bool request_host_memory_import,
-    VgfHostMemoryImportCapabilities* host_memory_import_capabilities);
+    bool* neural_statistics_device_enabled);
 
 // Helper functions to dump VGF Delegate Boundary Inputs
-constexpr const char* kVgfHostMemoryImportEnableEnv =
-    "EXECUTORCH_VGF_ENABLE_HOST_MEMORY_IMPORT";
 constexpr const char* kVgfDumpInputsDirEnv = "EXECUTORCH_VGF_DUMP_INPUTS_DIR";
 constexpr const char* kVgfDumpInputsAndExitEnv =
     "EXECUTORCH_VGF_DUMP_INPUTS_AND_EXIT";
@@ -422,11 +418,8 @@ class VGFBackend final : public ::executorch::runtime::BackendInterface {
 
     VkResult result;
     neural_statistics_config_ = get_vgf_neural_statistics_runtime_config();
-    const bool request_host_memory_import =
-        env_flag_enabled(kVgfHostMemoryImportEnableEnv);
 
-    // Fetch basic Vulkan objects once. Device extensions must be selected here,
-    // before vkCreateDevice; VgfRepr only receives already-created handles.
+    // Fetch basic vulkan objects once
     result = vkml_allocate_basics(
         &vk_instance,
         &vk_physical_device,
@@ -435,9 +428,7 @@ class VGFBackend final : public ::executorch::runtime::BackendInterface {
         &vk_command_pool,
         &vk_queue_family_index,
         neural_statistics_config_.requested,
-        &neural_statistics_device_enabled_,
-        request_host_memory_import,
-        &host_memory_import_capabilities_);
+        &neural_statistics_device_enabled_);
     if (result != VK_SUCCESS) {
       ET_LOG(
           Error, "Failed to initialize the Vulkan device error 0x%08X", result);
@@ -544,8 +535,7 @@ class VGFBackend final : public ::executorch::runtime::BackendInterface {
         vk_queue_family_index,
         neural_statistics_config_.requested,
         neural_statistics_device_enabled_,
-        neural_statistics_config_.mode_index,
-        host_memory_import_capabilities_);
+        neural_statistics_config_.mode_index);
 
 #ifdef ET_EVENT_TRACER_ENABLED
     event_tracer_end_profiling_delegate(event_tracer, allocate_repr_event);
@@ -875,7 +865,6 @@ class VGFBackend final : public ::executorch::runtime::BackendInterface {
     vk_queue_family_index = UINT32_MAX;
     neural_statistics_config_ = {};
     neural_statistics_device_enabled_ = false;
-    host_memory_import_capabilities_ = {};
     is_initialized_ = false;
     // Do not call volkFinalize(): the Vulkan backend shares the loader.
   }
@@ -890,7 +879,6 @@ class VGFBackend final : public ::executorch::runtime::BackendInterface {
   uint32_t vk_queue_family_index = UINT32_MAX;
   VgfNeuralStatisticsRuntimeConfig neural_statistics_config_{};
   bool neural_statistics_device_enabled_ = false;
-  VgfHostMemoryImportCapabilities host_memory_import_capabilities_{};
   bool is_initialized_ = false;
 };
 
@@ -908,17 +896,12 @@ VkResult vkml_allocate_basics(
     VkCommandPool* command_pool,
     uint32_t* queue_family_index,
     bool request_neural_statistics,
-    bool* neural_statistics_device_enabled,
-    bool request_host_memory_import,
-    VgfHostMemoryImportCapabilities* host_memory_import_capabilities) {
+    bool* neural_statistics_device_enabled) {
   VkResult result;
 
   if (neural_statistics_device_enabled != nullptr) {
     *neural_statistics_device_enabled = false;
   }
-  if (host_memory_import_capabilities != nullptr) {
-    *host_memory_import_capabilities = {};
-  }
 
   if (VK_SUCCESS != volkInitialize()) {
     ET_LOG(Error, "Volk failed to initialize");
@@ -1173,59 +1156,6 @@ VkResult vkml_allocate_basics(
 
   vector<const char*> requested_exts;
 
-  bool enable_host_memory_import_device = false;
-#if defined(VK_EXT_external_memory_host)
-  const bool host_memory_import_advertised = std::any_of(
-      available.begin(), available.end(), [](const auto& ext_avail) {
-        return std::strcmp(
-                   VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME,
-                   ext_avail.extensionName) == 0;
-      });
-
-  VkDeviceSize min_imported_host_pointer_alignment = 0;
-  if (host_memory_import_advertised) {
-    VkPhysicalDeviceExternalMemoryHostPropertiesEXT host_memory_properties{
-        .sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
-        .pNext = nullptr,
-    };
-    VkPhysicalDeviceProperties2 properties_2{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
-        .pNext = &host_memory_properties,
-    };
-    vkGetPhysicalDeviceProperties2(*physical_device, &properties_2);
-    min_imported_host_pointer_alignment =
-        host_memory_properties.minImportedHostPointerAlignment;
-  }
-
-  if (host_memory_import_capabilities != nullptr) {
-    host_memory_import_capabilities->physical_device_advertised =
-        host_memory_import_advertised;
-    host_memory_import_capabilities->min_imported_host_pointer_alignment =
-        min_imported_host_pointer_alignment;
-  }
-
-  enable_host_memory_import_device = vgf_host_memory_import_should_be_enabled(
-      request_host_memory_import, host_memory_import_advertised);
-  if (enable_host_memory_import_device) {
-    requested_exts.push_back(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME);
-  } else if (request_host_memory_import) {
-    ET_LOG(
-        Info,
-        "%s was requested but the Vulkan physical device does not expose %s",
-        kVgfHostMemoryImportEnableEnv,
-        VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME);
-  }
-#else
-  if (request_host_memory_import) {
-    ET_LOG(
-        Info,
-        "%s was requested but Vulkan headers do not expose "
-        "VK_EXT_external_memory_host",
-        kVgfHostMemoryImportEnableEnv);
-  }
-#endif
-
   const bool bfloat16_extension_available = std::any_of(
       available.begin(), available.end(), [](const auto& ext_avail) {
         return std::strcmp(
@@ -1333,36 +1263,12 @@ VkResult vkml_allocate_basics(
   // Load the device with volk and populate function pointers
   volkLoadDevice(*device);
 
-  if (host_memory_import_capabilities != nullptr) {
-    // Only a successful vkCreateDevice makes extension enablement
-    // authoritative. Physical-device advertisement alone is insufficient for
-    // later zero-copy code to use VK_EXT_external_memory_host device
-    // functionality.
-    host_memory_import_capabilities->logical_device_enabled =
-        enable_host_memory_import_device;
-    ET_LOG(
-        Info,
-        "VGF host memory import: requested=%d advertised=%d enabled=%d "
-        "minImportedHostPointerAlignment=%llu",
-        static_cast<int>(request_host_memory_import),
-        static_cast<int>(
-            host_memory_import_capabilities->physical_device_advertised),
-        static_cast<int>(
-            host_memory_import_capabilities->logical_device_enabled),
-        static_cast<unsigned long long>(
-            host_memory_import_capabilities
-                ->min_imported_host_pointer_alignment));
-  }
-
   vkGetDeviceQueue(*device, qf, 0, queue);
 
   VkCommandPoolCreateInfo poolInfo{
       .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
       .pNext = nullptr,
-      // VGF records a persistent per-repr command buffer. Host-memory import
-      // may later rebind descriptors and re-record only that command buffer.
-      // Keep the legacy flags=0 behavior unless the extension is truly enabled.
-      .flags = vgf_command_pool_flags(enable_host_memory_import_device),
+      .flags = 0,
       .queueFamilyIndex = qf,
   };
   result = vkCreateCommandPool(*device, &poolInfo, nullptr, command_pool);

backends/arm/runtime/VGFSetup.h

@@ -22,7 +22,6 @@ using executorch::runtime::CompileSpec;
 #include <executorch/backends/vulkan/runtime/vk_api/vk_api.h>
 
 #include <executorch/backends/arm/runtime/VGFNeuralStatistics.h>
-#include <executorch/backends/arm/runtime/VGFVulkanFeatures.h>
 
 namespace executorch {
 namespace backends {
@@ -109,8 +108,7 @@ class VgfRepr {
       uint32_t queue_family_index = UINT32_MAX,
       bool neural_statistics_requested = false,
       bool neural_statistics_device_enabled = false,
-      int neural_statistics_mode_index = 1,
-      VgfHostMemoryImportCapabilities host_memory_import_capabilities = {})
+      int neural_statistics_mode_index = 1)
       : vk_instance(inst),
         vk_physical(phys),
         vk_device(dev),
@@ -119,8 +117,7 @@ class VgfRepr {
         vk_queue_family_index(queue_family_index),
         neural_statistics_requested_(neural_statistics_requested),
         neural_statistics_device_enabled_(neural_statistics_device_enabled),
-        neural_statistics_mode_index_(neural_statistics_mode_index),
-        host_memory_import_capabilities_(host_memory_import_capabilities) {}
+        neural_statistics_mode_index_(neural_statistics_mode_index) {}
 
   /*
    * Process a VGF ready for execution, allocate necessary Vulkan objects.
@@ -178,23 +175,6 @@ class VgfRepr {
     return neural_statistics_requested_;
   }
 
-  bool host_memory_import_advertised() const {
-    return host_memory_import_capabilities_.physical_device_advertised;
-  }
-
-  bool host_memory_import_enabled() const {
-    return host_memory_import_capabilities_.logical_device_enabled;
-  }
-
-  VkDeviceSize min_imported_host_pointer_alignment() const {
-    return host_memory_import_capabilities_.min_imported_host_pointer_alignment;
-  }
-
-  const VgfHostMemoryImportCapabilities& host_memory_import_capabilities()
-      const {
-    return host_memory_import_capabilities_;
-  }
-
   ~VgfRepr() {
     free_vgf();
     if (vk_pipeline_cache != VK_NULL_HANDLE) {
@@ -223,7 +203,6 @@ class VgfRepr {
   bool neural_statistics_requested_ = false;
   bool neural_statistics_device_enabled_ = false;
   int neural_statistics_mode_index_ = 1;
-  VgfHostMemoryImportCapabilities host_memory_import_capabilities_{};
 
   bool timestamp_queries_enabled = false;
   uint32_t timestamp_valid_bits = 0;

backends/arm/runtime/VGFVulkanFeatures.h

@@ -13,29 +13,6 @@ namespace executorch {
 namespace backends {
 namespace vgf {
 
-// Snapshot of VK_EXT_external_memory_host state for the exact Vulkan device
-// used by VGF. Physical-device advertisement and logical-device enablement are
-// deliberately separate because Vulkan does not provide a post-creation query
-// for the list of extensions enabled at vkCreateDevice().
-struct VgfHostMemoryImportCapabilities {
-  bool physical_device_advertised = false;
-  bool logical_device_enabled = false;
-  VkDeviceSize min_imported_host_pointer_alignment = 0;
-};
-
-inline bool vgf_host_memory_import_should_be_enabled(
-    bool requested,
-    bool physical_device_advertised) {
-  return requested && physical_device_advertised;
-}
-
-inline VkCommandPoolCreateFlags vgf_command_pool_flags(
-    bool host_memory_import_enabled) {
-  return host_memory_import_enabled
-      ? VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
-      : 0;
-}
-
 inline VkPhysicalDeviceDataGraphFeaturesARM make_vgf_data_graph_features(
     void* p_next) {
   VkPhysicalDeviceDataGraphFeaturesARM features{};

backends/arm/test/vgf_vulkan_features_test.cpp

@@ -7,10 +7,6 @@
 
 #include <gtest/gtest.h>
 
-#include <type_traits>
-#include <utility>
-
-#include <executorch/backends/arm/runtime/VGFSetup.h>
 #include <executorch/backends/arm/runtime/VGFVulkanFeatures.h>
 
 namespace executorch {
@@ -46,92 +42,6 @@ TEST(VgfVulkanFeaturesTest, RequiresDataGraphShaderModuleSupport) {
   EXPECT_TRUE(vgf_data_graph_features_supported(available));
 }
 
-TEST(VgfVulkanFeaturesTest, EnablesHostMemoryImportWhenRequestedAndAdvertised) {
-  EXPECT_TRUE(vgf_host_memory_import_should_be_enabled(
-      /*requested=*/true, /*physical_device_advertised=*/true));
-}
-
-TEST(
-    VgfVulkanFeaturesTest,
-    DoesNotEnableHostMemoryImportWhenAdvertisedButNotRequested) {
-  EXPECT_FALSE(vgf_host_memory_import_should_be_enabled(
-      /*requested=*/false, /*physical_device_advertised=*/true));
-}
-
-TEST(
-    VgfVulkanFeaturesTest,
-    DoesNotEnableHostMemoryImportWhenRequestedButNotAdvertised) {
-  EXPECT_FALSE(vgf_host_memory_import_should_be_enabled(
-      /*requested=*/true, /*physical_device_advertised=*/false));
-}
-
-TEST(VgfVulkanFeaturesTest, LegacyHostMemoryImportPathRemainsDisabled) {
-  EXPECT_FALSE(vgf_host_memory_import_should_be_enabled(
-      /*requested=*/false, /*physical_device_advertised=*/false));
-}
-
-TEST(VgfVulkanFeaturesTest, HostImportCommandPoolSupportsIndividualReset) {
-  EXPECT_EQ(
-      vgf_command_pool_flags(/*host_memory_import_enabled=*/true),
-      VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
-}
-
-TEST(VgfVulkanFeaturesTest, LegacyCommandPoolFlagsRemainUnchanged) {
-  EXPECT_EQ(vgf_command_pool_flags(/*host_memory_import_enabled=*/false), 0u);
-}
-
-TEST(VgfVulkanFeaturesTest, HostMemoryImportCapabilitiesDefaultToUnavailable) {
-  const VgfHostMemoryImportCapabilities capabilities{};
-  EXPECT_FALSE(capabilities.physical_device_advertised);
-  EXPECT_FALSE(capabilities.logical_device_enabled);
-  EXPECT_EQ(capabilities.min_imported_host_pointer_alignment, 0u);
-}
-
-TEST(
-    VgfVulkanFeaturesTest,
-    HostMemoryImportCapabilitiesDistinguishAdvertisedFromEnabled) {
-  VgfHostMemoryImportCapabilities capabilities{};
-  capabilities.physical_device_advertised = true;
-  capabilities.logical_device_enabled = false;
-  capabilities.min_imported_host_pointer_alignment = 4096;
-
-  EXPECT_TRUE(capabilities.physical_device_advertised);
-  EXPECT_FALSE(capabilities.logical_device_enabled);
-  EXPECT_EQ(capabilities.min_imported_host_pointer_alignment, 4096u);
-}
-
-TEST(VgfVulkanFeaturesTest, VgfReprExposesHostMemoryImportCapabilities) {
-  static_assert(std::is_constructible_v<
-                VgfRepr,
-                VkInstance,
-                VkPhysicalDevice,
-                VkDevice,
-                VkQueue,
-                VkCommandPool,
-                uint32_t,
-                bool,
-                bool,
-                int,
-                VgfHostMemoryImportCapabilities>);
-  static_assert(std::is_same_v<
-                decltype(std::declval<const VgfRepr&>()
-                             .host_memory_import_advertised()),
-                bool>);
-  static_assert(
-      std::is_same_v<
-          decltype(std::declval<const VgfRepr&>().host_memory_import_enabled()),
-          bool>);
-  static_assert(std::is_same_v<
-                decltype(std::declval<const VgfRepr&>()
-                             .min_imported_host_pointer_alignment()),
-                VkDeviceSize>);
-  static_assert(std::is_same_v<
-                decltype(std::declval<const VgfRepr&>()
-                             .host_memory_import_capabilities()),
-                const VgfHostMemoryImportCapabilities&>);
-  SUCCEED();
-}
-
 } // namespace
 } // namespace vgf
 } // namespace backends