react-native-executorch 0.5.15 → 0.6.0-nightly-897eae9-20251213

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

@@ -0,0 +1,142 @@
+/*
+ * 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/named_data_map.h>
+
+namespace executorch {
+namespace ET_RUNTIME_NAMESPACE {
+namespace internal {
+
+/**
+ * A NamedDataMap implementation that wraps other NamedDataMaps.
+ */
+class MergedDataMap final : public NamedDataMap {
+public:
+  /**
+   * Creates a new NamedDataMap that wraps two other data maps.
+   *
+   * @param[in] first The first NamedDataMap to merge.
+   * @param[in] second The second NamedDataMap to merge.
+   * Note: the data maps must outlive the MergedDataMap instance.
+   */
+  static Result<MergedDataMap> load(const NamedDataMap *first,
+                                    const NamedDataMap *second) {
+    ET_CHECK_OR_RETURN_ERROR(first != nullptr && second != nullptr,
+                             InvalidArgument, "Input data map is null.");
+
+    // Check for duplicate keys.
+    for (uint32_t k = 0; k < first->get_num_keys().get(); k++) {
+      const auto key = first->get_key(k).get();
+      const auto error = second->get_tensor_layout(key).error();
+      // TODO(lfq): add API to check if key exists.
+      ET_CHECK_OR_RETURN_ERROR(error == Error::NotFound ||
+                                   error == Error::NotImplemented,
+                               InvalidArgument, "Duplicate key %s.", key);
+    }
+    return MergedDataMap(first, second);
+  }
+
+  /**
+   * Retrieve the tensor_layout for the specified key.
+   *
+   * @param[in] key The name of the tensor to get metadata on.
+   *
+   * @return Error::NotFound if the key is not present.
+   */
+  ET_NODISCARD
+  Result<const TensorLayout>
+  get_tensor_layout(executorch::aten::string_view key) const override {
+    auto layout = first_->get_tensor_layout(key);
+    if (layout.ok()) {
+      return layout.get();
+    }
+    if (layout.error() != Error::NotFound) {
+      return layout.error();
+    }
+    return second_->get_tensor_layout(key);
+  }
+
+  /**
+   * Retrieve read-only data for the specified key.
+   *
+   * @param[in] key The name of the tensor to get data on.
+   *
+   * @return error if the key is not present or data cannot be loaded.
+   */
+  ET_NODISCARD
+  Result<FreeableBuffer>
+  get_data(executorch::aten::string_view key) const override {
+    auto data = first_->get_data(key);
+    if (data.error() != Error::NotFound) {
+      return data;
+    }
+    return second_->get_data(key);
+  }
+
+  /**
+   * Loads the data of the specified tensor into the provided buffer.
+   * Not used in the MergedDataMap.
+   *
+   * @param[in] key The name of the tensor to get the data of.
+   * @param[in] buffer The buffer to load data into. Must point to at least
+   * `size` bytes of memory.
+   * @param[in] size The number of bytes to load.
+   *
+   * @returns an Error indicating if the load was successful.
+   */
+  ET_NODISCARD Error load_data_into(ET_UNUSED executorch::aten::string_view key,
+                                    ET_UNUSED void *buffer,
+                                    ET_UNUSED size_t size) const override {
+    return Error::NotImplemented;
+  }
+
+  /**
+   * @returns The number of keys in the map.
+   */
+  ET_NODISCARD Result<uint32_t> get_num_keys() const override {
+    return first_->get_num_keys().get() + second_->get_num_keys().get();
+  }
+
+  /**
+   * @returns The key at the specified index, error if index out of bounds.
+   */
+  ET_NODISCARD Result<const char *> get_key(uint32_t index) const override {
+    uint32_t total_num_keys = get_num_keys().get();
+    ET_CHECK_OR_RETURN_ERROR(index < total_num_keys, InvalidArgument,
+                             "Index %" PRIu32 " out of range of size %" PRIu32,
+                             index, total_num_keys);
+
+    if (index < first_->get_num_keys().get()) {
+      return first_->get_key(index);
+    } else {
+      return second_->get_key(index - first_->get_num_keys().get());
+    }
+  }
+
+  MergedDataMap(MergedDataMap &&) noexcept = default;
+
+  ~MergedDataMap() override = default;
+
+private:
+  MergedDataMap(const NamedDataMap *first, const NamedDataMap *second)
+      : first_{first}, second_{second} {}
+
+  // Not copyable or assignable.
+  MergedDataMap(const MergedDataMap &rhs) = delete;
+  MergedDataMap &operator=(MergedDataMap &&rhs) noexcept = delete;
+  MergedDataMap &operator=(const MergedDataMap &rhs) = delete;
+
+  const NamedDataMap *first_;
+  const NamedDataMap *second_;
+};
+
+} // namespace internal
+} // namespace ET_RUNTIME_NAMESPACE
+} // namespace executorch

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

