react-native-executorch 0.5.15 → 0.6.0

package/third-party/include/executorch/ExecuTorchModule.h

@@ -16,7 +16,7 @@ NS_ASSUME_NONNULL_BEGIN
  * and its debug name.
  */
 NS_SWIFT_NAME(TensorMetadata)
-__attribute__((deprecated("This API is experimental.")))
+__attribute__((objc_subclassing_restricted))
 @interface ExecuTorchTensorMetadata : NSObject
 
 /** The size of each dimension. */
@@ -46,7 +46,7 @@ __attribute__((deprecated("This API is experimental.")))
  * per-tensor metadata, buffer sizes, backends, and instruction count.
  */
 NS_SWIFT_NAME(MethodMetadata)
-__attribute__((deprecated("This API is experimental.")))
+__attribute__((objc_subclassing_restricted))
 @interface ExecuTorchMethodMetadata : NSObject
 
 /** The method’s name. */
@@ -123,22 +123,48 @@ typedef NS_ENUM(uint8_t, ExecuTorchVerification) {
  * them.
  */
 NS_SWIFT_NAME(Module)
-__attribute__((deprecated("This API is experimental.")))
 @interface ExecuTorchModule : NSObject
 
 /**
- * Initializes a module with a file path and a specified load mode.
+ * Initializes a module with a file path, data path and a specified load mode.
  *
  * @param filePath A string representing the path to the ExecuTorch program
  * file.
+ * @param dataFilePaths A list of strings representing paths to .ptd files with
+ * external tensors and external data.
  * @param loadMode A value from ExecuTorchModuleLoadMode that determines the
  * file loading behavior.
  * @return An initialized ExecuTorchModule instance.
  */
 - (instancetype)initWithFilePath:(NSString *)filePath
+                   dataFilePaths:(NSArray<NSString *> *)dataFilePaths
                         loadMode:(ExecuTorchModuleLoadMode)loadMode
     NS_DESIGNATED_INITIALIZER;
 
+/**
+ * Initializes a module with a file path, data path and a specified load mode.
+ *
+ * @param filePath A string representing the path to the ExecuTorch program
+ * file.
+ * @param dataFilePaths A list of strings representing paths to .ptd files with
+ * external tensors and external data.
+ * @return An initialized ExecuTorchModule instance.
+ */
+- (instancetype)initWithFilePath:(NSString *)filePath
+                   dataFilePaths:(NSArray<NSString *> *)dataFilePaths;
+
+/**
+ * Initializes a module with a file path and a specified load mode.
+ *
+ * @param filePath A string representing the path to the ExecuTorch program
+ * file.
+ * @param loadMode A value from ExecuTorchModuleLoadMode that determines the
+ * file loading behavior.
+ * @return An initialized ExecuTorchModule instance.
+ */
+- (instancetype)initWithFilePath:(NSString *)filePath
+                        loadMode:(ExecuTorchModuleLoadMode)loadMode;
+
 /**
  * Initializes a module with a file path using the default load mode (File
  * mode).
@@ -197,6 +223,14 @@ __attribute__((deprecated("This API is experimental.")))
  */
 - (BOOL)isMethodLoaded:(NSString *)methodName NS_SWIFT_NAME(isLoaded(_:));
 
+/**
+ * Unloads a method and releases its native resources and planned buffers.
+ *
+ * @param methodName The method to unload.
+ * @return YES if the method was unloaded; NO if it was not loaded at all.
+ */
+- (BOOL)unloadMethod:(NSString *)methodName NS_SWIFT_NAME(unload(_:));
+
 /**
  * Retrieves the set of method names available in the loaded program.
  *
@@ -382,6 +416,145 @@ __attribute__((deprecated("This API is experimental.")))
                                                      error:(NSError **)error
     NS_SWIFT_UNAVAILABLE("")NS_RETURNS_RETAINED;
 
+/**
+ * Sets a single input value for the "forward" method at index 0.
+ *
+ * @param value The input value.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setInput:(ExecuTorchValue *)value
+           error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
+
+/**
+ * Sets a single input value for the "forward" method at the specified index.
+ *
+ * @param value The input value.
+ * @param index Zero-based input index.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setInput:(ExecuTorchValue *)value
+         atIndex:(NSInteger)index
+           error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
+
+/**
+ * Sets a single input value for the specified method at index 0.
+ *
+ * @param value The input value.
+ * @param methodName The method name.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setInput:(ExecuTorchValue *)value
+       forMethod:(NSString *)methodName
+           error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
+
+/**
+ * Sets a single input value for the specified method at the given index.
+ *
+ * The module retains the provided value to keep its backing storage alive
+ * until the value is overwritten or the module is deallocated.
+ *
+ * @param value The input value.
+ * @param methodName The method name.
+ * @param index Zero-based input index.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setInput:(ExecuTorchValue *)value
+       forMethod:(NSString *)methodName
+         atIndex:(NSInteger)index
+           error:(NSError **)error NS_REFINED_FOR_SWIFT;
+
+/**
+ * Sets all input values for the "forward" method.
+ *
+ * The number and types of values must match the method’s declared inputs.
+ *
+ * @param values The input values, one per declared input.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setInputs:(NSArray<ExecuTorchValue *> *)values
+            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
+
+/**
+ * Sets all input values for the specified method.
+ *
+ * The module retains the provided values to keep their backing storage alive
+ * until the values are overwritten or the module is deallocated.
+ *
+ * @param values The input values, one per declared input.
+ * @param methodName The method name.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setInputs:(NSArray<ExecuTorchValue *> *)values
+        forMethod:(NSString *)methodName
+            error:(NSError **)error NS_REFINED_FOR_SWIFT;
+
+/**
+ * Sets the output buffer for the "forward" method at index 0.
+ *
+ * Only tensor outputs are supported. The provided value must wrap a tensor
+ * compatible with the method’s output slot.
+ *
+ * @param value The output buffer (must wrap a tensor).
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setOutput:(ExecuTorchValue *)value
+            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
+
+/**
+ * Sets the output buffer for the "forward" method at the specified index.
+ *
+ * Only tensor outputs are supported. The provided value must wrap a tensor
+ * compatible with the method’s output slot.
+ *
+ * @param value The output buffer (must wrap a tensor).
+ * @param index Zero-based output index.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setOutput:(ExecuTorchValue *)value
+          atIndex:(NSInteger)index
+            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
+
+/**
+ * Sets the output buffer for the specified method at index 0.
+ *
+ * Only tensor outputs are supported. The provided value must wrap a tensor
+ * compatible with the method’s output slot.
+ *
+ * @param value The output buffer (must wrap a tensor).
+ * @param methodName The method name.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setOutput:(ExecuTorchValue *)value
+        forMethod:(NSString *)methodName
+            error:(NSError **)error NS_SWIFT_UNAVAILABLE("");
+
+/**
+ * Sets the output buffer for the specified method at the given index.
+ *
+ * The module retains the provided value to keep its backing storage alive
+ * until the value is overwritten or the module is deallocated.
+ * Only tensor outputs are supported.
+ *
+ * @param value The output buffer (must wrap a tensor).
+ * @param methodName The method name.
+ * @param index Zero-based output index.
+ * @param error On failure, set to an NSError describing the issue.
+ * @return YES on success; NO otherwise.
+ */
+- (BOOL)setOutput:(ExecuTorchValue *)value
+        forMethod:(NSString *)methodName
+          atIndex:(NSInteger)index
+            error:(NSError **)error NS_REFINED_FOR_SWIFT;
+
 + (instancetype)new NS_UNAVAILABLE;
 - (instancetype)init NS_UNAVAILABLE;
 

package/third-party/include/executorch/ExecuTorchTensor.h

@@ -69,8 +69,7 @@ typedef NS_ENUM(uint8_t, ExecuTorchShapeDynamism) {
  * @return An NSInteger indicating the size in bytes.
  */
 FOUNDATION_EXPORT
-__attribute__((deprecated("This API is experimental."))) NSInteger
-ExecuTorchSizeOfDataType(ExecuTorchDataType dataType)
+NSInteger ExecuTorchSizeOfDataType(ExecuTorchDataType dataType)
     NS_SWIFT_NAME(size(ofDataType:));
 
 /**
@@ -81,7 +80,7 @@ ExecuTorchSizeOfDataType(ExecuTorchDataType dataType)
  * @return An NSInteger equal to the product of the sizes of all dimensions.
  */
 FOUNDATION_EXPORT
-__attribute__((deprecated("This API is experimental."))) NSInteger
+NSInteger
 ExecuTorchElementCountOfShape(NSArray<NSNumber *> *shape) NS_REFINED_FOR_SWIFT;
 
 /**
@@ -91,7 +90,7 @@ ExecuTorchElementCountOfShape(NSArray<NSNumber *> *shape) NS_REFINED_FOR_SWIFT;
  * initializers and utility methods to work with tensor data.
  */
 NS_SWIFT_NAME(AnyTensor)
-__attribute__((deprecated("This API is experimental.")))
+__attribute__((objc_subclassing_restricted))
 @interface ExecuTorchTensor : NSObject<NSCopying>
 
 /**

package/third-party/include/executorch/ExecuTorchValue.h

@@ -22,12 +22,6 @@ typedef NS_ENUM(uint32_t, ExecuTorchValueTag) {
   ExecuTorchValueTagDouble,
   ExecuTorchValueTagInteger,
   ExecuTorchValueTagBoolean,
-  ExecuTorchValueTagBooleanList,
-  ExecuTorchValueTagDoubleList,
-  ExecuTorchValueTagIntegerList,
-  ExecuTorchValueTagTensorList,
-  ExecuTorchValueTagScalarList,
-  ExecuTorchValueTagOptionalTensorList,
 } NS_SWIFT_NAME(ValueTag);
 
 typedef NSNumber *
@@ -49,7 +43,7 @@ typedef float
  * a tensor or a scalar. The value’s type is indicated by its tag.
  */
 NS_SWIFT_NAME(Value)
-__attribute__((deprecated("This API is experimental.")))
+__attribute__((objc_subclassing_restricted))
 @interface ExecuTorchValue : NSObject<NSCopying>
 
 /**

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

@@ -69,7 +69,7 @@ public:
    * memory locking behavior.
    *
    * @param[in] file_path The path to the ExecuTorch program file to load.
-   * @param[in] data_map_path The path to a .ptd file
+   * @param[in] data_map_path The path to a .ptd file.
    * @param[in] load_mode The loading mode to use.
    * @param[in] event_tracer A EventTracer used for tracking and logging events.
    */
@@ -78,6 +78,20 @@ public:
                   const LoadMode load_mode = LoadMode::File,
                   std::unique_ptr<runtime::EventTracer> event_tracer = nullptr);
 
+  /**
+   * Constructs an instance by loading a program from a file with specified
+   * memory locking behavior.
+   *
+   * @param[in] file_path The path to the ExecuTorch program file to load.
+   * @param[in] data_files The path to one or more .ptd file/s.
+   * @param[in] load_mode The loading mode to use.
+   * @param[in] event_tracer A EventTracer used for tracking and logging events.
+   */
+  explicit Module(const std::string &file_path,
+                  std::vector<std::string> data_files,
+                  const LoadMode load_mode = LoadMode::File,
+                  std::unique_ptr<runtime::EventTracer> event_tracer = nullptr);
+
   /**
    * Constructs an instance with the provided data loader and memory allocator.
    *
@@ -188,6 +202,32 @@ public:
     return load_method(method_name, nullptr, event_tracer);
   }
 
+  /**
+   * Unload a specific method from the program.
+   *
+   * @param[in] method_name The name of the method to unload.
+   *
+   * @returns True if the method is unloaded, false if no-op.
+   */
+  inline bool unload_method(const std::string &method_name) {
+    return methods_.erase(method_name);
+  }
+
+  /**
+   * DEPRECATED: Module manages each Method exclusively.
+   *
+   * Get a method by it's name. Not recommended to use this method directly as
+   * an end user. It's exposed to allow for composability of module in apis that
+   * operate on method.
+   *
+   * @param[in] method_name The name of the method to get.
+   *
+   * @returns A Result object containing either a pointer to the requested
+   *          method or an error to indicate failure.
+   */
+  ET_DEPRECATED ET_NODISCARD runtime::Result<Method *>
+  method(const std::string &method_name);
+
   /**
    * Load the 'forward' method from the program and set up memory management if
    * needed. The loaded method is cached to reuse the next time it's executed.
@@ -210,6 +250,13 @@ public:
     return load_forward(nullptr, event_tracer);
   }
 
+  /**
+   * Unload the 'forward' method from the program.
+   *
+   * @returns True if the 'forward' method is unloaded, false if no-op.
+   */
+  inline bool unload_forward() { return unload_method("forward"); }
+
   /**
    * Checks if a specific method is loaded.
    *
@@ -453,6 +500,89 @@ public:
     return set_output("forward", std::move(output_value), output_index);
   }
 
+  /**
+   * Sets all output tensors for a specific method.
+   *
+   * Loads the program and method if needed, and for each output uses
+   * the provided tensor's data buffer as the method's output buffer.
+   *
+   * @param[in] method_name The name of the method.
+   * @param[in] output_values A vector of EValues to set as the method outputs.
+   *
+   * @returns An Error to indicate success or failure.
+   *
+   * @note Only Tensor outputs are currently supported for setting.
+   * @note Will fail for outputs that are memory-planned or constants.
+   */
+  ET_NODISCARD
+  runtime::Error set_outputs(const std::string &method_name,
+                             const std::vector<runtime::EValue> &output_values);
+
+  /**
+   * Sets all output tensors for the "forward" method.
+   *
+   * @param[in] output_values A vector of EValues to set as the method outputs.
+   *
+   * @returns An Error to indicate success or failure.
+   *
+   * @note Only Tensor outputs are currently supported for setting.
+   * @note Will fail for outputs that are memory-planned or constants.
+   */
+  ET_NODISCARD
+  inline runtime::Error
+  set_outputs(const std::vector<runtime::EValue> &output_values) {
+    return set_outputs("forward", output_values);
+  }
+
+  /**
+   * Retrieve all current output values of a specific method without executing
+   * it. Loads the program and method before retrieval if needed.
+   *
+   * @param[in] method_name The name of the method.
+   *
+   * @returns A Result containing the vector of output values, or an error.
+   */
+  ET_NODISCARD
+  runtime::Result<std::vector<runtime::EValue>>
+  get_outputs(const std::string &method_name);
+
+  /**
+   * Retrieve all current output values of the "forward" method without
+   * executing it. Loads the program and method before retrieval if needed.
+   *
+   * @returns A Result containing the vector of output values, or an error.
+   */
+  ET_NODISCARD
+  inline runtime::Result<std::vector<runtime::EValue>> get_outputs() {
+    return get_outputs("forward");
+  }
+
+  /**
+   * Retrieve a single current output value of a specific method without
+   * executing it. Loads the program and method before retrieval if needed.
+   *
+   * @param[in] method_name The name of the method.
+   * @param[in] output_index Zero-based index of the output to retrieve.
+   *
+   * @returns A Result containing the requested output value, or an error.
+   */
+  ET_NODISCARD
+  runtime::Result<runtime::EValue> get_output(const std::string &method_name,
+                                              size_t output_index = 0);
+
+  /**
+   * Retrieve a single current output value of the "forward" method without
+   * executing it. Loads the program and method before retrieval if needed.
+   *
+   * @param[in] output_index Zero-based index of the output to retrieve.
+   *
+   * @returns A Result containing the requested output value, or an error.
+   */
+  ET_NODISCARD
+  inline runtime::Result<runtime::EValue> get_output(size_t output_index = 0) {
+    return get_output("forward", output_index);
+  }
+
   /**
    * Retrieves the EventTracer instance being used by the Module.
    * EventTracer is used for tracking and logging events during the execution
@@ -465,8 +595,9 @@ public:
     return event_tracer_.get();
   }
 
-  ET_NODISCARD
-  runtime::Span<uint8_t> debug_buffer() {
+  // Note: this debug_buffer will always be empty. The one being used is in
+  // the event_tracer attached to module. Please use that one.
+  ET_DEPRECATED ET_NODISCARD runtime::Span<uint8_t> debug_buffer() {
     return runtime::Span<uint8_t>(debug_buffer_.data(), debug_buffer_.size());
   }
 
@@ -477,20 +608,20 @@ private:
     std::unique_ptr<runtime::HierarchicalAllocator> planned_memory;
     std::unique_ptr<runtime::MemoryManager> memory_manager;
     std::unique_ptr<Method> method;
-    std::vector<runtime::EValue> inputs;
   };
 
   std::string file_path_;
-  std::string data_map_path_;
+  std::vector<std::string> data_files_;
   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<NamedDataMap> data_map_;
-  std::vector<uint8_t> debug_buffer_;
+  std::vector<std::unique_ptr<runtime::DataLoader>> data_map_loaders_;
+  std::vector<std::unique_ptr<NamedDataMap>> named_data_maps_;
+  std::unique_ptr<NamedDataMap> merged_data_map_;
+  ET_DEPRECATED std::vector<uint8_t> debug_buffer_;
 
 protected:
   std::unordered_map<std::string, MethodHolder> methods_;

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

@@ -9,5 +9,6 @@
 #pragma once
 
 // Umbrella header for the Tensor extension.
+#include <executorch/extension/tensor/tensor_accessor.h>
 #include <executorch/extension/tensor/tensor_ptr.h>
 #include <executorch/extension/tensor/tensor_ptr_maker.h>

package/third-party/include/executorch/extension/tensor/tensor_ptr.h

@@ -102,15 +102,27 @@ make_tensor_ptr(std::vector<executorch::aten::SizesType> sizes,
                 executorch::aten::ScalarType type = deduced_type,
                 executorch::aten::TensorShapeDynamism dynamism =
                     executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND) {
+  ET_CHECK_MSG(data.size() ==
+                   executorch::aten::compute_numel(sizes.data(), sizes.size()),
+               "Data size does not match tensor size.");
   if (type != deduced_type) {
     ET_CHECK_MSG(runtime::canCast(deduced_type, type),
                  "Cannot cast deduced type to specified type.");
     std::vector<uint8_t> casted_data(data.size() * runtime::elementSize(type));
-    ET_SWITCH_REALHBBF16_TYPES(type, nullptr, "make_tensor_ptr", CTYPE, [&] {
-      std::transform(data.begin(), data.end(),
-                     reinterpret_cast<CTYPE *>(casted_data.data()),
-                     [](const T &val) { return static_cast<CTYPE>(val); });
-    });
+
+    // Create a minimal context for error handling in ET_SWITCH
+    struct {
+      [[noreturn]] void fail(torch::executor::Error /* error */) {
+        ET_CHECK_MSG(false, "Unsupported dtype in make_tensor_ptr");
+      }
+    } ctx;
+
+    ET_SWITCH_REALHBBF16_AND_UINT_TYPES(
+        type, ctx, "make_tensor_ptr", CTYPE, [&] {
+          std::transform(data.begin(), data.end(),
+                         reinterpret_cast<CTYPE *>(casted_data.data()),
+                         [](const T &val) { return static_cast<CTYPE>(val); });
+        });
     const auto raw_data_ptr = casted_data.data();
     auto data_ptr =
         std::make_shared<std::vector<uint8_t>>(std::move(casted_data));
