react-native-executorch 0.5.6 → 0.5.7

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

@@ -34,12 +34,13 @@ typedef NSNumber *
     ExecuTorchScalarValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(ScalarValue);
 typedef NSString *
     ExecuTorchStringValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(StringValue);
-typedef BOOL
-    ExecuTorchBooleanValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(BoolValue);
+typedef BOOL ExecuTorchBooleanValue NS_SWIFT_NAME(BoolValue);
 typedef NSInteger
     ExecuTorchIntegerValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(IntegerValue);
 typedef double
     ExecuTorchDoubleValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(DoubleValue);
+typedef float
+    ExecuTorchFloatValue NS_SWIFT_BRIDGED_TYPEDEF NS_SWIFT_NAME(FloatValue);
 
 /**
  * A dynamic value type used by ExecuTorch.
@@ -49,7 +50,7 @@ typedef double
  */
 NS_SWIFT_NAME(Value)
 __attribute__((deprecated("This API is experimental.")))
-@interface ExecuTorchValue : NSObject
+@interface ExecuTorchValue : NSObject<NSCopying>
 
 /**
  * The tag that indicates the dynamic type of the value.
@@ -64,7 +65,7 @@ __attribute__((deprecated("This API is experimental.")))
  * @return A Tensor instance or nil.
  */
 @property(nullable, nonatomic, readonly)
-    ExecuTorchTensor *tensorValue NS_SWIFT_NAME(tensor);
+    ExecuTorchTensor *tensorValue NS_REFINED_FOR_SWIFT;
 
 /**
  * The string value if the tag is ExecuTorchValueTagString.
@@ -106,6 +107,14 @@ __attribute__((deprecated("This API is experimental.")))
 @property(nonatomic, readonly)
     ExecuTorchDoubleValue doubleValue NS_SWIFT_NAME(double);
 
+/**
+ * The float value if the tag is ExecuTorchValueTagDouble.
+ *
+ * @return An float representing the float value.
+ */
+@property(nonatomic, readonly)
+    ExecuTorchFloatValue floatValue NS_SWIFT_NAME(float);
+
 /**
  * Returns YES if the value is of type None.
  *
@@ -155,6 +164,16 @@ __attribute__((deprecated("This API is experimental.")))
  */
 @property(nonatomic, readonly) BOOL isDouble;
 
+/**
+ * Returns YES if the value's tag is Double.
+ *
+ * Note: Since float values are stored with a Double tag, this property will
+ * also be YES for values created from floats.
+ *
+ * @return A BOOL indicating whether the value is a float.
+ */
+@property(nonatomic, readonly) BOOL isFloat;
+
 /**
  * Creates an instance encapsulating a Tensor.
  *
@@ -163,7 +182,7 @@ __attribute__((deprecated("This API is experimental.")))
  * ExecuTorchValueTagTensor.
  */
 + (instancetype)valueWithTensor:(ExecuTorchTensor *)value
-    NS_SWIFT_NAME(init(_:));
+    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
 
 /**
  * Creates an instance encapsulating a string.
@@ -173,7 +192,7 @@ __attribute__((deprecated("This API is experimental.")))
  * ExecuTorchValueTagString.
  */
 + (instancetype)valueWithString:(ExecuTorchStringValue)value
-    NS_SWIFT_NAME(init(_:));
+    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
 
 /**
  * Creates an instance encapsulating a boolean.
@@ -183,7 +202,7 @@ __attribute__((deprecated("This API is experimental.")))
  * ExecuTorchValueTagBoolean.
  */
 + (instancetype)valueWithBoolean:(ExecuTorchBooleanValue)value
-    NS_SWIFT_NAME(init(_:));
+    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
 
 /**
  * Creates an instance encapsulating an integer.
@@ -193,7 +212,7 @@ __attribute__((deprecated("This API is experimental.")))
  * ExecuTorchValueTagInteger.
  */
 + (instancetype)valueWithInteger:(ExecuTorchIntegerValue)value
-    NS_SWIFT_NAME(init(_:));
+    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
 
 /**
  * Creates an instance encapsulating a double value.
@@ -203,7 +222,40 @@ __attribute__((deprecated("This API is experimental.")))
  * ExecuTorchValueTagDouble.
  */
 + (instancetype)valueWithDouble:(ExecuTorchDoubleValue)value