@@ -20,6 +20,7 @@
 #include <executorch/runtime/core/named_data_map.h>
 #include <executorch/runtime/core/span.h>
 #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/platform/compiler.h>
 
@@ -47,7 +48,7 @@ class Program;
 class BackendDelegate;
 struct Chain;
 class KernelRuntimeContext;
-using OpFunction = void (*)(KernelRuntimeContext &, EValue **);
+using OpFunction = void (*)(KernelRuntimeContext &, Span<EValue *>);
 /// A list of pointers into the master values table that together compose the
 /// argument list for a single instruction
 using InstructionArgs = Span<EValue *>;
@@ -69,17 +70,22 @@ public:
         temp_allocator_(rhs.temp_allocator_),
         serialization_plan_(rhs.serialization_plan_),
         event_tracer_(rhs.event_tracer_), n_value_(rhs.n_value_),
-        values_(rhs.values_), n_delegate_(rhs.n_delegate_),
-        delegates_(rhs.delegates_), n_chains_(rhs.n_chains_),
-        chains_(rhs.chains_), external_constants_(rhs.external_constants_),
+        values_(rhs.values_), input_set_(rhs.input_set_),
+        n_delegate_(rhs.n_delegate_), delegates_(rhs.delegates_),
+        n_chains_(rhs.n_chains_), chains_(rhs.chains_),
+        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_) {
     // Required: clear out fields that the dtor looks at, so that we don't free
     // anything twice.
     rhs.n_value_ = 0;
     rhs.values_ = nullptr;
+    rhs.input_set_ = nullptr;
     rhs.n_delegate_ = 0;
     rhs.delegates_ = nullptr;
+
+    rhs.merged_data_map_ = nullptr;
     rhs.n_external_constants_ = 0;
     rhs.external_constants_ = nullptr;
 
@@ -172,6 +178,9 @@ public:
   ET_NODISCARD Error get_outputs(EValue *output_evalues, size_t length);
 
   /**
+   * DEPRECATED: Use MethodMeta instead to access metadata, and set_input to
+   * update Method inputs.
+   *
    * Copies the method's inputs into the provided array.
    *
    * WARNING: The input contains shallow copies of internal tensor inputs.
@@ -185,7 +194,8 @@ public:
    *
    * @returns Error::Ok on success, non-Ok on failure.
    */
-  ET_NODISCARD Error get_inputs(EValue *input_evalues, size_t length);
+  ET_DEPRECATED ET_NODISCARD Error get_inputs(EValue *input_evalues,
+                                              size_t length);
 
   /**
    *
@@ -216,7 +226,7 @@ public:
    * @retval non-Ok step failed
    * @retval Error::EndOfMethod method finished executing successfully
    */
-  ET_EXPERIMENTAL ET_NODISCARD Error step();
+  ET_NODISCARD Error step();
 
   /// DEPRECATED: Use `step()` instead.
   ET_DEPRECATED ET_NODISCARD Error experimental_step();
@@ -230,7 +240,7 @@ public:
    *     the end of the Method. This means it is not possible to recover a
    *     Method that failed mid-execution.
    */
-  ET_EXPERIMENTAL ET_NODISCARD Error reset_execution();
+  ET_NODISCARD Error reset_execution();
 
   /// DEPRECATED: Use `reset_execution()` instead.
   ET_DEPRECATED ET_NODISCARD Error experimental_reset_execution();
@@ -297,7 +307,8 @@ private:
       : step_state_(), program_(program), memory_manager_(memory_manager),
         temp_allocator_(temp_allocator), serialization_plan_(nullptr),
         event_tracer_(event_tracer), n_value_(0), values_(nullptr),
-        n_delegate_(0), delegates_(nullptr), n_chains_(0), chains_(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),
         init_state_(InitializationState::Uninitialized) {}
 
@@ -337,6 +348,7 @@ private:
 
   size_t n_value_;
   EValue *values_;
+  bool *input_set_;
 
   size_t n_delegate_;
   BackendDelegate *delegates_;
@@ -344,6 +356,7 @@ private:
   size_t n_chains_;
   Chain *chains_;
 
+  internal::MergedDataMap *merged_data_map_;
   NamedData *external_constants_;
   size_t n_external_constants_ = 0;
 

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

@@ -77,9 +77,27 @@ private:
   friend class MethodMeta;
   friend class testing::TensorInfoTestFriend;
 
+  /**
+   * Create a TensorInfo instance.
+   *
+   * @param[in] sizes The sizes of the tensor.
+   * @param[in] dim_order The dim order of the tensor.
+   * @param[in] scalar_type The scalar type of the tensor.
+   * @param[in] is_memory_planned Whether the tensor's memory was planned.
+   * @param[in] name The fully qualified name of the tensor.
+   * @returns A Result containing the TensorInfo on success, or an error on
+   * failure.
+   */
+  static Result<TensorInfo> create(Span<const int32_t> sizes,
+                                   Span<const uint8_t> dim_order,
+                                   executorch::aten::ScalarType scalar_type,
+                                   const bool is_memory_planned,
+                                   std::string_view name);
+
   TensorInfo(Span<const int32_t> sizes, Span<const uint8_t> dim_order,
              executorch::aten::ScalarType scalar_type,
-             const bool is_memory_planned, std::string_view name);
+             const bool is_memory_planned, std::string_view name,
+             size_t nbytes);
 
   /**
    * The sizes of the tensor.
@@ -241,7 +259,7 @@ public:
    *
    * @returns The number of instructions.
    */
