react-native-executorch 0.5.6 → 0.5.8

package/third-party/include/executorch/extension/module/bundled_module.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <executorch/extension/module/module.h>
+
+#ifdef USE_ATEN_LIB
+#define ET_BUNDLED_MODULE_NAMESPACE bundled_module::aten
+#else // !USE_ATEN_LIB
+#define ET_BUNDLED_MODULE_NAMESPACE bundled_module
+#endif // USE_ATEN_LIB
+
+namespace executorch {
+namespace extension {
+
+using ET_MODULE_NAMESPACE::Module;
+
+namespace ET_BUNDLED_MODULE_NAMESPACE {
+
+/**
+ * A facade class for loading bundled programs and executing methods within
+ * them.
+ */
+class BundledModule : public Module {
+public:
+  /**
+   * Constructs an instance with the bundled program buffer pointer.
+   *
+   * This constructor reads the program from bundled program buffer to load the
+   * module with data loader. The bundled program pointer is preserved so that
+   * the portion outside of program is accessible.
+   *
+   * @param[in] bundled_program_ptr A DataLoader used for loading program data.
+   * @param[in] memory_allocator A MemoryAllocator used for memory management.
+   * @param[in] temp_allocator A MemoryAllocator to use when allocating
+   * temporary data during kernel or delegate execution.
+   * @param[in] event_tracer A EventTracer used for tracking and logging events.
+   * @param[in] data_map_loader A DataLoader used for loading external weights.
+   */
+  explicit BundledModule(
+      const void *bundled_program_ptr,
+      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
+      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
+      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
+      std::unique_ptr<runtime::DataLoader> data_map_loader = nullptr);
+
+  // Disallow copying
+  BundledModule(const BundledModule &) = delete;
+  BundledModule &operator=(const BundledModule &) = delete;
+  // Disallow copying
+  BundledModule(BundledModule &&) = delete;
+  BundledModule &operator=(BundledModule &&) = delete;
+  // Default destructor
+  ~BundledModule() {
+    if (is_loaded_from_file_) {
+      delete[] static_cast<const uint8_t *>(bundled_program_ptr_);
+    }
+  }
+
+  /**
+   * Constructs an instance by loading a bundled program from a file with
+   * specified memory locking behavior.
+   *
+   * @param[in] file_path The path to the ExecuTorch bundled program file to
+   * load.
+   * @param[in] memory_allocator A MemoryAllocator used for memory management.
+   * @param[in] temp_allocator A MemoryAllocator to use when allocating
+   * temporary data during kernel or delegate execution.
+   * @param[in] event_tracer A EventTracer used for tracking and logging events.
+   * @param[in] data_map_loader A DataLoader used for loading external weights.
+   */
+  ET_NODISCARD static runtime::Result<std::unique_ptr<BundledModule>> from_file(
+      const std::string &file_path,
+      std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
+      std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
+      std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
+      std::unique_ptr<runtime::DataLoader> data_map_loader = nullptr);
+
+  using Module::execute;
+
+  /**
+   * Execute a specific method with the input value at the given `testset_idx`
+   * from the bundle to the method. Loads the program and method before
+   * executing if needed.
+   *
+   * This function is a wrapper of `load_bundled_input` in `bundled_program`.
+   *
+   * @param[in] method_name The name of the method to execute.
+   * @param[in] testset_idx The index of the input value to be passed to the
+   * method.
+   *
+   * @returns Return Error::Ok on a successful load, or the error happens during
+   * execution.
+   */
+  ET_NODISCARD
+  runtime::Result<std::vector<runtime::EValue>>
+  execute(const std::string &method_name, const size_t testset_idx);
+
+  /**
+   * Verify the output of a specific method with the expected output from the
+   * program bundle at the given `testset_idx`.
+   *
+   * This function is a wrapper of `verify_method_outputs` in `bundled_program`.
+   *
+   * @param[in] method_name The name of the method to extract outputs from.
+   * @param[in] testset_idx  The index of expected output needs to be compared.
+   * @param[in] rtol Relative tolerance used for data comparsion.
+   * @param[in] atol Absolute tolerance used for data comparsion.
+   *
+   * @returns Return Error::Ok if two outputs match, or the error happens during
+   * execution.
+   */
+  ET_NODISCARD
+  runtime::Error verify_method_outputs(const std::string &method_name,
+                                       const size_t testset_idx,
+                                       double rtol = 1e-5, double atol = 1e-8);
+
+private:
+  const void *bundled_program_ptr_;
+  bool is_loaded_from_file_ = false;
+};
+
+} // namespace ET_BUNDLED_MODULE_NAMESPACE
+} // namespace extension
+} // namespace executorch

