react-native-executorch 0.9.0 → 0.9.1

package/third-party/include/executorch/runtime/core/portable_type/tensor_impl.h

@@ -10,8 +10,11 @@
 
 #include <executorch/runtime/core/array_ref.h>
 #include <executorch/runtime/core/error.h>
+#include <executorch/runtime/core/portable_type/device.h>
 #include <executorch/runtime/core/portable_type/scalar_type.h>
+#include <executorch/runtime/core/result.h>
 #include <executorch/runtime/core/tensor_shape_dynamism.h>
+#include <executorch/runtime/platform/compiler.h>
 
 // Forward declaration of a helper that provides access to internal resizing
 // methods of TensorImpl. Real definition is in
@@ -99,11 +102,15 @@ public:
    * @param strides Strides of the tensor at each dimension. Must contain `dim`
    *     entries.
    * @param dynamism The mutability of the shape of the tensor.
+   * @param device_type The type of device where tensor data resides.
+   * @param device_index The device index for multi-device scenarios.
    */
   TensorImpl(ScalarType type, ssize_t dim, SizesType *sizes,
              void *data = nullptr, DimOrderType *dim_order = nullptr,
              StridesType *strides = nullptr,
-             TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC);
+             TensorShapeDynamism dynamism = TensorShapeDynamism::STATIC,
+             DeviceType device_type = DeviceType::CPU,
+             DeviceIndex device_index = 0);
 
   /**
    * Returns the size of the tensor in bytes.
@@ -161,6 +168,15 @@ public:
   /// Returns the mutability of the shape of the tensor.
   TensorShapeDynamism shape_dynamism() const { return shape_dynamism_; }
 
+  /// Returns the device where tensor data resides.
+  Device device() const { return device_; }
+
+  /// Returns the type of device where tensor data resides.
+  DeviceType device_type() const { return device_.type(); }
+
+  /// Returns the device index, or 0 if default/unspecified.
+  DeviceIndex device_index() const { return device_.index(); }
+
   /// Returns a pointer of type T to the constant underlying data blob.
   template <typename T> inline const T *data() const {
     return static_cast<const T *>(data());
@@ -238,6 +254,9 @@ private:
 
   /// Specifies the mutability of the shape of the tensor.
   const TensorShapeDynamism shape_dynamism_;
+
+  /// Device where tensor data resides (CPU, CUDA, etc.)
+  Device device_;
 };
 
 /**
@@ -247,6 +266,16 @@ ssize_t compute_numel(
     const ::executorch::runtime::etensor::TensorImpl::SizesType *sizes,
     ssize_t dim);
 
+/**
+ * Compute the number of elements based on the sizes of a tensor.
+ * Returns Error::InvalidArgument if any intermediate multiplication would
+ * overflow ssize_t, or if a size is negative. Prefer this over compute_numel()
+ * for paths that can propagate an Error upward.
+ */
+::executorch::runtime::Result<ssize_t>
+safe_numel(const ::executorch::runtime::etensor::TensorImpl::SizesType *sizes,
+           ssize_t dim);
+
 /// Appropriate format specifier for the result of calling
 /// size(). Must be used instead of using zd directly to support ATen
 /// mode.
@@ -276,6 +305,7 @@ namespace executor {
 // TODO(T197294990): Remove these deprecated aliases once all users have moved
 // to the new `::executorch` namespaces.
 using ::executorch::runtime::etensor::compute_numel;
+using ::executorch::runtime::etensor::safe_numel;
 using ::executorch::runtime::etensor::TensorImpl;
 } // namespace executor
 } // namespace torch

package/third-party/include/executorch/runtime/executor/method.h

@@ -23,6 +23,7 @@
 #include <executorch/runtime/executor/memory_manager.h>
 #include <executorch/runtime/executor/merged_data_map.h>
 #include <executorch/runtime/executor/method_meta.h>
+#include <executorch/runtime/kernel/operator_registry.h>
 #include <executorch/runtime/platform/compiler.h>
 
 // Forward declare flatbuffer types. This is a public header and must not
@@ -77,7 +78,7 @@ public:
         merged_data_map_(std::move(rhs.merged_data_map_)),
         external_constants_(rhs.external_constants_),
         n_external_constants_(rhs.n_external_constants_),
-        init_state_(rhs.init_state_) {
+        kernel_registry_(rhs.kernel_registry_), init_state_(rhs.init_state_) {
     // Required: clear out fields that the dtor looks at, so that we don't free
     // anything twice.
     rhs.n_value_ = 0;
@@ -323,13 +324,15 @@ private:
   };
 
   Method(const Program *program, MemoryManager *memory_manager,
-         EventTracer *event_tracer, MemoryAllocator *temp_allocator)
+         EventTracer *event_tracer, MemoryAllocator *temp_allocator,
+         Span<const Kernel> kernel_registry = {})
       : step_state_(), program_(program), memory_manager_(memory_manager),
         temp_allocator_(temp_allocator), serialization_plan_(nullptr),
         event_tracer_(event_tracer), n_value_(0), values_(nullptr),
         input_set_(nullptr), n_delegate_(0), delegates_(nullptr), n_chains_(0),
         chains_(nullptr), merged_data_map_(nullptr),
         external_constants_(nullptr), n_external_constants_(0),
+        kernel_registry_(kernel_registry),
         init_state_(InitializationState::Uninitialized) {}
 
   /// Static factory used by Program.