-  ET_EXPERIMENTAL size_t num_instructions() const;
+  size_t num_instructions() const;
 
   /**
    * DEPRECATED: Use num_memory_planned_buffers() instead.

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

@@ -8,12 +8,6 @@
 
 #pragma once
 
-#ifdef __GNUC__
-// Disable -Wdeprecated-declarations, as some builds use 'Werror'.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 #include <cinttypes>
 #include <cstdint>
 #include <optional>
@@ -313,7 +307,3 @@ namespace executor {
 using ::executorch::ET_RUNTIME_NAMESPACE::Program;
 } // namespace executor
 } // namespace torch
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif

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

@@ -40,7 +40,7 @@ namespace executorch {
 namespace ET_RUNTIME_NAMESPACE {
 
 class KernelRuntimeContext; // Forward declaration
-using OpFunction = void (*)(KernelRuntimeContext &, EValue **);
+using OpFunction = void (*)(KernelRuntimeContext &, Span<EValue *>);
 
 /**
  * Dtype and dim order metadata for a Tensor argument to an operator.

package/third-party/include/executorch/runtime/platform/compiler.h

@@ -149,8 +149,10 @@
 // As of G3 RJ-2024.3 toolchain, zu format specifier is not supported for Xtensa
 #if defined(__XTENSA__)
 #define ET_PRIsize_t "lu"
+#define ET_PRIssize_t "ld"
 #else
 #define ET_PRIsize_t "zu"
+#define ET_PRIssize_t "zd"
 #endif
 
 // Whether the compiler supports GNU statement expressions.

package/third-party/include/executorch/schema/extended_header.h

@@ -22,7 +22,8 @@ namespace runtime {
 struct ExtendedHeader {
   /**
    * To find the header, callers should provide at least this many bytes of the
-   * head of the serialized Program data.
+   * head of the serialized Program data. Keep this in sync with NUM_HEAD_BYTES
+   * in //executorch/exir/_serialize/program.py
    */
   static constexpr size_t kNumHeadBytes = 64;
 