package/third-party/include/executorch/extension/module/module.h

@@ -16,9 +16,23 @@
 
 #include <executorch/runtime/executor/program.h>
 
+#ifdef USE_ATEN_LIB
+#define ET_MODULE_NAMESPACE module::aten
+#else // !USE_ATEN_LIB
+#define ET_MODULE_NAMESPACE module
+#endif // USE_ATEN_LIB
+
 namespace executorch {
 namespace extension {
 
+using ET_RUNTIME_NAMESPACE::Method;
+using ET_RUNTIME_NAMESPACE::MethodMeta;
+using ET_RUNTIME_NAMESPACE::NamedDataMap;
+using ET_RUNTIME_NAMESPACE::Program;
+
+class ExecuTorchJni;
+
+namespace ET_MODULE_NAMESPACE {
 /**
  * A facade class for loading programs and executing methods within them.
  */
@@ -47,7 +61,7 @@ public:
    * @param[in] event_tracer A EventTracer used for tracking and logging events.
    */
   explicit Module(const std::string &file_path,
-                  const LoadMode load_mode = LoadMode::MmapUseMlock,
+                  const LoadMode load_mode = LoadMode::File,
                   std::unique_ptr<runtime::EventTracer> event_tracer = nullptr);
 
   /**
@@ -61,7 +75,7 @@ public:
    */
   explicit Module(const std::string &file_path,
                   const std::string &data_map_path,
-                  const LoadMode load_mode = LoadMode::MmapUseMlock,
+                  const LoadMode load_mode = LoadMode::File,
                   std::unique_ptr<runtime::EventTracer> event_tracer = nullptr);
 
   /**
@@ -93,7 +107,7 @@ public:
    * @param[in] data_map_loader A DataLoader used for loading external weights.
    */
   explicit Module(
-      std::shared_ptr<runtime::Program> program,
+      std::shared_ptr<Program> program,
       std::unique_ptr<runtime::MemoryAllocator> memory_allocator = nullptr,
       std::unique_ptr<runtime::MemoryAllocator> temp_allocator = nullptr,
       std::unique_ptr<runtime::EventTracer> event_tracer = nullptr,
@@ -103,7 +117,7 @@ public:
   Module &operator=(const Module &) = delete;
   Module(Module &&) = delete;
   Module &operator=(Module &&) = delete;
-
+  virtual ~Module() = default;
   /**
    * Loads the program if needed.
    *
@@ -112,16 +126,16 @@ public:
    *
    * @returns An Error to indicate success or failure of the loading process.
    */
-  ET_NODISCARD
-  runtime::Error load(const runtime::Program::Verification verification =
-                          runtime::Program::Verification::Minimal);
+  ET_NODISCARD virtual runtime::Error
+  load(const Program::Verification verification =
+           Program::Verification::Minimal);
 
   /**
    * Checks if the program is loaded.
    *
    * @returns true if the program is loaded, false otherwise.
    */
-  inline bool is_loaded() const { return program_ != nullptr; }
+  virtual inline bool is_loaded() const { return program_ != nullptr; }
 
   /**
    * Get the program. The data loader used by the program is guaranteed to be
@@ -129,7 +143,7 @@ public:
    *
    * @returns Shared pointer to the program or nullptr if it's not yet loaded.
    */
-  inline std::shared_ptr<runtime::Program> program() const { return program_; }
+  inline std::shared_ptr<Program> program() const { return program_; }
 
   /**
    * Get the number of methods available in the loaded program.
@@ -210,15 +224,14 @@ public:
 
   /**
    * Get a method metadata struct by method name.
-   * Loads the program and method if needed.
+   * Loads the program if needed.
    *
    * @param[in] method_name The name of the method to get the metadata for.
    *
    * @returns A method metadata, or an error if the program or method failed to
    * load.
    */
-  runtime::Result<runtime::MethodMeta>
-  method_meta(const std::string &method_name);
+  runtime::Result<MethodMeta> method_meta(const std::string &method_name);
 
   /**
    * Execute a specific method with the given input values and retrieve the
@@ -231,8 +244,7 @@ public:
    * @returns A Result object containing either a vector of output values
    *          from the method or an error to indicate failure.
    */
-  ET_NODISCARD
-  runtime::Result<std::vector<runtime::EValue>>
+  ET_NODISCARD virtual runtime::Result<std::vector<runtime::EValue>>
   execute(const std::string &method_name,
           const std::vector<runtime::EValue> &input_values);
 
@@ -453,33 +465,40 @@ public:
     return event_tracer_.get();
   }
 
+  ET_NODISCARD
+  runtime::Span<uint8_t> debug_buffer() {
+    return runtime::Span<uint8_t>(debug_buffer_.data(), debug_buffer_.size());
+  }
+
 private:
   struct MethodHolder {
     std::vector<std::vector<uint8_t>> planned_buffers;
     std::vector<runtime::Span<uint8_t>> planned_spans;
     std::unique_ptr<runtime::HierarchicalAllocator> planned_memory;
     std::unique_ptr<runtime::MemoryManager> memory_manager;
-    std::unique_ptr<runtime::Method> method;
+    std::unique_ptr<Method> method;
     std::vector<runtime::EValue> inputs;
   };
 
   std::string file_path_;
   std::string data_map_path_;
-  LoadMode load_mode_{LoadMode::MmapUseMlock};
-  std::shared_ptr<runtime::Program> program_;
+  LoadMode load_mode_{LoadMode::File};
+  std::shared_ptr<Program> program_;
   std::unique_ptr<runtime::DataLoader> data_loader_;
   std::unique_ptr<runtime::MemoryAllocator> memory_allocator_;
   std::unique_ptr<runtime::MemoryAllocator> temp_allocator_;
   std::unique_ptr<runtime::EventTracer> event_tracer_;
   std::unique_ptr<runtime::DataLoader> data_map_loader_;
-  std::unique_ptr<runtime::NamedDataMap> data_map_;
+  std::unique_ptr<NamedDataMap> data_map_;
+  std::vector<uint8_t> debug_buffer_;
 
 protected:
   std::unordered_map<std::string, MethodHolder> methods_;
 
-  friend class ExecuTorchJni;
+  friend class executorch::extension::ExecuTorchJni;
 };
 
+} // namespace ET_MODULE_NAMESPACE
 } // namespace extension
 } // namespace executorch
 