-    NS_SWIFT_NAME(init(_:));
+    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
+
+/**
+ * Creates an instance encapsulating a float value.
+ *
+ * Note: The underlying value will be stored with a tag of
+ * ExecuTorchValueTagDouble, as there is no distinct float tag.
+ *
+ * @param value A float value.
+ * @return A new ExecuTorchValue instance with a tag of
+ * ExecuTorchValueTagDouble.
+ */
++ (instancetype)valueWithFloat:(ExecuTorchFloatValue)value
+    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
+
+/**
+ * Creates an instance encapsulating a scalar value.
+ *
+ * The value's tag will be set according to the type encoding of the
+ * ExecuTorchScalarValue.
+ *
+ * @param value An ExecuTorchScalarValue.
+ * @return A new ExecuTorchValue instance with the appropriate tag.
+ */
++ (instancetype)valueWithScalar:(ExecuTorchScalarValue)value
+    NS_SWIFT_NAME(init(_:)) NS_RETURNS_RETAINED;
+
+/**
+ * Returns a copy of the value.
+ *
+ * @return A new ExecuTorchValue instance that is a duplicate of the current
+ * value.
+ */
+- (instancetype)copy;
 
 /**
  * Determines whether the current Value is equal to another Value.

package/third-party/include/executorch/extension/kernel_util/make_boxed_from_unboxed_functor.h

@@ -0,0 +1,181 @@
+/*
+ * 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.
+ */
+
+//===----------------------------------------------------------------------===//
+/// \file extension/kernel_util/make_boxed_from_unboxed_functor.h
+/// Defines a template that can be used to create a boxed version of an unboxed
+/// functor.
+/// Example usage:
+/// ```
+/// Tensor&
+/// my_op(KernelRuntimeContext& ctx, const Tensor& self, const Tensor& other,
+///       Tensor& out)
+/// {
+///   // ...
+///   return out;
+/// }
+///
+/// Kernel my_kernel = Kernel::make_boxed_kernel("my_ns::my_op",
+///   EXECUTORCH_FN(my_op));
+/// static auto res = register_kernels({my_kernel});
+/// ```
+/// Or simply:
+/// ```
+/// EXECUTORCH_LIBRARY(my_ns, "my_op", my_op);
+/// ```
+///
+/// The trick here is to convert each EValue to inferred argument type. This
+/// uses a lot of C++17 features.
+//===----------------------------------------------------------------------===//
+
+#pragma once
+#if __cplusplus < 201703L
+#error "This header requires C++17"
+#endif
+
+#include <cstdlib>
+#include <executorch/extension/kernel_util/meta_programming.h>
+#include <executorch/extension/kernel_util/type_list.h>
+#include <executorch/runtime/core/evalue.h>
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/kernel/operator_registry.h>
+#include <memory>
+#include <type_traits>
+#include <typeinfo>
+
+namespace executorch {
+namespace runtime {
+class KernelRuntimeContext; // Forward declaration
+} // namespace runtime
+} // namespace executorch
+
+namespace executorch {
+namespace extension {
+
+// This extension has a lot of generic internal names like "size"; use a unique
+// internal namespace to avoid conflicts with other extensions.
+namespace kernel_util_internal {
+
+template <class T> struct decay_if_not_tensor final {
+  using type = std::decay_t<T>;
+};
+template <> struct decay_if_not_tensor<executorch::aten::Tensor &> final {
+  using type = executorch::aten::Tensor &;
+};
+template <> struct decay_if_not_tensor<const executorch::aten::Tensor &> final {
+  using type = const executorch::aten::Tensor &;
+};
+
+template <class T> struct evalue_to_arg final {
+  static T call(executorch::runtime::EValue &v) { return std::move(v).to<T>(); }
+};
+
+template <> struct evalue_to_arg<executorch::aten::Tensor &> final {
+  static executorch::aten::Tensor &call(executorch::runtime::EValue &v) {
+    return v.toTensor();
+  }
+};
+
+template <> struct evalue_to_arg<const executorch::aten::Tensor &> final {
+  static const executorch::aten::Tensor &call(executorch::runtime::EValue &v) {
+    return v.toTensor();
+  }
+};
+
+template <class T> struct evalue_to_arg<std::optional<T>> final {
+  static std::optional<T> call(executorch::runtime::EValue &v) {
+    return v.toOptional<T>();
+  }
+};
+
+template <class T>
+struct evalue_to_arg<executorch::aten::ArrayRef<std::optional<T>>> final {
+  static executorch::aten::ArrayRef<std::optional<T>>
+  call(executorch::runtime::EValue &v) {
+    return v.toListOptionalTensor();
+  }
+};
+
+template <class Functor, size_t... evalue_arg_indices, typename... ArgTypes>
+void call_functor_with_args_from_stack(
+    ::executorch::runtime::KernelRuntimeContext &ctx,
+    executorch::runtime::EValue **stack,
+    std::index_sequence<evalue_arg_indices...>, typelist<ArgTypes...> *) {
+  (*Functor::func_ptr())(
+      ctx, evalue_to_arg<typename decay_if_not_tensor<ArgTypes>::type>::call(
+               *stack[evalue_arg_indices])...);
+}
+
+} // namespace kernel_util_internal
+
+/**
+ * WrapUnboxedIntoFunctor: Given a function pointer, wrap it into a functor that
+ * takes EValues as input and returns void. The wrapped functor will unbox all
+ * inputs and forward them to unboxed kernel.
+ */
+template <class FuncType> struct WrapUnboxedIntoFunctor {
+  static_assert(
+      kernel_util_internal::is_compile_time_function_pointer<FuncType>::value,
+      "Can't handle function other than EXECUTORCH_FN");
+  using TrueType = typename FuncType::FuncType;
+  using ReturnType = typename kernel_util_internal::infer_function_traits_t<
+      TrueType>::return_type;
+  using ArgsType = typename kernel_util_internal::infer_function_traits_t<
+      TrueType>::parameter_types;
+  // check if the first argument is KernelRuntimeContext, if so, remove it
+  static constexpr bool first_arg_is_context = std::is_same<
+      ::executorch::runtime::KernelRuntimeContext,
+      std::remove_reference_t<
+          kernel_util_internal::head_with_default_t<void, ArgsType>>>::value;
+  using ContextRemovedArgsType =
+      std::conditional_t<first_arg_is_context,
+                         kernel_util_internal::drop_if_nonempty_t<ArgsType, 1>,
+                         ArgsType>;
+
+  static void call(::executorch::runtime::KernelRuntimeContext &ctx,
+                   executorch::runtime::EValue **stack) {
+    constexpr size_t num_inputs =
+        kernel_util_internal::size<ContextRemovedArgsType>::value;
+    return kernel_util_internal::call_functor_with_args_from_stack<FuncType>(
+        ctx, stack, std::make_index_sequence<num_inputs>(),
+        static_cast<ContextRemovedArgsType *>(nullptr));
+  }
+};
+
+template <typename FuncType>
+static executorch::runtime::Kernel make_boxed_kernel(const char *name,
+                                                     FuncType) {
+  return executorch::runtime::Kernel(name,
+                                     WrapUnboxedIntoFunctor<FuncType>::call);
+}
+
+} // namespace extension
+} // namespace executorch
+
+// Inspired from C10_CONCATENATE
+#define ET_CONCATENATE_IMPL(s1, s2) s1##s2
+#define ET_CONCATENATE(s1, s2) ET_CONCATENATE_IMPL(s1, s2)
+#define ET_UID __LINE__
+
+#define EXECUTORCH_LIBRARY(ns, op_name, func)                                  \
+  _EXECUTORCH_LIBRARY_IMPL(ns, op_name, func, ET_UID)
+
+#define _EXECUTORCH_LIBRARY_IMPL(ns, op_name, func, uid)                       \
+  static auto ET_CONCATENATE(res_##ns##_, uid) =                               \
+      ::executorch::runtime::register_kernel(                                  \
+          ::executorch::extension::make_boxed_kernel(#ns "::" op_name,         \
+                                                     EXECUTORCH_FN(func)))
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::extension::make_boxed_kernel;
+using ::executorch::extension::WrapUnboxedIntoFunctor;
+} // namespace executor
+} // namespace torch