@@ -70,6 +71,14 @@ struct ExtendedHeader {
    * is present.
    */
   uint64_t segment_base_offset;
+
+  /**
+   * The size of all the segment data, in bytes. Zero if:
+   * - no segment is present
+   * - the segment_data_size field doesn't exist in the header - the case for
+   *   older PTE files.
+   */
+  uint64_t segment_data_size;
 };
 
 } // namespace runtime

package/third-party/include/torch/headeronly/macros/Export.h

@@ -1,6 +1,13 @@
 #define C10_USING_CUSTOM_GENERATED_MACROS
 #pragma once
 
+#ifndef C10_MACROS_EXPORT_H_
+#define C10_MACROS_EXPORT_H_
+
+#ifndef C10_USING_CUSTOM_GENERATED_MACROS
+#include <torch/headeronly/macros/cmake_macros.h>
+#endif // C10_USING_CUSTOM_GENERATED_MACROS
+
 /* Header file to define the common scaffolding for exported symbols.
  *
  * Export is by itself a quite tricky situation to deal with, and if you are
@@ -86,3 +93,62 @@
 #else
 #define C10_API C10_IMPORT
 #endif
+
+// This one is being used by libtorch.so
+#ifdef CAFFE2_BUILD_MAIN_LIB
+#define TORCH_API C10_EXPORT
+#else
+#define TORCH_API C10_IMPORT
+#endif
+
+// You may be wondering why we have TORCH_CUDA_CPP_API and TORCH_CUDA_CU_API
+// belonging to the same library instead of just one TORCH_CUDA_API. Well, it
+// can indeed just be one TORCH_CUDA_API (and used to be)! TORCH_CUDA_CPP_API
+// and TORCH_CUDA_CU_API are artifacts of when we needed a split build to
+// avoid relocation marker linking errors. The context is as follows:
+//
+// Once upon a time, there _was_ only TORCH_CUDA_API. All was happy until we
+// tried to compile PyTorch for CUDA 11.1, which ran into relocation marker
+// issues when linking big binaries.
+// (https://github.com/pytorch/pytorch/issues/39968) We had two choices:
+//    (1) Stop supporting so many GPU architectures
+//    (2) Do something else
+// We chose #2 and decided to split the behemoth that was torch_cuda into two
+// smaller libraries, one with most of the core kernel functions (torch_cuda_cu)
+// and the other that had..well..everything else (torch_cuda_cpp). The idea was
+// this: instead of linking our static libraries (like the hefty
+// libcudnn_static.a) with another huge library, torch_cuda, and run into pesky
+// relocation marker issues, we could link our static libraries to a smaller
+// part of torch_cuda (torch_cuda_cpp) and avoid the issues.
+
+// libtorch_cuda.so (where torch_cuda_cu and torch_cuda_cpp are a part of the
+// same api)
+#ifdef TORCH_CUDA_BUILD_MAIN_LIB
+#define TORCH_CUDA_CPP_API C10_EXPORT
+#define TORCH_CUDA_CU_API C10_EXPORT
+#else
+#define TORCH_CUDA_CPP_API C10_IMPORT
+#define TORCH_CUDA_CU_API C10_IMPORT
+#endif
+
+#if defined(TORCH_HIP_BUILD_MAIN_LIB)
+#define TORCH_HIP_CPP_API C10_EXPORT
+#define TORCH_HIP_API C10_EXPORT
+#else
+#define TORCH_HIP_CPP_API C10_IMPORT
+#define TORCH_HIP_API C10_IMPORT
+#endif
+
+#if defined(TORCH_XPU_BUILD_MAIN_LIB)
+#define TORCH_XPU_API C10_EXPORT
+#else
+#define TORCH_XPU_API C10_IMPORT
+#endif
+
+// Enums only need to be exported on windows for non-CUDA files
+#if defined(_WIN32) && defined(__CUDACC__)
+#define C10_API_ENUM C10_API
+#else
+#define C10_API_ENUM
+#endif
+#endif // C10_MACROS_EXPORT_H_