react-native-executorch 0.9.0 → 0.9.1

package/src/modules/natural_language_processing/LLMModule.ts

@@ -3,6 +3,7 @@ import { Logger } from '../../common/Logger';
 import { parseUnknownError } from '../../errors/errorUtils';
 import { ResourceSource } from '../../types/common';
 import {
+  AudioConfig,
   LLMCapability,
   LLMConfig,
   LLMModelName,
@@ -51,6 +52,7 @@ export class LLMModule {
       tokenizerSource: ResourceSource;
       tokenizerConfigSource: ResourceSource;
       capabilities?: readonly LLMCapability[];
+      audioConfig?: AudioConfig;
     },
     onDownloadProgress: (progress: number) => void = () => {},
     tokenCallback?: (token: string) => void,
@@ -59,10 +61,14 @@ export class LLMModule {
     const instance = new LLMModule({ tokenCallback, messageHistoryCallback });
     try {
       await instance.controller.load({
-        modelSource: namedSources.modelSource,
-        tokenizerSource: namedSources.tokenizerSource,
-        tokenizerConfigSource: namedSources.tokenizerConfigSource,
-        capabilities: namedSources.capabilities,
+        model: {
+          modelName: namedSources.modelName,
+          modelSource: namedSources.modelSource,
+          tokenizerSource: namedSources.tokenizerSource,
+          tokenizerConfigSource: namedSources.tokenizerConfigSource,
+          capabilities: namedSources.capabilities,
+          audioConfig: namedSources.audioConfig,
+        },
         onDownloadProgressCallback: onDownloadProgress,
       });
       return instance;
@@ -140,10 +146,15 @@ export class LLMModule {
    * If you want a simple chat with model the consider using `sendMessage`
    * @param input - Raw input string containing the prompt and conversation history.
    * @param imagePaths - Optional array of local image paths for multimodal inference. Each entry may be either `file:///absolute/path` or `/absolute/path` — the controller normalizes the path before passing it to native code.
+   * @param audioWaveforms - Optional array of 16kHz waveforms of audio recordings for multimodal inference.
    * @returns The generated response as a string.
    */
-  async forward(input: string, imagePaths?: string[]): Promise<string> {
-    return await this.controller.forward(input, imagePaths);
+  async forward(
+    input: string,
+    imagePaths?: string[],
+    audioWaveforms?: Float32Array[]
+  ): Promise<string> {
+    return await this.controller.forward(input, imagePaths, audioWaveforms);
   }
 
   /**
@@ -162,12 +173,12 @@ export class LLMModule {
    * After model responds it will call `messageHistoryCallback()` containing both user message and model response.
    * It also returns them.
    * @param message - The message string to send.
-   * @param media - Optional media object containing a local image path for multimodal models.
+   * @param media - Optional media object containing a local image path or 16kHz waveform of an audio recording for multimodal models.
    * @returns - Updated message history including the new user message and model response.
    */
   async sendMessage(
     message: string,
-    media?: { imagePath?: string }
+    media?: { imagePath?: string; audioBuffer?: Float32Array }
   ): Promise<Message[]> {
     await this.controller.sendMessage(message, media);
     return this.controller.messageHistory;

package/src/types/llm.ts

@@ -5,20 +5,23 @@ import { ResourceSource } from './common';
  * Capabilities a multimodal LLM can have.
  * @category Types
  */
-export type LLMCapability = 'vision';
+export type LLMCapability = 'vision' | 'audio';
 
 /**
  * Derives the media argument shape for `sendMessage` from a capabilities tuple.
  * @category Types
  */
 export type MediaArg<C extends readonly LLMCapability[]> =
-  'vision' extends C[number] ? { imagePath?: string } : object;
+  ('vision' extends C[number] ? { imagePath?: string } : object) &
+    ('audio' extends C[number] ? { audioBuffer?: Float32Array } : object);
 
 /**
  * Union of all built-in LLM model names.
  * @category Types
  */
 export type LLMModelName =
+  | 'gemma4-e2b'
+  | 'gemma4-e2b-multimodal'
   | 'llama-3.2-3b'
   | 'llama-3.2-3b-qlora'
   | 'llama-3.2-3b-spinquant'
@@ -62,43 +65,63 @@ export type LLMModelName =
   | 'bielik-v3.0-1.5b'
   | 'bielik-v3.0-1.5b-quantized';
 
+/**
+ * Audio soft-token expansion constants for audio_encoder.
+ * @category Types
+ */
+export interface AudioConfig {
+  samplesPerBlock: number;
+  tokensPerBlock: number;
+}
+
+/**
+ * Properties defining LLMModel.
+ * @category Types
+ */
+export interface LLMModel {
+  /**
+   * The built-in model name (e.g. `'llama-3.2-3b'`). Used for telemetry and hook reload triggers.
+   * Pass one of the pre-built LLM constants (e.g. `LLAMA3_2_3B`) to populate all required fields.
+   */
+  modelName: LLMModelName;
+  /**
+   * `ResourceSource` that specifies the location of the model binary.
+   */
+  modelSource: ResourceSource;
+  /**
+   * `ResourceSource` pointing to the JSON file which contains the tokenizer.
+   */
+  tokenizerSource: ResourceSource;
+  /**
+   * `ResourceSource` pointing to the JSON file which contains the tokenizer config.
+   */
+  tokenizerConfigSource: ResourceSource;
+  /**
+   * Optional list of modality capabilities the model supports.
+   * Determines the type of the `media` argument in `sendMessage`.
+   * Example: `['vision']` enables `sendMessage(text, { imagePath })`.
+   */
+  capabilities?: readonly LLMCapability[];
+  /**
+   * Recommended default generation settings, typically copied from the
+   * upstream `generation_config.json` or the model card. Applied automatically
+   * after the native module loads and before any user `configure()` call,
+   * so callers only need to override the values they want to change.
+   */
+  generationConfig?: GenerationConfig;
+  /**
+   * Defines config for audio input modality for multimodal LLMs.
+   * `capabilities` must include 'audio'.
+   */
+  audioConfig?: AudioConfig;
+}
+
 /**
  * Properties for initializing and configuring a Large Language Model (LLM) instance.
  * @category Types
  */
 export interface LLMProps {
-  model: {
-    /**
-     * The built-in model name (e.g. `'llama-3.2-3b'`). Used for telemetry and hook reload triggers.
-     * Pass one of the pre-built LLM constants (e.g. `LLAMA3_2_3B`) to populate all required fields.
-     */
-    modelName: LLMModelName;
-    /**
-     * `ResourceSource` that specifies the location of the model binary.
-     */
-    modelSource: ResourceSource;
-    /**
-     * `ResourceSource` pointing to the JSON file which contains the tokenizer.
-     */
-    tokenizerSource: ResourceSource;
-    /**
-     * `ResourceSource` pointing to the JSON file which contains the tokenizer config.
-     */
-    tokenizerConfigSource: ResourceSource;
-    /**
-     * Optional list of modality capabilities the model supports.
-     * Determines the type of the `media` argument in `sendMessage`.
-     * Example: `['vision']` enables `sendMessage(text, { imagePath })`.
-     */
-    capabilities?: readonly LLMCapability[];
-    /**
-     * Recommended default generation settings, typically copied from the
-     * upstream `generation_config.json` or the model card. Applied automatically
-     * after the native module loads and before any user `configure()` call,
-     * so callers only need to override the values they want to change.
-     */
-    generationConfig?: GenerationConfig;
-  };
+  model: LLMModel;
   /**
    * Boolean that can prevent automatic model loading (and downloading the data if you load it for the first time) after running the hook.
    */
@@ -289,6 +312,12 @@ export interface Message {
    * controller normalizes the path before passing it to native code.
    */
   mediaPath?: string;
+  /**
+   * Optional fp32 mono 16 kHz PCM buffer. Only valid on `user` messages for
+   * models with the `'audio'` capability. The controller forwards it to the
+   * native `generateMultimodal` path.
+   */
+  audioWaveform?: Float32Array;
 }
 
 /**
@@ -386,6 +415,7 @@ export interface ContextStrategy {
 export const SPECIAL_TOKENS = {
   BOS_TOKEN: 'bos_token',
   EOS_TOKEN: 'eos_token',
+  EOT_TOKEN: 'eot_token',
   UNK_TOKEN: 'unk_token',
   SEP_TOKEN: 'sep_token',
   PAD_TOKEN: 'pad_token',

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

@@ -6,6 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#import "ExecuTorchBackendOption.h"
+#import "ExecuTorchBackendOptionsMap.h"
 #import "ExecuTorchError.h"
 #import "ExecuTorchLog.h"
 #import "ExecuTorchModule.h"

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

@@ -6,6 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#import "ExecuTorchBackendOption.h"
+#import "ExecuTorchBackendOptionsMap.h"
 #import "ExecuTorchValue.h"
 
 NS_ASSUME_NONNULL_BEGIN
@@ -198,6 +200,37 @@ NS_SWIFT_NAME(Module)
  */
 - (BOOL)load:(NSError **)error;
 
+/**
+ * Loads the module's program with per-delegate backend options.
+ *
+ * The receiver retains @c options for as long as the underlying program
+ * references it (lifetime tracked via ARC).
+ *
+ * @param options A `ExecuTorchBackendOptionsMap` containing per-delegate
+ *        load-time configuration, built once via
+ *        `[ExecuTorchBackendOptionsMap mapWithOptions:error:]`.
+ * @param verification The verification level to apply when loading the program.
+ * @param error A pointer to an NSError pointer that will be set if an error
+ * occurs.
+ * @return YES if the program was successfully loaded; otherwise, NO.
+ */
+- (BOOL)loadWithOptions:(ExecuTorchBackendOptionsMap *)options
+           verification:(ExecuTorchVerification)verification
+                  error:(NSError **)error NS_REFINED_FOR_SWIFT;
+
+/**
+ * Loads the module's program with per-delegate backend options using minimal
+ * verification.
+ *
+ * @param options A `ExecuTorchBackendOptionsMap` containing per-delegate
+ *        load-time configuration.
+ * @param error A pointer to an NSError pointer that will be set if an error
+ * occurs.
+ * @return YES if the program was successfully loaded; otherwise, NO.
+ */
+- (BOOL)loadWithOptions:(ExecuTorchBackendOptionsMap *)options
+                  error:(NSError **)error NS_REFINED_FOR_SWIFT;
+
 /**
  * Checks if the module is loaded.
  *
@@ -215,6 +248,19 @@ NS_SWIFT_NAME(Module)
 - (BOOL)loadMethod:(NSString *)methodName
              error:(NSError **)error NS_SWIFT_NAME(load(_:));
 
+/**
+ * Loads a specific method from the program with per-delegate backend options.
+ *
+ * @param methodName A string representing the name of the method to load.
+ * @param options A `ExecuTorchBackendOptionsMap` containing per-delegate
+ *        load-time configuration.
+ * @param error A pointer to an NSError pointer that is set if an error occurs.
+ * @return YES if the method was successfully loaded; otherwise, NO.
+ */
+- (BOOL)loadMethod:(NSString *)methodName
+           options:(ExecuTorchBackendOptionsMap *)options
+             error:(NSError **)error NS_REFINED_FOR_SWIFT;
+
 /**
  * Checks if a specific method is loaded.
  *

package/third-party/include/executorch/extension/data_loader/buffer_data_loader.h

@@ -36,9 +36,10 @@ public:
        ET_UNUSED const DataLoader::SegmentInfo &segment_info) const override {
     size_t total_size;
     bool overflow = c10::add_overflows(offset, size, &total_size);
-    ET_CHECK_OR_RETURN_ERROR(!overflow && total_size <= size_, InvalidArgument,
-                             "offset %zu + size %zu > size_ %zu", offset, size,
-                             size_);
+    ET_CHECK_OR_RETURN_ERROR(
+        !overflow && total_size <= size_, InvalidArgument,
+        "offset %zu + size %zu > size_ %zu, or overflow detected", offset, size,
+        size_);
     return executorch::runtime::FreeableBuffer(data_ + offset, size,
                                                /*free_fn=*/nullptr);
   }

package/third-party/include/executorch/extension/data_loader/mman.h

@@ -17,6 +17,7 @@
 
 #ifndef _WIN32
 
+#include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
@@ -41,6 +42,34 @@ ET_INLINE off_t get_mmap_offset(size_t offset) {
   return static_cast<off_t>(offset);
 }
 
+/**
+ * Hint the kernel to prefetch pages eagerly and to optimize for sequential
+ * reads. Intended to reduce page-fault stutter during model initialization
+ * when the caller does not want to mlock the pages into RAM.
+ */
+ET_INLINE void madvise_pages_willneed_sequential(void *addr, size_t len) {
+  ::madvise(addr, len, MADV_WILLNEED);
+  ::madvise(addr, len, MADV_SEQUENTIAL);
+}
+
+/**
+ * On Apple platforms, schedule kernel read-ahead on the file descriptor itself
+ * via fcntl(F_RDADVISE). This is more aggressive than madvise for cold starts:
+ * it brings pages into the unified buffer cache so first-touch faults are
+ * serviced from RAM instead of storage. No-op on non-Apple POSIX platforms.
+ */
+ET_INLINE void fcntl_rdadvise_apple(int fd, size_t file_size) {
+#if defined(__APPLE__)
+  struct radvisory advice;
+  advice.ra_offset = 0;
+  advice.ra_count = static_cast<int>(file_size);
+  ::fcntl(fd, F_RDADVISE, &advice);
+#else
+  (void)fd;
+  (void)file_size;
+#endif
+}
+
 #else
 
 #define NOMINMAX
@@ -78,4 +107,21 @@ ET_INLINE uint64_t get_mmap_offset(size_t offset) {
   return static_cast<uint64_t>(offset);
 }
 
+/**
+ * No-op on Windows: there is no direct equivalent to madvise(MADV_WILLNEED |
+ * MADV_SEQUENTIAL) and the existing mman_windows shim does not implement one.
+ */
+ET_INLINE void madvise_pages_willneed_sequential(void *addr, size_t len) {
+  (void)addr;
+  (void)len;
+}
+
+/**
+ * No-op on Windows: F_RDADVISE is an Apple-specific fcntl command.
+ */
+ET_INLINE void fcntl_rdadvise_apple(int fd, size_t file_size) {
+  (void)fd;
+  (void)file_size;
+}
+
 #endif

package/third-party/include/executorch/extension/data_loader/mmap_data_loader.h

@@ -38,6 +38,10 @@ public:
     UseMlock,
     /// Call `mlock()` on loaded pages, ignoring errors if it fails.
     UseMlockIgnoreErrors,
+    /// Use madvise(MADV_WILLNEED | MADV_SEQUENTIAL) instead of mlock.
+    /// Tells the kernel to prefetch pages eagerly and optimize for
+    /// sequential reads, without pinning them in RAM.
+    UseMadvise,
   };
 
   /**

package/third-party/include/executorch/extension/data_loader/shared_ptr_data_loader.h

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <c10/util/safe_numerics.h>
 #include <executorch/runtime/core/data_loader.h>
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/result.h>
@@ -32,9 +33,12 @@ public:
   executorch::runtime::Result<executorch::runtime::FreeableBuffer>
   load(size_t offset, size_t size,
        ET_UNUSED const DataLoader::SegmentInfo &segment_info) const override {
-    ET_CHECK_OR_RETURN_ERROR(offset + size <= size_, InvalidArgument,
-                             "offset %zu + size %zu > size_ %zu", offset, size,
-                             size_);
+    size_t total_size;
+    bool overflow = c10::add_overflows(offset, size, &total_size);
+    ET_CHECK_OR_RETURN_ERROR(
+        !overflow && total_size <= size_, InvalidArgument,
+        "offset %zu + size %zu > size_ %zu, or overflow detected", offset, size,
+        size_);
     return executorch::runtime::FreeableBuffer(
         static_cast<uint8_t *>(data_.get()) + offset, size,
         /*free_fn=*/nullptr);

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

@@ -14,6 +14,8 @@
 #include <unordered_set>
 #include <vector>
 
+#include <executorch/runtime/backend/backend_options_map.h>
+#include <executorch/runtime/backend/options.h>
 #include <executorch/runtime/executor/program.h>
 
 #ifdef USE_ATEN_LIB
@@ -25,6 +27,7 @@
 namespace executorch {
 namespace extension {
 
+using ET_RUNTIME_NAMESPACE::Kernel;
 using ET_RUNTIME_NAMESPACE::Method;
 using ET_RUNTIME_NAMESPACE::MethodMeta;
 using ET_RUNTIME_NAMESPACE::NamedDataMap;
@@ -51,6 +54,8 @@ public:
     MmapUseMlock,
     /// Use memory locking and ignore errors.
     MmapUseMlockIgnoreErrors,
+    /// Use mmap with madvise(MADV_WILLNEED | MADV_SEQUENTIAL) hints.
+    MmapUseMadvise,
   };
 
   /**
@@ -182,9 +187,18 @@ public:
   /**
    * Loads the program with per-delegate runtime options.
    *
-   * @param[in] backend_options A LoadBackendOptionsMap containing per-delegate
-   * load-time configuration options. The caller must ensure this object
-   * outlives any methods loaded with these options.
+   * The Module deep-copies `backend_options` into internal storage, so the
+   * caller may release the input (and any backing BackendOption arrays its
+   * Spans referenced) immediately after this call returns. Future lazy
+   * `load_method` calls (e.g. triggered by `forward`) consume the
+   * Module-owned copy.
+   *
+   * Transactional: on failure, the previously-installed backend options
+   * (if any) are left in place; the input is not committed.
+   *
+   * @param[in] backend_options A LoadBackendOptionsMap containing
+   * per-delegate load-time configuration options. Deep-copied into the
+   * Module on success; not retained on failure.
    * @param[in] verification The type of verification to do before returning
    * success.
    *
@@ -195,6 +209,21 @@ public:
        const Program::Verification verification =
            Program::Verification::Minimal);
 
+  /**
+   * Returns the deep-copied LoadBackendOptionsMap most recently installed
+   * via `load(LoadBackendOptionsMap, ...)`. The returned reference is owned
+   * by the Module and remains valid until the next call to
+   * `load(LoadBackendOptionsMap, ...)` or until the Module is destroyed.
+   *
+   * If `load(LoadBackendOptionsMap, ...)` has never been called, returns a
+   * default-constructed (empty, `size() == 0`) map.
+   *
+   * @returns Const reference to the Module-owned LoadBackendOptionsMap.
+   */
+  inline const LoadBackendOptionsMap &backend_options() const {
+    return backend_options_map_;
+  }
+
   /**
    * Checks if the program is loaded.
    *
@@ -246,7 +275,8 @@ public:
   load_method(const std::string &method_name,
               runtime::HierarchicalAllocator *planned_memory = nullptr,
               torch::executor::EventTracer *event_tracer = nullptr,
-              const LoadBackendOptionsMap *backend_options = nullptr);
+              const LoadBackendOptionsMap *backend_options = nullptr,
+              std::vector<Kernel> kernel_registry = {});
 
   ET_DEPRECATED ET_NODISCARD runtime::Error inline load_method(
       const std::string &method_name,
@@ -294,9 +324,10 @@ public:
   ET_NODISCARD inline runtime::Error
   load_forward(runtime::HierarchicalAllocator *planned_memory = nullptr,
                torch::executor::EventTracer *event_tracer = nullptr,
-               const LoadBackendOptionsMap *backend_options = nullptr) {
-    return load_method("forward", planned_memory, event_tracer,
-                       backend_options);
+               const LoadBackendOptionsMap *backend_options = nullptr,
+               std::vector<Kernel> kernel_registry = {}) {
+    return load_method("forward", planned_memory, event_tracer, backend_options,
+                       std::move(kernel_registry));
   }
 
   ET_DEPRECATED ET_NODISCARD inline runtime::Error
@@ -678,6 +709,7 @@ private:
     std::unique_ptr<PlannedMemory> planned_memory;
     std::unique_ptr<runtime::MemoryManager> memory_manager;
     std::unique_ptr<Method> method;
+    std::vector<Kernel> kernel_registry;
   };
 
   std::string file_path_;
@@ -693,7 +725,14 @@ private:
   std::unique_ptr<NamedDataMap> merged_data_map_;
   std::vector<std::vector<uint8_t>> shared_arenas_;
   ET_DEPRECATED std::vector<uint8_t> debug_buffer_;
-  const LoadBackendOptionsMap *backend_options_ = nullptr;
+  // Module-owned deep-copy of the backend options most recently installed
+  // via load(LoadBackendOptionsMap, ...). `backend_options_storage_` owns
+  // the per-backend BackendOption arrays; `backend_options_map_` is a
+  // LoadBackendOptionsMap whose Spans reference those owned arrays. An
+  // empty map (`size() == 0`) is observationally indistinguishable from
+  // "never set" by downstream consumers, so we don't track that bit.
+  std::vector<std::vector<runtime::BackendOption>> backend_options_storage_;
+  LoadBackendOptionsMap backend_options_map_;
   bool share_memory_arenas_;
 
   ET_NODISCARD runtime::Error

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

@@ -14,6 +14,7 @@
 #include <vector>
 
 #include <c10/macros/Macros.h>
+#include <c10/util/safe_numerics.h>
 #include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
@@ -105,13 +106,21 @@ 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()),
+  auto numel_result = executorch::aten::safe_numel(sizes.data(), sizes.size());
+  ET_CHECK_MSG(numel_result.ok(), "safe_numel failed: %d",
+               static_cast<int>(numel_result.error()));
+  ET_CHECK_MSG(data.size() == static_cast<size_t>(numel_result.get()),
                "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() * aten::elementSize(type));
+    size_t casted_bytes = 0;
+    ET_CHECK_MSG(!c10::mul_overflows(
+                     data.size(), static_cast<size_t>(aten::elementSize(type)),
+                     &casted_bytes),
+                 "casted_data size overflow: %zu elements * %zu bytes/element",
+                 data.size(), static_cast<size_t>(aten::elementSize(type)));
+    std::vector<uint8_t> casted_data(casted_bytes);
 
     // Create a minimal context for error handling in ET_SWITCH
     struct {
@@ -327,8 +336,11 @@ make_tensor_ptr(const executorch::aten::Tensor &tensor,
   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());
+  auto element_count_result =
+      executorch::aten::safe_numel(sizes.data(), sizes.size());
+  ET_CHECK_MSG(element_count_result.ok(), "safe_numel failed: %d",
+               static_cast<int>(element_count_result.error()));
+  const auto element_count = element_count_result.get();
   const auto parent_element_count = tensor.numel();
   ET_CHECK_MSG(
       element_count <= parent_element_count,

package/third-party/include/executorch/kernels/optimized/Functions.h

@@ -91,6 +91,12 @@ TORCH_API inline torch::executor::Tensor & gelu_outf(torch::executor::KernelRunt
 }
 
 
+// aten::grid_sampler_2d.out(Tensor input, Tensor grid, int interpolation_mode, int padding_mode, bool align_corners, *, Tensor(a!) out) -> Tensor(a!)
+TORCH_API inline torch::executor::Tensor & grid_sampler_2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out) {
+    return ::torch::executor::native::opt_grid_sampler_2d_out(context, input, grid, interpolation_mode, padding_mode, align_corners, out);
+}
+
+
 // aten::le.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)
 TORCH_API inline torch::executor::Tensor & le_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out) {
     return ::torch::executor::native::opt_le_scalar_out(context, self, other, out);
@@ -139,6 +145,12 @@ TORCH_API inline torch::executor::Tensor & sub_outf(torch::executor::KernelRunti
 }
 
 
+// aten::sum.IntList_out(Tensor self, int[1]? dim, bool keepdim=False, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)
+TORCH_API inline torch::executor::Tensor & sum_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out) {
+    return ::torch::executor::native::opt_sum_dim_out(context, self, dim, keepdim, dtype, out);
+}
+
+
 // aten::sub.Scalar_out(Tensor self, Scalar other, Scalar alpha=1, *, Tensor(a!) out) -> Tensor(a!)
 TORCH_API inline torch::executor::Tensor & sub_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out) {
     return ::torch::executor::native::opt_sub_scalar_out(context, self, other, alpha, out);

package/third-party/include/executorch/kernels/optimized/NativeFunctions.h

@@ -42,6 +42,8 @@ torch::executor::Tensor & opt_exp_out(const torch::executor::Tensor & self, torc
 torch::executor::Tensor & opt_exp_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_gelu_out(const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_gelu_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::string_view approximate, torch::executor::Tensor & out);
+torch::executor::Tensor & opt_grid_sampler_2d_out(const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out);
+torch::executor::Tensor & opt_grid_sampler_2d_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, const torch::executor::Tensor & grid, int64_t interpolation_mode, int64_t padding_mode, bool align_corners, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_le_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_le_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_le_tensor_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);
@@ -58,6 +60,8 @@ torch::executor::Tensor & opt_mul_scalar_out(torch::executor::KernelRuntimeConte
 ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &,torch::executor::Tensor &> opt_native_layer_norm_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & input, torch::executor::ArrayRef<int64_t> normalized_shape, const torch::executor::optional<torch::executor::Tensor> & weight, const torch::executor::optional<torch::executor::Tensor> & bias, double eps, torch::executor::Tensor & out0, torch::executor::Tensor & out1, torch::executor::Tensor & out2);
 torch::executor::Tensor & opt_sub_out(const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_sub_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Tensor & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
+torch::executor::Tensor & opt_sum_dim_out(const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
+torch::executor::Tensor & opt_sum_dim_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool keepdim, torch::executor::optional<torch::executor::ScalarType> dtype, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_sub_scalar_out(const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_sub_scalar_out(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, const torch::executor::Scalar & other, const torch::executor::Scalar & alpha, torch::executor::Tensor & out);
 torch::executor::Tensor & opt_where_out(const torch::executor::Tensor & condition, const torch::executor::Tensor & self, const torch::executor::Tensor & other, torch::executor::Tensor & out);

package/third-party/include/executorch/kernels/portable/Functions.h

@@ -25,12 +25,24 @@ namespace executor {
 
 namespace aten {
 
+// aten::_adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!)
+TORCH_API inline torch::executor::Tensor & _adaptive_avg_pool2d_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::ArrayRef<int64_t> output_size, torch::executor::Tensor & out) {
+    return ::torch::executor::native::_adaptive_avg_pool2d_out(context, self, output_size, out);
+}
+
+
 // aten::_cdist_forward.out(Tensor x1, Tensor x2, float p, int? compute_mode, *, Tensor(a!) out) -> Tensor(a!)
 TORCH_API inline torch::executor::Tensor & _cdist_forward_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & x1, const torch::executor::Tensor & x2, double p, torch::executor::optional<int64_t> compute_mode, torch::executor::Tensor & out) {
     return ::torch::executor::native::_cdist_forward_out(context, x1, x2, p, compute_mode, out);
 }
 
 
+// aten::_conj_physical.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+TORCH_API inline torch::executor::Tensor & _conj_physical_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::Tensor & out) {
+    return ::torch::executor::native::_conj_physical_out(context, self, out);
+}
+
+
 // aten::_log_softmax.out(Tensor self, int dim, bool half_to_float, *, Tensor(a!) out) -> Tensor(a!)
 TORCH_API inline torch::executor::Tensor & _log_softmax_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, int64_t dim, bool half_to_float, torch::executor::Tensor & out) {
     return ::torch::executor::native::log_softmax_out(context, self, dim, half_to_float, out);
@@ -1201,6 +1213,12 @@ TORCH_API inline torch::executor::Tensor & var_outf(torch::executor::KernelRunti
 }
 
 
+// aten::var_mean.correction_out(Tensor self, int[1]? dim=None, *, Scalar? correction=None, bool keepdim=False, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
+TORCH_API inline ::std::tuple<torch::executor::Tensor &,torch::executor::Tensor &> var_mean_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, const torch::executor::optional<torch::executor::Scalar> & correction, bool keepdim, torch::executor::Tensor & out0, torch::executor::Tensor & out1) {
+    return ::torch::executor::native::var_mean_correction_out(context, self, dim, correction, keepdim, out0, out1);
+}
+
+
 // aten::var.out(Tensor self, int[1]? dim, bool unbiased=True, bool keepdim=False, *, Tensor(a!) out) -> Tensor(a!)
 TORCH_API inline torch::executor::Tensor & var_outf(torch::executor::KernelRuntimeContext & context, const torch::executor::Tensor & self, torch::executor::optional<torch::executor::ArrayRef<int64_t>> dim, bool unbiased, bool keepdim, torch::executor::Tensor & out) {
     return ::torch::executor::native::var_out(context, self, dim, unbiased, keepdim, out);