@@ -232,7 +244,8 @@ make_tensor_ptr(std::initializer_list<T> list,
  * @return A TensorPtr that manages the newly created TensorImpl.
  */
 template <typename T> inline TensorPtr make_tensor_ptr(T value) {
-  return make_tensor_ptr({}, std::vector<T>{value});
+  return make_tensor_ptr(std::vector<executorch::aten::SizesType>{},
+                         std::vector<T>{value});
 }
 
 /**
@@ -281,31 +294,80 @@ inline TensorPtr make_tensor_ptr(
 }
 
 /**
- * Creates a TensorPtr to manage a new Tensor with the same properties
- * as the given Tensor, sharing the same data without owning it.
+ * Creates a TensorPtr to manage a new Tensor that aliases the given Tensor's
+ * storage, with optional metadata overrides. Shape dynamism is inherited from
+ * the source tensor.
+ *
+ * If an override is provided (non-empty), it is passed as-is. If an override is
+ * empty, the corresponding metadata is reused from the source tensor when it
+ * fits; otherwise it is left empty for the core factory to derive a valid
+ * configuration. If `dim_order` is empty but `strides` is provided, `dim_order`
+ * is left empty so the core may infer it from the provided strides.
  *
- * @param tensor The Tensor whose properties are used to create a new TensorPtr.
- * @return A new TensorPtr managing a Tensor with the same properties as the
- * original.
+ * @param tensor The source tensor to alias.
+ * @param sizes Optional sizes override.
+ * @param dim_order Optional dimension order override.
+ * @param strides Optional strides override.
+ * @param deleter A custom deleter function for managing the lifetime of the
+ * original Tensor.
+ * @return A TensorPtr aliasing the same storage with requested metadata.
  */
-inline TensorPtr make_tensor_ptr(const executorch::aten::Tensor &tensor) {
-  return make_tensor_ptr(
-      std::vector<executorch::aten::SizesType>(tensor.sizes().begin(),
-                                               tensor.sizes().end()),
-      tensor.mutable_data_ptr(),
+inline TensorPtr
+make_tensor_ptr(const executorch::aten::Tensor &tensor,
+                std::vector<executorch::aten::SizesType> sizes = {},
+                std::vector<executorch::aten::DimOrderType> dim_order = {},
+                std::vector<executorch::aten::StridesType> strides = {},
+                std::function<void(void *)> deleter = nullptr) {
+  if (sizes.empty()) {
+    sizes.assign(tensor.sizes().begin(), tensor.sizes().end());
+  }
+  const auto same_rank = sizes.size() == static_cast<size_t>(tensor.dim());
+  const auto same_shape = same_rank && std::equal(sizes.begin(), sizes.end(),
+                                                  tensor.sizes().begin());
+  const auto element_count =
+      executorch::aten::compute_numel(sizes.data(), sizes.size());
+  const auto parent_element_count = tensor.numel();
+  ET_CHECK_MSG(
+      element_count <= parent_element_count,
+      "Requested view has %zd elements, but source tensor only has %zd.",
+      static_cast<ssize_t>(element_count),
+      static_cast<ssize_t>(parent_element_count));
 #ifndef USE_ATEN_LIB
-      std::vector<executorch::aten::DimOrderType>(tensor.dim_order().begin(),
-                                                  tensor.dim_order().end()),
-      std::vector<executorch::aten::StridesType>(tensor.strides().begin(),
-                                                 tensor.strides().end()),
-      tensor.scalar_type(), tensor.shape_dynamism()
+  if (dim_order.empty() && strides.empty() && same_rank) {
+    dim_order.assign(tensor.dim_order().begin(), tensor.dim_order().end());
+  }
+#endif // USE_ATEN_LIB
+  if (strides.empty() && dim_order.empty() && same_shape) {
+    strides.assign(tensor.strides().begin(), tensor.strides().end());
+  }
+  return make_tensor_ptr(std::move(sizes), tensor.mutable_data_ptr(),
+                         std::move(dim_order), std::move(strides),
+                         tensor.scalar_type(),
+#ifndef USE_ATEN_LIB
+                         tensor.shape_dynamism(),
 #else  // USE_ATEN_LIB
-      {},
-      std::vector<executorch::aten::StridesType>(tensor.strides().begin(),
-                                                 tensor.strides().end()),
-      tensor.scalar_type()
+                         executorch::aten::TensorShapeDynamism::DYNAMIC_BOUND,
 #endif // USE_ATEN_LIB
-  );
+                         std::move(deleter));
+}
+
+/**
+ * Convenience overload identical to make_tensor_ptr(*tensor_ptr, ...).
+ * Keeps the original TensorPtr alive until the returned TensorPtr is destroyed.
+ *
+ * @param tensor_ptr The source tensor pointer to alias.
+ * @param sizes Optional sizes override.
+ * @param dim_order Optional dimension order override.
+ * @param strides Optional strides override.
+ * @return A TensorPtr aliasing the same storage with requested metadata.
+ */
+inline TensorPtr
+make_tensor_ptr(const TensorPtr &tensor_ptr,
+                std::vector<executorch::aten::SizesType> sizes = {},
+                std::vector<executorch::aten::DimOrderType> dim_order = {},
+                std::vector<executorch::aten::StridesType> strides = {}) {
+  return make_tensor_ptr(*tensor_ptr, std::move(sizes), std::move(dim_order),
+                         std::move(strides), [tensor_ptr](void *) {});
 }
 
 /**

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

@@ -42,8 +42,11 @@ public:
    * is a private API, which will later be replaced by something that allows
    * creating of threadpool with requested size and use such a threadpool with
    * backend delegates, custom ops or optimized lib.
+   * For Meta internal use, there is
+   * executorch::extension::threadpool::UseNThreadsThreadPoolGuard API that
+   * provides a safer way to select a subset of threads, from threadpool, to run
+   * the model on.
    */
-  [[deprecated("This API is experimental and may change without notice.")]]
   bool _unsafe_reset_threadpool(uint32_t num_threads);
 
   /**

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

@@ -11,6 +11,12 @@
 #include <executorch/runtime/core/memory_allocator.h>
 #include <executorch/runtime/core/named_data_map.h>
 
+#ifdef __GNUC__
+// Disable -Wdeprecated-declarations, as some builds use 'Werror'.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
 namespace executorch {
 namespace ET_RUNTIME_NAMESPACE {
 /**

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

@@ -97,7 +97,7 @@ public:
    */
   ET_NODISCARD virtual Error execute(BackendExecutionContext &context,
                                      DelegateHandle *handle,
-                                     EValue **args) const = 0;
+                                     Span<EValue *> args) const = 0;
 
   /**
    * Responsible update the backend status, if any. The backend options are