package/third-party/include/executorch/extension/kernel_util/meta_programming.h

@@ -0,0 +1,108 @@
+/*
+ * 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
+#if __cplusplus < 201703L
+#error "This header requires C++17"
+#endif
+
+#include <cstdlib>
+#include <executorch/extension/kernel_util/type_list.h>
+#include <memory>
+#include <type_traits>
+#include <typeinfo>
+
+namespace executorch {
+namespace extension {
+// This extension has a lot of generic internal names like "size"; use a unique
+// internal namespace to avoid conflicts with other extensions.
+namespace kernel_util_internal {
+
+// Check if a given type is a function
+template <class T> struct is_function_type : std::false_type {};
+template <class Result, class... Args>
+struct is_function_type<Result(Args...)> : std::true_type {};
+template <class T>
+using is_function_type_t = typename is_function_type<T>::type;
+
+// A compile-time wrapper around a function pointer
+template <class FuncType_, FuncType_ *func_ptr_>
+struct CompileTimeFunctionPointer final {
+  static_assert(is_function_type<FuncType_>::value,
+                "EXECUTORCH_FN can only wrap function types.");
+  using FuncType = FuncType_;
+
+  static constexpr FuncType *func_ptr() { return func_ptr_; }
+};
+
+// Check if a given type is a compile-time function pointer
+template <class T> struct is_compile_time_function_pointer : std::false_type {};
+template <class FuncType, FuncType *func_ptr>
+struct is_compile_time_function_pointer<
+    CompileTimeFunctionPointer<FuncType, func_ptr>> : std::true_type {};
+
+#define EXECUTORCH_FN_TYPE(func)                                               \
+  ::executorch::extension::kernel_util_internal::CompileTimeFunctionPointer<   \
+      std::remove_pointer_t<std::remove_reference_t<decltype(func)>>, func>
+#define EXECUTORCH_FN(func) EXECUTORCH_FN_TYPE(func)()
+
+/**
+ * strip_class: helper to remove the class type from pointers to `operator()`.
+ */
+template <typename T> struct strip_class {};
+template <typename Class, typename Result, typename... Args>
+struct strip_class<Result (Class::*)(Args...)> {
+  using type = Result(Args...);
+};
+template <typename Class, typename Result, typename... Args>
+struct strip_class<Result (Class::*)(Args...) const> {
+  using type = Result(Args...);
+};
+template <typename T> using strip_class_t = typename strip_class<T>::type;
+
+/**
+ * Access information about result type or arguments from a function type.
+ * Example:
+ * using A = function_traits<int (float, double)>::return_type // A == int
+ * using A = function_traits<int (float, double)>::parameter_types::tuple_type
+ * // A == tuple<float, double>
+ */
+template <class Func> struct function_traits {
+  static_assert(
+      !std::is_same<Func, Func>::value,
+      "In function_traits<Func>, Func must be a plain function type.");
+};
+template <class Result, class... Args> struct function_traits<Result(Args...)> {
+  using func_type = Result(Args...);
+  using return_type = Result;
+  using parameter_types = typelist<Args...>;
+  static constexpr auto number_of_parameters = sizeof...(Args);
+};
+
+/**
+ * infer_function_traits: creates a `function_traits` type for a simple
+ * function (pointer) or functor (lambda/struct). Currently does not support
+ * class methods.
+ */
+template <typename Functor> struct infer_function_traits {
+  using type = function_traits<strip_class_t<decltype(&Functor::operator())>>;
+};
+template <typename Result, typename... Args>
+struct infer_function_traits<Result (*)(Args...)> {
+  using type = function_traits<Result(Args...)>;
+};
+template <typename Result, typename... Args>
+struct infer_function_traits<Result(Args...)> {
+  using type = function_traits<Result(Args...)>;
+};
+template <typename T>
+using infer_function_traits_t = typename infer_function_traits<T>::type;
+
+} // namespace kernel_util_internal
+} // namespace extension
+} // namespace executorch

