Update base for Update on "[4/N] Add backend options map"

cccclai · cccclai · commit bf88011bb241 · 2025-06-17T09:12:45.000-07:00
This is to manage the backend <-> BackendOptions map. Users will create the bakcend options map, and ET runtime will read the backend name, and dispatch the list of backend options to each backend. Differential Revision: [D76149466](https://our.internmc.facebook.com/intern/diff/D76149466/) [ghstack-poisoned]
diff --git a/runtime/backend/backend_options.h b/runtime/backend/backend_options.h
@@ -6,94 +6,88 @@
  * LICENSE file in the root directory of this source tree.
  */
 
- #pragma once
- #include <executorch/runtime/core/error.h>
- #include <cstddef>
- #include <cstring>
- #include <executorch/runtime/core/array_ref.h>
- #include <executorch/runtime/core/error.h>
- #include <variant>
- 
- namespace executorch {
- namespace runtime {
- 
- // Strongly-typed option key template
- template <typename T>
- struct OptionKey {
-   const char* key;
-   constexpr explicit OptionKey(const char* k) : key(k) {}
- };
- 
- // Union replaced with std::variant
- using OptionValue = std::variant<bool, int, const char*>;
- 
- struct BackendOption {
-   const char* key; // key is the name of the backend option, like num_threads,
-                    // enable_profiling, etc
-   OptionValue
-       value; // value is the value of the backend option, like 4, true, etc
- };
- 
- template <size_t MaxCapacity>
- class BackendOptions {
-  public:
-   // Initialize with zero options
-   BackendOptions() : size_(0) {}
- 
-   // Type-safe setters
-   template <typename T>
-   void set_option(OptionKey<T> key, T value) {
-     const char* k = key.key;
-     // Update existing if found
-     for (size_t i = 0; i < size_; ++i) {
-       if (strcmp(options_[i].key, k) == 0) {
-         options_[i].value = value;
-         return;
-       }
-     }
-     // Add new option if space available
-     if (size_ < MaxCapacity) {
-       options_[size_++] = BackendOption{k, value};
-     }
-   }
- 
-   // Type-safe getters
-   template <typename T>
-   Error get_option(OptionKey<T> key, T& out) const {
-     const char* k = key.key;
-     for (size_t i = 0; i < size_; ++i) {
-       if (strcmp(options_[i].key, k) == 0) {
-         if (auto* val = std::get_if<T>(&options_[i].value)) {
-           out = *val;
-           return Error::Ok;
-         }
-         return Error::InvalidArgument;
-       }
-     }
-     return Error::NotFound;
-   }
-   executorch::runtime::ArrayRef<BackendOption> view() const {
-     return executorch::runtime::ArrayRef<BackendOption>(options_, size_);
-   }
-   
-  private:
-   BackendOption options_[MaxCapacity]{}; // Storage for backend options
-   size_t size_; // Current number of options
- };
- 
- // Helper functions for creating typed option keys (unchanged)
- constexpr OptionKey<bool> BoolKey(const char* k) {
-   return OptionKey<bool>(k);
- }
- 
- constexpr OptionKey<int> IntKey(const char* k) {
-   return OptionKey<int>(k);
- }
- 
- constexpr OptionKey<const char*> StrKey(const char* k) {
-   return OptionKey<const char*>(k);
- }
- 
- } // namespace runtime
- } // namespace executorch
- 
+#pragma once
+#include <executorch/runtime/core/error.h>
+#include <cstddef>
+#include <cstring>
+#include <variant>
+
+namespace executorch {
+namespace runtime {
+
+// Strongly-typed option key template
+template <typename T>
+struct OptionKey {
+  const char* key;
+  constexpr explicit OptionKey(const char* k) : key(k) {}
+};
+
+// Union replaced with std::variant
+using OptionValue = std::variant<bool, int, const char*>;
+
+struct BackendOption {
+  const char* key; // key is the name of the backend option, like num_threads,
+                   // enable_profiling, etc
+  OptionValue
+      value; // value is the value of the backend option, like 4, true, etc
+};
+
+template <size_t MaxCapacity>
+class BackendOptions {
+ public:
+  // Initialize with zero options
+  BackendOptions() : size_(0) {}
+
+  // Type-safe setters
+  template <typename T>
+  void set_option(OptionKey<T> key, T value) {
+    const char* k = key.key;
+    // Update existing if found
+    for (size_t i = 0; i < size_; ++i) {
+      if (strcmp(options_[i].key, k) == 0) {
+        options_[i].value = value;
+        return;
+      }
+    }
+    // Add new option if space available
+    if (size_ < MaxCapacity) {
+      options_[size_++] = BackendOption{k, value};
+    }
+  }
+
+  // Type-safe getters
+  template <typename T>
+  Error get_option(OptionKey<T> key, T& out) const {
+    const char* k = key.key;
+    for (size_t i = 0; i < size_; ++i) {
+      if (strcmp(options_[i].key, k) == 0) {
+        if (auto* val = std::get_if<T>(&options_[i].value)) {
+          out = *val;
+          return Error::Ok;
+        }
+        return Error::InvalidArgument;
+      }
+    }
+    return Error::NotFound;
+  }
+
+ private:
+  BackendOption options_[MaxCapacity]{}; // Storage for backend options
+  size_t size_; // Current number of options
+};
+
+// Helper functions for creating typed option keys (unchanged)
+constexpr OptionKey<bool> BoolKey(const char* k) {
+  return OptionKey<bool>(k);
+}
+
+constexpr OptionKey<int> IntKey(const char* k) {
+  return OptionKey<int>(k);
+}
+
+constexpr OptionKey<const char*> StrKey(const char* k) {
+  return OptionKey<const char*>(k);
+}
+
+} // namespace runtime
+} // namespace executorch
diff --git a/runtime/backend/interface.h b/runtime/backend/interface.h
@@ -12,8 +12,8 @@
 
 #include <executorch/runtime/backend/backend_execution_context.h>
 #include <executorch/runtime/backend/backend_init_context.h>
-#include <executorch/runtime/backend/backend_update_context.h>
 #include <executorch/runtime/backend/backend_options.h>
+#include <executorch/runtime/backend/backend_update_context.h>
 #include <executorch/runtime/core/array_ref.h>
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/evalue.h>
@@ -102,18 +102,35 @@ class BackendInterface {
       EValue** args) const = 0;
 
   /**
-   * Responsible update the backend status, if any. The backend options are passed in
-   * by users, and the backend can update its internal status based on the options.
+   * Responsible update the backend status, if any. The backend options are
+   * passed in by users, and the backend can update its internal status based on
+   * the options.
    *
    * @param[in] context Runtime context if any. Currently it's not used.
    * @param[in] args A list of BackendOptions passed in by users.
    * @retval Error::Ok if successful.
    */
-   ET_NODISCARD virtual Error update(
-    BackendUpdateContext& context,
-    const executorch::runtime::ArrayRef<BackendOption>& backend_options) const {
-        return Error::Ok;
-      };
+  ET_NODISCARD virtual Error set_option(
+      BackendUpdateContext& context,
+      const executorch::runtime::Span<BackendOption>& backend_options) {
+    return Error::Ok;
+  };
+
+  /**
+   * Responsible update the backend status, if any. The backend options are
+   * passed in by users, and the backend can update its internal status based on
+   * the options.
+   *
+   * @param[in] context Runtime context if any. Currently it's not used.
+   * @param[in] args A list of BackendOptions passed in by users, that will be
+   * filled by the backend
+   * @retval Error::Ok if successful.
+   */
+  ET_NODISCARD virtual Error get_option(
+      BackendUpdateContext& context,
+      executorch::runtime::Span<BackendOption>& backend_options) {
+    return Error::Ok;
+  };
 
   /**
    * Responsible for destroying a handle, if it's required for some backend.
diff --git a/runtime/backend/test/backend_interface_update_test.cpp b/runtime/backend/test/backend_interface_update_test.cpp
@@ -54,10 +54,10 @@ class MockBackend : public BackendInterface {
             return Error::Ok;
       }
   
-      Error update(
+      Error set_option(
           BackendUpdateContext& context,
-          const executorch::runtime::ArrayRef<BackendOption>& backend_options) const override {
-          update_count++;
+          const executorch::runtime::Span<BackendOption>& backend_options) override {
+          set_option_count++;
           int sucess_update = 0;
           for (const auto& backend_option : backend_options) {
             if (strcmp(backend_option.key, "Backend") == 0) {
@@ -92,7 +92,7 @@ class MockBackend : public BackendInterface {
       // State tracking
       mutable bool init_called = false;
       mutable int execute_count = 0;
-      mutable int update_count = 0;
+      mutable int set_option_count = 0;
 };
 
  class BackendInterfaceUpdateTest : public ::testing::Test {
@@ -119,7 +119,8 @@ TEST_F(BackendInterfaceUpdateTest, HandlesInvalidOption) {
     "None"
   };
 
-  Error err = mock_backend->update(context, invalid_option);
+  // Create a span from the single option
+  Error err = mock_backend->set_option(context, invalid_option);
   EXPECT_EQ(err, Error::InvalidArgument);
 
 }
@@ -132,7 +133,7 @@ TEST_F(BackendInterfaceUpdateTest, HandlesInvalidOption) {
   EXPECT_EQ(mock_backend->target_backend, std::nullopt);
 
   // Test successful update
-  Error err = mock_backend->update(context, options.view());
+  Error err = mock_backend->set_option(context, options.view());
   EXPECT_EQ(err, Error::Ok);
 
   EXPECT_EQ(mock_backend->target_backend, "GPU");
@@ -150,7 +151,7 @@ TEST_F(BackendInterfaceUpdateTest, HandlesIntOption) {
   options.set_option(IntKey("NumberOfThreads"), expected_num_threads);  
   
   // Test successful update
-  Error err = mock_backend->update(context, options.view());
+  Error err = mock_backend->set_option(context, options.view());
   EXPECT_EQ(err, Error::Ok);
   EXPECT_EQ(mock_backend->num_threads, expected_num_threads);
 }
@@ -164,7 +165,7 @@ TEST_F(BackendInterfaceUpdateTest, HandlesBoolOption) {
   options.set_option(BoolKey("Debug"), true);  
   
   // Test successful update
-  Error err = mock_backend->update(context, options.view());
+  Error err = mock_backend->set_option(context, options.view());
   EXPECT_EQ(err, Error::Ok);
 
   EXPECT_EQ(mock_backend->debug, true);
@@ -181,7 +182,7 @@ TEST_F(BackendInterfaceUpdateTest, HandlesMultipleOptions) {
   options.set_option(StrKey("Backend"), "GPU");  
   
   // Test successful update
-  Error err = mock_backend->update(context, options.view());
+  Error err = mock_backend->set_option(context, options.view());
   EXPECT_EQ(err, Error::Ok);
 
   EXPECT_EQ(mock_backend->debug, true);
@@ -199,7 +200,7 @@ TEST_F(BackendInterfaceUpdateTest, UpdateBeforeInit) {
   options.set_option(StrKey("Backend"), "GPU");
   
   // Update before init
-  Error err = mock_backend->update(update_context, options.view());
+  Error err = mock_backend->set_option(update_context, options.view());
   EXPECT_EQ(err, Error::Ok);
     
   // Now call init
@@ -210,7 +211,7 @@ TEST_F(BackendInterfaceUpdateTest, UpdateBeforeInit) {
   
   // Verify state
   EXPECT_TRUE(mock_backend->init_called);
-  EXPECT_EQ(mock_backend->update_count, 1);
+  EXPECT_EQ(mock_backend->set_option_count, 1);
   EXPECT_EQ(mock_backend->execute_count, 0);
   ASSERT_TRUE(mock_backend->target_backend.has_value());
   EXPECT_STREQ(mock_backend->target_backend.value().c_str(), "GPU");
@@ -234,7 +235,7 @@ TEST_F(BackendInterfaceUpdateTest, UpdateAfterInitBeforeExecute) {
   
   // Now update
   options.set_option(StrKey("Backend"), "CPU");
-  Error err = mock_backend->update(update_context, options.view());
+  Error err = mock_backend->set_option(update_context, options.view());
   EXPECT_EQ(err, Error::Ok);
   
   // Now execute
@@ -244,7 +245,7 @@ TEST_F(BackendInterfaceUpdateTest, UpdateAfterInitBeforeExecute) {
   EXPECT_EQ(err, Error::Ok);
   
   // Verify state
-  EXPECT_EQ(mock_backend->update_count, 1);
+  EXPECT_EQ(mock_backend->set_option_count, 1);
   EXPECT_EQ(mock_backend->execute_count, 1);
   ASSERT_TRUE(mock_backend->target_backend.has_value());
   EXPECT_STREQ(mock_backend->target_backend.value().c_str(), "CPU");
@@ -270,15 +271,15 @@ TEST_F(BackendInterfaceUpdateTest, UpdateBetweenExecutes) {
   
   // Update between executes
   options.set_option(StrKey("Backend"), "NPU");
-  err = mock_backend->update(update_context, options.view());
+  err = mock_backend->set_option(update_context, options.view());
   EXPECT_EQ(err, Error::Ok);
   
   // Second execute
   err = mock_backend->execute(execute_context, handle, args);
   EXPECT_EQ(err, Error::Ok);
   
   // Verify state
-  EXPECT_EQ(mock_backend->update_count, 1);
+  EXPECT_EQ(mock_backend->set_option_count, 1);
   EXPECT_EQ(mock_backend->execute_count, 2);
   ASSERT_TRUE(mock_backend->target_backend.has_value());
   EXPECT_STREQ(mock_backend->target_backend.value().c_str(), "NPU");
diff --git a/runtime/core/span.h b/runtime/core/span.h
@@ -55,6 +55,9 @@ class Span final {
   template <size_t N>
   /* implicit */ constexpr Span(T (&Arr)[N]) : data_(Arr), length_(N) {}
 
+  /// Construct a Span from a single element reference.
+  /* implicit */ constexpr Span(T& single_element) : data_(&single_element), length_(1) {}
+
   /// @returns a pointer to the start of the underlying element buffer.
   iterator begin() const noexcept {
     return data_;