@@ -337,7 +340,8 @@ private:
   load(executorch_flatbuffer::ExecutionPlan *s_plan, const Program *program,
        MemoryManager *memory_manager, EventTracer *event_tracer,
        const NamedDataMap *named_data_map,
-       const LoadBackendOptionsMap *backend_options = nullptr);
+       const LoadBackendOptionsMap *backend_options = nullptr,
+       Span<const Kernel> kernel_registry = {});
 
   /**
    * Initialize the method from its serialized representation.
@@ -382,6 +386,8 @@ private:
   NamedData *external_constants_;
   size_t n_external_constants_ = 0;
 
+  Span<const Kernel> kernel_registry_;
+
   InitializationState init_state_;
 
   /**

package/third-party/include/executorch/runtime/executor/method_meta.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/core/portable_type/device.h>
 #include <executorch/runtime/core/result.h>
 #include <executorch/runtime/core/span.h>
 #include <executorch/runtime/core/tag.h>
@@ -230,6 +231,19 @@ public:
    */
   Result<int64_t> memory_planned_buffer_size(size_t index) const;
 
+  /**
+   * Get the device placement for the specified memory-planned buffer.
+   *
+   * For CPU-only programs (no non_const_buffer_device in the PTE), all buffers
+   * default to Device{CPU, 0}. For programs with device annotations, returns
+   * the device type and index that the buffer should be allocated on.
+   *
+   * @param[in] index The index of the buffer to look up (0-based, same
+   *     indexing as memory_planned_buffer_size()).
+   * @returns The Device on success, or an error on failure.
+   */
+  Result<etensor::Device> memory_planned_buffer_device(size_t index) const;
+
   /**
    * Check to see if a backend is used in this method.
    *

package/third-party/include/executorch/runtime/executor/platform_memory_allocator.h

@@ -12,6 +12,7 @@
 #include <cstdint>
 #include <stdio.h>
 
+#include <c10/util/safe_numerics.h>
 #include <executorch/runtime/core/memory_allocator.h>
 #include <executorch/runtime/platform/log.h>
 #include <executorch/runtime/platform/platform.h>
@@ -46,8 +47,17 @@ public:
       return nullptr;
     }
 
-    // Allocate enough memory for the node, the data and the alignment bump.
-    size_t alloc_size = sizeof(AllocationNode) + size + alignment;
+    // Check for overflow before computing total allocation size.
+    // Allocate enough for the node, data, and alignment bump (at most
+    // alignment - 1 extra bytes to align the data pointer).
+    size_t alloc_size = 0;
+    if (c10::add_overflows(sizeof(AllocationNode), size, &alloc_size) ||
+        c10::add_overflows(alloc_size, alignment - 1, &alloc_size)) {
+      ET_LOG(Error, "Allocation size overflow: size %zu, alignment %zu", size,
+             alignment);
+      return nullptr;
+    }
+
     void *node_memory = runtime::pal_allocate(alloc_size);
 
     // If allocation failed, log message and return nullptr.

package/third-party/include/executorch/runtime/executor/program.h

@@ -21,6 +21,7 @@
 #include <executorch/runtime/executor/method.h>
 #include <executorch/runtime/executor/method_meta.h>
 #include <executorch/runtime/executor/pte_data_map.h>
+#include <executorch/runtime/kernel/operator_registry.h>
 #include <executorch/runtime/platform/compiler.h>
 
 // Forward declare flatbuffer types. This is a public header and must not
@@ -148,7 +149,8 @@ public:
   load_method(const char *method_name, MemoryManager *memory_manager,
               EventTracer *event_tracer = nullptr,
               const NamedDataMap *named_data_map = nullptr,
-              const LoadBackendOptionsMap *backend_options = nullptr) const;
+              const LoadBackendOptionsMap *backend_options = nullptr,
+              Span<const Kernel> kernel_registry = {}) const;
 
   /**
    * Gathers metadata for the named method.

package/third-party/include/executorch/runtime/executor/tensor_parser.h

@@ -92,8 +92,12 @@ parseListOptionalType(const flatbuffers::Vector<int32_t> *value_indices,
       ET_CHECK_OR_RETURN_ERROR(
           index >= 0 && static_cast<size_t>(index) < values_len, InvalidProgram,
           "Invalid value index %" PRId32 " for ListOptional", index);
+      auto optional_result = values[index].tryToOptional<T>();
+      if (!optional_result.ok()) {
+        return optional_result.error();
+      }
       new (&optional_tensor_list[output_idx])
-          std::optional<T>(values[index].toOptional<T>());
+          std::optional<T>(std::move(optional_result.get()));
       evalp_list[output_idx] = &values[static_cast<size_t>(index)];
     }
     output_idx++;

package/third-party/include/executorch/runtime/kernel/operator_registry.h

@@ -216,6 +216,15 @@ bool registry_has_op_function(const char *name,
 get_op_function_from_registry(const char *name,
                               Span<const TensorMeta> meta_list = {});
 
+/**
+ * Returns the operator with a given name and TensorMeta list from the provided
+ * kernel list instead of the global registry.
+ */
+::executorch::runtime::Result<OpFunction>
+get_op_function_from_registry(const char *name,
+                              Span<const TensorMeta> meta_list,
+                              Span<const Kernel> kernel_list);
+
 /**
  * Returns all registered kernels.
  */