package/third-party/include/executorch/extension/kernel_util/type_list.h

@@ -0,0 +1,137 @@
+/*
+ * 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.
+ */
+
+///
+/// \file runtime/kernel/type_list.h
+/// Forked from pytorch/c10/util/TypeList.h
+/// \brief Utilities for working with type lists.
+#pragma once
+#if __cplusplus < 201703L
+#error "This header requires C++17"
+#endif
+
+#include <algorithm>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace executorch {
+namespace extension {
+// This extension has a lot of generic internal names like "size"; use a unique
+// internal namespace to avoid conflicts with other extensions.
+namespace kernel_util_internal {
+
+/**
+ * Type holding a list of types for compile time type computations
+ *     constexpr size_t num = size<typelist<int, double>>::value;
+ *     static_assert(num == 2, "");
+ */
+template <class... T> struct false_t : std::false_type {};
+
+template <class... Items> struct typelist final {
+public:
+  typelist() = delete; // not for instantiation
+};
+template <class TypeList> struct size final {
+  static_assert(false_t<TypeList>::value,
+                "In typelist::size<T>, T must be typelist<...>.");
+};
+template <class... Types> struct size<typelist<Types...>> final {
+  static constexpr size_t value = sizeof...(Types);
+};
+
+/**
+ * is_instantiation_of<T, I> is true_type iff I is a template instantiation of T
+ * (e.g. vector<int> is an instantiation of vector) Example:
+ *    is_instantiation_of_t<vector, vector<int>> // true
+ *    is_instantiation_of_t<pair, pair<int, string>> // true
+ *    is_instantiation_of_t<vector, pair<int, string>> // false
+ */
+template <template <class...> class Template, class T>
+struct is_instantiation_of : std::false_type {};
+template <template <class...> class Template, class... Args>
+struct is_instantiation_of<Template, Template<Args...>> : std::true_type {};
+template <template <class...> class Template, class T>
+using is_instantiation_of_t = typename is_instantiation_of<Template, T>::type;
+
+/// Base template.
+template <size_t Index, class TypeList> struct element final {
+  static_assert(
+      false_t<TypeList>::value,
+      "In typelist::element<T>, the T argument must be typelist<...>.");
+};
+/// Successful case, we have reached the zero index and can "return" the head
+/// type.
+template <class Head, class... Tail>
+struct element<0, typelist<Head, Tail...>> {
+  using type = Head;
+};
+/// Error case, we have an index but ran out of types! It will only be selected
+/// if `Ts...` is actually empty!
+template <size_t Index, class... Ts> struct element<Index, typelist<Ts...>> {
+  static_assert(Index < sizeof...(Ts),
+                "Index is out of bounds in typelist::element");
+};
+/// Shave off types until we hit the <0, Head, Tail...> or <Index> case.
+template <size_t Index, class Head, class... Tail>
+struct element<Index, typelist<Head, Tail...>>
+    : element<Index - 1, typelist<Tail...>> {};
+/// Convenience alias.
+template <size_t Index, class TypeList>
+using element_t = typename element<Index, TypeList>::type;
+
+/**
+ * Returns the first element of a type list, or the specified default if the
+ * type list is empty. Example: int  ==  head_t<bool, typelist<int, string>>
+ *   bool  ==  head_t<bool, typelist<>>
+ */
+template <class Default, class TypeList> struct head_with_default final {
+  using type = Default;
+};
+template <class Default, class Head, class... Tail>
+struct head_with_default<Default, typelist<Head, Tail...>> final {
+  using type = Head;
+};
+template <class Default, class TypeList>
+using head_with_default_t = typename head_with_default<Default, TypeList>::type;
+
+/**
+ * Take/drop a number of arguments from a typelist.
+ * Example:
+ *   typelist<int, string> == take_t<typelist<int, string, bool>, 2>
+ *   typelist<bool> == drop_t<typelist<int, string, bool>, 2>
+ */
+template <class TypeList, size_t offset, class IndexSequence>
+struct take_elements final {};
+template <class TypeList, size_t offset, size_t... Indices>
+struct take_elements<TypeList, offset, std::index_sequence<Indices...>> final {
+  using type = typelist<typename element<offset + Indices, TypeList>::type...>;
+};
+
+/**
+ * Like drop, but returns an empty list rather than an assertion error if `num`
+ * is larger than the size of the TypeList.
+ * Example:
+ *   typelist<> == drop_if_nonempty_t<typelist<string, bool>, 2>
+ *   typelist<> == drop_if_nonempty_t<typelist<int, string, bool>, 3>
+ */
+template <class TypeList, size_t num> struct drop_if_nonempty final {
+  static_assert(
+      is_instantiation_of<typelist, TypeList>::value,
+      "In typelist::drop<T, num>, the T argument must be typelist<...>.");
+  using type = typename take_elements<
+      TypeList, std::min(num, size<TypeList>::value),
+      std::make_index_sequence<size<TypeList>::value -
+                               std::min(num, size<TypeList>::value)>>::type;
+};
+template <class TypeList, size_t num>
+using drop_if_nonempty_t = typename drop_if_nonempty<TypeList, num>::type;
+
+} // namespace kernel_util_internal
+} // namespace extension
+} // namespace executorch