Update on "[3/N] Add get_option/set_option function in backend interface"

Add update function in backend interface class. The update function will receive the backend options from dispatched by the ET runtime.

ET runtime's logic: loop over each backend and it's corresponding backend options, dispatch the backend options to the corresponding backend

Next step, will add update API in the method and then module
exported-using-ghexport

Differential Revision: [D75919242](https://our.internmc.facebook.com/intern/diff/D75919242/)

Differential Revision: [D75919242](https://our.internmc.facebook.com/intern/diff/D75919242)

[ghstack-poisoned]

Author: cccclai

runtime/backend/options.h

@@ -74,21 +74,12 @@ class BackendOptions {
    */
   BackendOptions() : size_(0) {}
 
-  /**
-   * Returns a const view of all stored options as a Span.
-   *
-   * @return A const Span containing all BackendOption entries
-   */
-  executorch::runtime::Span<const BackendOption> view() const {
-    return executorch::runtime::Span<const BackendOption>(options_, size_);
-  }
-
   /**
    * Returns a mutable view of all stored options as a Span.
    *
    * @return A mutable Span containing all BackendOption entries
    */
-  executorch::runtime::Span<BackendOption> mutable_view() {
+  executorch::runtime::Span<BackendOption> view() {
     return executorch::runtime::Span<BackendOption>(options_, size_);
   }
 
@@ -101,9 +92,13 @@ class BackendOptions {
    * @param value The boolean value to set
    * @return Error::Ok on success, Error::InvalidArgument if storage is full
    */
-  template <size_t N>
-  Error set_option(const char (&key)[N], bool value) noexcept {
-    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
+  Error set_option(const char* key, bool value) noexcept {
+    ET_CHECK_MSG(
+        strlen(key) <= kMaxOptionKeyLength,
+        "Option key %s (%zu) is too long (max %zu)",
+        key,
+        strlen(key),
+        kMaxOptionKeyLength);
     return set_option_impl(key, value);
   }
 
@@ -116,9 +111,13 @@ class BackendOptions {
    * @param value The integer value to set
    * @return Error::Ok on success, Error::InvalidArgument if storage is full
    */
-  template <size_t N>
-  Error set_option(const char (&key)[N], int value) noexcept {
-    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
+  Error set_option(const char* key, int value) noexcept {
+    ET_CHECK_MSG(
+        strlen(key) <= kMaxOptionKeyLength,
+        "Option key %s (%zu) is too long (max %zu)",
+        key,
+        strlen(key),
+        kMaxOptionKeyLength);
     return set_option_impl(key, value);
   }
 
@@ -134,9 +133,13 @@ class BackendOptions {
    * @param value The string value to set (must have static storage duration)
    * @return Error::Ok on success, Error::InvalidArgument if storage is full
    */
-  template <size_t N>
-  Error set_option(const char (&key)[N], const char* value) noexcept {
-    static_assert(N <= kMaxOptionKeyLength, "Option key is too long");
+  Error set_option(const char* key, const char* value) noexcept {
+    ET_CHECK_MSG(
+        strlen(key) <= kMaxOptionKeyLength,
+        "Option key %s (%zu) is too long (max %zu)",
+        key,
+        strlen(key),
+        kMaxOptionKeyLength);
     // Create a fixed-size array and copy the string
     std::array<char, kMaxOptionValueLength> arr;
     strncpy(arr.data(), value, kMaxOptionValueLength - 1);

runtime/backend/test/backend_interface_update_test.cpp

@@ -58,27 +58,28 @@ class MockBackend : public BackendInterface {
       const executorch::runtime::Span<BackendOption>& backend_options)
       override {
     set_option_count++;
-    int sucess_update = 0;
+    int success_update = 0;
     for (const auto& backend_option : backend_options) {
       if (strcmp(backend_option.key, "Backend") == 0) {
-        if (std::holds_alternative<const char*>(backend_option.value)) {
+        if (std::holds_alternative<std::array<char, 256>>(backend_option.value)) {
           // Store the value in our member variable
-          target_backend = std::get<const char*>(backend_option.value);
-          sucess_update++;
+          const auto& arr = std::get<std::array<char, 256>>(backend_option.value);
+          target_backend = std::string(arr.data());
+          success_update++;
         }
       } else if (strcmp(backend_option.key, "NumberOfThreads") == 0) {
         if (std::holds_alternative<int>(backend_option.value)) {
           num_threads = std::get<int>(backend_option.value);
-          sucess_update++;
+          success_update++;
         }
       } else if (strcmp(backend_option.key, "Debug") == 0) {
         if (std::holds_alternative<bool>(backend_option.value)) {
           debug = std::get<bool>(backend_option.value);
-          sucess_update++;
+          success_update++;
         }
       }
     }
-    if (sucess_update == backend_options.size()) {
+    if (success_update == backend_options.size()) {
       return Error::Ok;
     }
     return Error::InvalidArgument;
@@ -113,9 +114,9 @@ TEST_F(BackendInterfaceUpdateTest, HandlesInvalidOption) {
   BackendOptionContext context;
 
   // Test invalid key case
-  BackendOption invalid_option{"InvalidKey", "None"};
+  std::array<char, 256> value_array{"None"};
+  BackendOption invalid_option{"InvalidKey", value_array};
 
-  // Create a span from the single option
   Error err = mock_backend->set_option(context, invalid_option);
   EXPECT_EQ(err, Error::InvalidArgument);
 }

runtime/backend/test/backend_options_test.cpp

@@ -101,7 +101,7 @@ TEST_F(BackendOptionsTest, MutableOption) {
   EXPECT_EQ(options.get_option("flag", ival), Error::Ok);
   EXPECT_EQ(ival, 0);
 
-  options.mutable_view()[0].value = 123; // Overwrites the entry
+  options.view()[0].value = 123; // Overwrites the entry
 
   // Integer get should succeed with the updated value
   EXPECT_EQ(options.get_option("flag", ival), Error::Ok);