@@ -487,6 +506,13 @@ namespace torch {
 namespace executor {
 // TODO(T197294990): Remove these deprecated aliases once all users have moved
 // to the new `::executorch` namespaces.
-using ::executorch::extension::Module;
+using ::executorch::extension::ET_MODULE_NAMESPACE::Module;
 } // namespace executor
 } // namespace torch
+
+namespace executorch {
+namespace extension {
+// backward compatible namespace alias
+using ::executorch::extension::ET_MODULE_NAMESPACE::Module;
+} // namespace extension
+} // namespace executorch

package/third-party/include/executorch/extension/threadpool/cpuinfo_utils.h

@@ -7,9 +7,8 @@
  */
 
 #pragma once
-#if defined(__ANDROID__) && defined(__aarch64__)
 
-#include <cpuinfo.h>
+#include <cpuinfo/cpuinfo.h>
 
 namespace executorch::extension::cpuinfo {
 
@@ -23,4 +22,3 @@ namespace torch::executorch::cpuinfo { // DEPRECATED
 // the namespace `torch::executorch` instead of `torch::executor`.
 using ::executorch::extension::cpuinfo::get_num_performant_cores; // DEPRECATED
 } // namespace torch::executorch::cpuinfo
-#endif

package/third-party/include/executorch/extension/threadpool/threadpool.h

@@ -7,13 +7,12 @@
  */
 
 #pragma once
-#if defined(__ANDROID__) && defined(__aarch64__)
 
 #include <functional>
 #include <memory>
 #include <mutex>
 
-#include <pthreadpool.h>
+#include <pthreadpool/pthreadpool.h>
 
 namespace executorch::extension::threadpool {
 
@@ -91,4 +90,3 @@ using ::executorch::extension::threadpool::get_pthreadpool; // DEPRECATED
 using ::executorch::extension::threadpool::get_threadpool;  // DEPRECATED
 using ::executorch::extension::threadpool::ThreadPool;      // DEPRECATED
 } // namespace torch::executorch::threadpool
-#endif

package/third-party/include/executorch/extension/threadpool/threadpool_guard.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+namespace executorch::extension::threadpool {
+
+// A RAII, thread local (!) guard that enables or disables guard upon
+// construction, and sets it back to the original value upon destruction.
+struct NoThreadPoolGuard {
+  static bool is_enabled();
+  static void set_enabled(bool enabled);
+
+  NoThreadPoolGuard() : prev_mode_(NoThreadPoolGuard::is_enabled()) {
+    NoThreadPoolGuard::set_enabled(true);
+  }
+  ~NoThreadPoolGuard() { NoThreadPoolGuard::set_enabled(prev_mode_); }
+
+private:
+  const bool prev_mode_;
+};
+
+} // namespace executorch::extension::threadpool
+
+namespace torch::executorch::threadpool { // DEPRECATED
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces. Note that threadpool incorrectly used
+// the namespace `torch::executorch` instead of `torch::executor`.
+using ::executorch::extension::threadpool::NoThreadPoolGuard; // DEPRECATED
+} // namespace torch::executorch::threadpool

package/third-party/include/executorch/runtime/backend/backend_execution_context.h

@@ -12,7 +12,7 @@
 #include <executorch/runtime/core/memory_allocator.h>
 
 namespace executorch {
-namespace runtime {
+namespace ET_RUNTIME_NAMESPACE {
 
 /**
  * BackendExecutionContext will be used to inject run time context.
@@ -59,13 +59,13 @@ private:
   const char *method_name_ = nullptr;
 };
 
-} // namespace runtime
+} // namespace ET_RUNTIME_NAMESPACE
 } // namespace executorch
 
 namespace torch {
 namespace executor {
 // TODO(T197294990): Remove these deprecated aliases once all users have moved
 // to the new `::executorch` namespaces.
-using ::executorch::runtime::BackendExecutionContext;
+using ::executorch::ET_RUNTIME_NAMESPACE::BackendExecutionContext;
 } // namespace executor
 } // namespace torch

package/third-party/include/executorch/runtime/backend/backend_init_context.h

@@ -7,12 +7,12 @@
  */
 
 #pragma once
+#include <executorch/runtime/core/event_tracer.h>
 #include <executorch/runtime/core/memory_allocator.h>
 #include <executorch/runtime/core/named_data_map.h>
 
 namespace executorch {
-namespace runtime {
-
+namespace ET_RUNTIME_NAMESPACE {
 /**
  * BackendInitContext will be used to inject runtime info for to initialize
  * delegate.
@@ -23,8 +23,14 @@ public:
                               EventTracer *event_tracer = nullptr,
                               const char *method_name = nullptr,
                               const NamedDataMap *named_data_map = nullptr)
-      : runtime_allocator_(runtime_allocator), method_name_(method_name),
-        named_data_map_(named_data_map) {}
+      : runtime_allocator_(runtime_allocator),
+#ifdef ET_EVENT_TRACER_ENABLED
+        event_tracer_(event_tracer),
+#else
+        event_tracer_(nullptr),
+#endif
+        method_name_(method_name), named_data_map_(named_data_map) {
+  }
 
   /** Get the runtime allocator passed from Method. It's the same runtime
    * executor used by the standard executor runtime and the life span is the
@@ -60,13 +66,13 @@ private:
   const NamedDataMap *named_data_map_ = nullptr;
 };
 
-} // namespace runtime
+} // namespace ET_RUNTIME_NAMESPACE
 } // namespace executorch
 
 namespace torch {
 namespace executor {
 // TODO(T197294990): Remove these deprecated aliases once all users have moved
 // to the new `::executorch` namespaces.
-using ::executorch::runtime::BackendInitContext;
+using ::executorch::ET_RUNTIME_NAMESPACE::BackendInitContext;
 } // namespace executor
 } // namespace torch

package/third-party/include/executorch/runtime/backend/backend_option_context.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <executorch/runtime/core/event_tracer.h>
+#include <executorch/runtime/core/memory_allocator.h>
+#include <executorch/runtime/core/named_data_map.h>
+
+namespace executorch {
+namespace ET_RUNTIME_NAMESPACE {
+/**
+ * BackendOptionContext will be used to inject runtime info for to initialize
+ * delegate.
+ */
+class BackendOptionContext final {
+public:
+  explicit BackendOptionContext() {}
+};
+
+} // namespace ET_RUNTIME_NAMESPACE
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::ET_RUNTIME_NAMESPACE::BackendOptionContext;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/runtime/backend/interface.h

@@ -12,6 +12,8 @@
 
 #include <executorch/runtime/backend/backend_execution_context.h>
 #include <executorch/runtime/backend/backend_init_context.h>
+#include <executorch/runtime/backend/backend_option_context.h>
+#include <executorch/runtime/backend/options.h>
 #include <executorch/runtime/core/array_ref.h>
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/evalue.h>
@@ -22,7 +24,7 @@
 #include <executorch/runtime/platform/compiler.h>
 
 namespace executorch {
-namespace runtime {
+namespace ET_RUNTIME_NAMESPACE {
 
 struct SizedBuffer {
   void *buffer;
@@ -97,6 +99,37 @@ public:
                                      DelegateHandle *handle,
                                      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.
+   *
+   * @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
+  set_option(__ET_UNUSED BackendOptionContext &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(__ET_UNUSED BackendOptionContext &context,
+             executorch::runtime::Span<BackendOption> &backend_options) {
+    return Error::Ok;
+  };
+
   /**
    * Responsible for destroying a handle, if it's required for some backend.
    * It may be needed for some backends. For example, resources associated with
@@ -148,19 +181,47 @@ size_t get_num_registered_backends();
  */
 Result<const char *> get_backend_name(size_t index);
 
-} // namespace runtime
+/**
+ * Sets backend options for a specific backend.
+ *
+ * @param backend_name The name of the backend to set options for
+ * @param backend_options The backend option list containing the options
+ * to set
+ * @return Error::Ok on success, Error::NotFound if backend is not found, or
+ * other error codes on failure
+ */
+Error set_option(
+    const char *backend_name,
+    const executorch::runtime::Span<executorch::runtime::BackendOption>
+        backend_options);
+
+/**
+ * Retrieves backend options for a specific backend.
+ *
+ * @param backend_name The name of the backend to get options from
+ * @param backend_options The backend option objects that will be filled with
+ * the populated values from the backend
+ * @return Error::Ok on success, Error::NotFound if backend is not found, or
+ * other error codes on failure
+ */
+Error get_option(const char *backend_name,
+                 executorch::runtime::Span<executorch::runtime::BackendOption>
+                     backend_options);
+
+} // namespace ET_RUNTIME_NAMESPACE
 } // namespace executorch
 
 namespace torch {
 namespace executor {
 // TODO(T197294990): Remove these deprecated aliases once all users have moved
 // to the new `::executorch` namespaces.
-using ::executorch::runtime::Backend;
-using ::executorch::runtime::CompileSpec;
-using ::executorch::runtime::DelegateHandle;
-using ::executorch::runtime::get_backend_class;
-using ::executorch::runtime::register_backend;
-using ::executorch::runtime::SizedBuffer;
-using PyTorchBackendInterface = ::executorch::runtime::BackendInterface;
+using ::executorch::ET_RUNTIME_NAMESPACE::Backend;
+using ::executorch::ET_RUNTIME_NAMESPACE::CompileSpec;
+using ::executorch::ET_RUNTIME_NAMESPACE::DelegateHandle;
+using ::executorch::ET_RUNTIME_NAMESPACE::get_backend_class;
+using ::executorch::ET_RUNTIME_NAMESPACE::register_backend;
+using ::executorch::ET_RUNTIME_NAMESPACE::SizedBuffer;
+using PyTorchBackendInterface =
+    ::executorch::ET_RUNTIME_NAMESPACE::BackendInterface;
 } // namespace executor
 } // namespace torch