react-native-executorch 0.5.6 → 0.5.7

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

@@ -11,6 +11,10 @@
  * Platform abstraction layer to allow individual platform libraries to override
  * symbols in ExecuTorch. PAL functions are defined as C functions so a platform
  * library implementer can use C in lieu of C++.
+ *
+ * The et_pal_ methods should not be called directly. Use the corresponding
+ * methods in the executorch::runtime namespace instead to appropriately
+ * dispatch through the PAL function table.
  */
 
 #pragma once
@@ -53,12 +57,14 @@ typedef struct {
  * to initialize any global state. Typically overridden by PAL implementer.
  */
 void et_pal_init(void) ET_INTERNAL_PLATFORM_WEAKNESS;
+using pal_init_method = void (*)();
 
 /**
  * Immediately abort execution, setting the device into an error state, if
  * available.
  */
 ET_NORETURN void et_pal_abort(void) ET_INTERNAL_PLATFORM_WEAKNESS;
+using pal_abort_method = void (*)();
 
 /**
  * Return a monotonically non-decreasing timestamp in system ticks.
@@ -66,6 +72,8 @@ ET_NORETURN void et_pal_abort(void) ET_INTERNAL_PLATFORM_WEAKNESS;
  * @retval Timestamp value in system ticks.
  */
 et_timestamp_t et_pal_current_ticks(void) ET_INTERNAL_PLATFORM_WEAKNESS;
+typedef et_timestamp_t (*et_pal_current_ticks_t)(void);
+using pal_current_ticks_method = et_timestamp_t (*)();
 
 /**
  * Return the conversion rate from system ticks to nanoseconds as a fraction.
@@ -81,6 +89,7 @@ et_timestamp_t et_pal_current_ticks(void) ET_INTERNAL_PLATFORM_WEAKNESS;
  */
 et_tick_ratio_t
 et_pal_ticks_to_ns_multiplier(void) ET_INTERNAL_PLATFORM_WEAKNESS;
+using pal_ticks_to_ns_multiplier_method = et_tick_ratio_t (*)();
 
 /**
  * Severity level of a log message. Values must map to printable 7-bit ASCII
@@ -110,6 +119,9 @@ void et_pal_emit_log_message(et_timestamp_t timestamp, et_pal_log_level_t level,
                              const char *filename, const char *function,
                              size_t line, const char *message,
                              size_t length) ET_INTERNAL_PLATFORM_WEAKNESS;
+using pal_emit_log_message_method = void (*)(
+    et_timestamp_t timestamp, et_pal_log_level_t level, const char *filename,
+    const char *function, size_t line, const char *message, size_t length);
 
 /**
  * NOTE: Core runtime code must not call this directly. It may only be called by
@@ -122,6 +134,7 @@ void et_pal_emit_log_message(et_timestamp_t timestamp, et_pal_log_level_t level,
  *     et_pal_free().
  */
 void *et_pal_allocate(size_t size) ET_INTERNAL_PLATFORM_WEAKNESS;
+using pal_allocate_method = void *(*)(size_t size);
 
 /**
  * Frees memory allocated by et_pal_allocate().
@@ -129,5 +142,118 @@ void *et_pal_allocate(size_t size) ET_INTERNAL_PLATFORM_WEAKNESS;
  * @param[in] ptr Pointer to memory to free. May be nullptr.
  */
 void et_pal_free(void *ptr) ET_INTERNAL_PLATFORM_WEAKNESS;
+using pal_free_method = void (*)(void *ptr);
 
 } // extern "C"
+
+namespace executorch::runtime {
+
+/**
+ * Table of pointers to platform abstraction layer functions.
+ */
+struct PalImpl {
+  // Note that this struct cannot contain constructors in order to ensure that
+  // the singleton instance can be initialized without relying on a global
+  // constructor. If it does require a global constructor, there can be a race
+  // between the init of the default PAL and the user static registration code.
+  static PalImpl create(pal_emit_log_message_method emit_log_message,
+                        const char *source_filename);
+
+  static PalImpl
+  create(pal_init_method init, pal_abort_method abort,
+         pal_current_ticks_method current_ticks,
+         pal_ticks_to_ns_multiplier_method ticks_to_ns_multiplier,
+         pal_emit_log_message_method emit_log_message,
+         pal_allocate_method allocate, pal_free_method free,
+         const char *source_filename);
+
+  pal_init_method init = nullptr;
+  pal_abort_method abort = nullptr;
+  pal_current_ticks_method current_ticks = nullptr;
+  pal_ticks_to_ns_multiplier_method ticks_to_ns_multiplier = nullptr;
+  pal_emit_log_message_method emit_log_message = nullptr;
+  pal_allocate_method allocate = nullptr;
+  pal_free_method free = nullptr;
+
+  // An optional metadata field, indicating the name of the source
+  // file that registered the PAL implementation.
+  const char *source_filename;
+};
+
+/**
+ * Override the PAL functions with user implementations. Any null entries in the
+ * table are unchanged and will keep the default implementation.
+ *
+ * Returns true if the registration was successful, false otherwise.
+ */
+bool register_pal(PalImpl impl);
+
+/**
+ * Returns the PAL function table, which contains function pointers to the
+ * active implementation of each PAL function.
+ */
+const PalImpl *get_pal_impl();
+
+/**
+ * Initialize the platform abstraction layer.
+ *
+ * This function should be called before any other function provided by the PAL
+ * to initialize any global state. Typically overridden by PAL implementer.
+ */
+void pal_init();
+
+/**
+ * Immediately abort execution, setting the device into an error state, if
+ * available.
+ */
+ET_NORETURN void pal_abort();
+
+/**
+ * Return a monotonically non-decreasing timestamp in system ticks.
+ *
+ * @retval Timestamp value in system ticks.
+ */
+et_timestamp_t pal_current_ticks();
+
+/**
+ * Return the conversion rate from system ticks to nanoseconds as a fraction.
+ * To convert a system ticks to nanoseconds, multiply the tick count by the
+ * numerator and then divide by the denominator:
+ *   nanoseconds = ticks * numerator / denominator
+ *
+ * The utility method executorch::runtime::ticks_to_ns(et_timestamp_t) can also
+ * be used to perform the conversion for a given tick count. It is defined in
+ * torch/executor/runtime/platform/clock.h.
+ *
+ * @retval The ratio of nanoseconds to system ticks.
+ */
+et_tick_ratio_t pal_ticks_to_ns_multiplier();
+
+/**
+ * Severity level of a log message. Values must map to printable 7-bit ASCII
+ * uppercase letters.
+ */
+void pal_emit_log_message(et_timestamp_t timestamp, et_pal_log_level_t level,
+                          const char *filename, const char *function,
+                          size_t line, const char *message, size_t length);
+
+/**
+ * NOTE: Core runtime code must not call this directly. It may only be called by
+ * a MemoryAllocator wrapper.
+ *
+ * Allocates size bytes of memory.
+ *
+ * @param[in] size Number of bytes to allocate.
+ * @returns the allocated memory, or nullptr on failure. Must be freed using
+ *     et_pal_free().
+ */
+void *pal_allocate(size_t size);
+
+/**
+ * Frees memory allocated by et_pal_allocate().
+ *
+ * @param[in] ptr Pointer to memory to free. May be nullptr.
+ */
+void pal_free(void *ptr);
+
+} // namespace executorch::runtime

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

@@ -0,0 +1,88 @@
+#define C10_USING_CUSTOM_GENERATED_MACROS
+#pragma once
+
+/* 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
+ * hitting this file, make sure you start with the background here:
+ * - Linux: https://gcc.gnu.org/wiki/Visibility
+ * - Windows:
+ * https://docs.microsoft.com/en-us/cpp/cpp/dllexport-dllimport?view=vs-2017
+ *
+ * Do NOT include this file directly. Instead, use c10/macros/Macros.h
+ */
+
+// You do not need to edit this part of file unless you are changing the core
+// pytorch export abstractions.
+//
+// This part defines the C10 core export and import macros. This is controlled
+// by whether we are building shared libraries or not, which is determined
+// during build time and codified in c10/core/cmake_macros.h.
+// When the library is built as a shared lib, EXPORT and IMPORT will contain
+// visibility attributes. If it is being built as a static lib, then EXPORT
+// and IMPORT basically have no effect.
+
+// As a rule of thumb, you should almost NEVER mix static and shared builds for
+// libraries that depend on c10. AKA, if c10 is built as a static library, we
+// recommend everything dependent on c10 to be built statically. If c10 is built
+// as a shared library, everything dependent on it should be built as shared. In
+// the PyTorch project, all native libraries shall use the macro
+// C10_BUILD_SHARED_LIB to check whether pytorch is building shared or static
+// libraries.
+
+// For build systems that do not directly depend on CMake and directly build
+// from the source directory (such as Buck), one may not have a cmake_macros.h
+// file at all. In this case, the build system is responsible for providing
+// correct macro definitions corresponding to the cmake_macros.h.in file.
+//
+// In such scenarios, one should define the macro
+//     C10_USING_CUSTOM_GENERATED_MACROS
+// to inform this header that it does not need to include the cmake_macros.h
+// file.
+
+#ifdef _WIN32
+#define C10_HIDDEN
+#if defined(C10_BUILD_SHARED_LIBS)
+#define C10_EXPORT __declspec(dllexport)
+#define C10_IMPORT __declspec(dllimport)
+#else
+#define C10_EXPORT
+#define C10_IMPORT
+#endif
+#else // _WIN32
+#if defined(__GNUC__)
+#define C10_EXPORT __attribute__((__visibility__("default")))
+#define C10_HIDDEN __attribute__((__visibility__("hidden")))
+#else // defined(__GNUC__)
+#define C10_EXPORT
+#define C10_HIDDEN
+#endif // defined(__GNUC__)
+#define C10_IMPORT C10_EXPORT
+#endif // _WIN32
+
+#ifdef NO_EXPORT
+#undef C10_EXPORT
+#define C10_EXPORT
+#endif
+
+// Definition of an adaptive XX_API macro, that depends on whether you are
+// building the library itself or not, routes to XX_EXPORT and XX_IMPORT.
+// Basically, you will need to do this for each shared library that you are
+// building, and the instruction is as follows: assuming that you are building
+// a library called libawesome.so. You should:
+// (1) for your cmake target (usually done by "add_library(awesome, ...)"),
+//     define a macro called AWESOME_BUILD_MAIN_LIB using
+//     target_compile_options.
+// (2) define the AWESOME_API macro similar to the one below.
+// And in the source file of your awesome library, use AWESOME_API to
+// annotate public symbols.
+
+// Here, for the C10 library, we will define the macro C10_API for both import
+// and export.
+
+// This one is being used by libc10.so
+#ifdef C10_BUILD_MAIN_LIB
+#define C10_API C10_EXPORT
+#else
+#define C10_API C10_IMPORT
+#endif

package/third-party/include/tokenizers-cpp/tokenizers_c.h

@@ -0,0 +1,61 @@
+/*!
+ *  Copyright (c) 2023 by Contributors
+ * \file tokenizers_c.h
+ * \brief C binding to tokenizers rust library
+ */
+#ifndef TOKENIZERS_C_H_
+#define TOKENIZERS_C_H_
+
+// The C API
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef void *TokenizerHandle;
+
+typedef struct {
+  int *token_ids;
+  size_t len;
+} TokenizerEncodeResult;
+
+TokenizerHandle tokenizers_new_from_str(const char *json, size_t len);
+
+TokenizerHandle byte_level_bpe_tokenizers_new_from_str(
+    const char *vocab, size_t vocab_len, const char *merges, size_t merges_len,
+    const char *added_tokens, size_t added_tokens_len);
+
+void tokenizers_encode(TokenizerHandle handle, const char *data, size_t len,
+                       int add_special_token, TokenizerEncodeResult *result);
+
+void tokenizers_encode_batch(TokenizerHandle handle, const char **data,
+                             size_t *len, size_t num_seqs,
+                             int add_special_token,
+                             TokenizerEncodeResult *results);
+
+void tokenizers_free_encode_results(TokenizerEncodeResult *results,
+                                    size_t num_seqs);
+
+void tokenizers_decode(TokenizerHandle handle, const uint32_t *data, size_t len,
+                       int skip_special_token);
+
+void tokenizers_get_decode_str(TokenizerHandle handle, const char **data,
+                               size_t *len);
+
+void tokenizers_get_vocab_size(TokenizerHandle handle, size_t *size);
+
+void tokenizers_id_to_token(TokenizerHandle handle, uint32_t id,
+                            const char **data, size_t *len);
+
+// tokenizers_token_to_id stores -1 to *id if the token is not in the vocab
+void tokenizers_token_to_id(TokenizerHandle handle, const char *token,
+                            size_t len, int32_t *id);
+
+void tokenizers_free(TokenizerHandle handle);
+
+#ifdef __cplusplus
+}
+#endif
+#endif // TOKENIZERS_C_H_

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

@@ -0,0 +1,88 @@
+#define C10_USING_CUSTOM_GENERATED_MACROS
+#pragma once
+
+/* 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
+ * hitting this file, make sure you start with the background here:
+ * - Linux: https://gcc.gnu.org/wiki/Visibility
+ * - Windows:
+ * https://docs.microsoft.com/en-us/cpp/cpp/dllexport-dllimport?view=vs-2017
+ *
+ * Do NOT include this file directly. Instead, use c10/macros/Macros.h
+ */
+
+// You do not need to edit this part of file unless you are changing the core
+// pytorch export abstractions.
+//
+// This part defines the C10 core export and import macros. This is controlled
+// by whether we are building shared libraries or not, which is determined
+// during build time and codified in c10/core/cmake_macros.h.
+// When the library is built as a shared lib, EXPORT and IMPORT will contain
+// visibility attributes. If it is being built as a static lib, then EXPORT
+// and IMPORT basically have no effect.
+
+// As a rule of thumb, you should almost NEVER mix static and shared builds for
+// libraries that depend on c10. AKA, if c10 is built as a static library, we
+// recommend everything dependent on c10 to be built statically. If c10 is built
+// as a shared library, everything dependent on it should be built as shared. In
+// the PyTorch project, all native libraries shall use the macro
+// C10_BUILD_SHARED_LIB to check whether pytorch is building shared or static
+// libraries.
+
+// For build systems that do not directly depend on CMake and directly build
+// from the source directory (such as Buck), one may not have a cmake_macros.h
+// file at all. In this case, the build system is responsible for providing
+// correct macro definitions corresponding to the cmake_macros.h.in file.
+//
+// In such scenarios, one should define the macro
+//     C10_USING_CUSTOM_GENERATED_MACROS
+// to inform this header that it does not need to include the cmake_macros.h
+// file.
+
+#ifdef _WIN32
+#define C10_HIDDEN
+#if defined(C10_BUILD_SHARED_LIBS)
+#define C10_EXPORT __declspec(dllexport)
+#define C10_IMPORT __declspec(dllimport)
+#else
+#define C10_EXPORT
+#define C10_IMPORT
+#endif
+#else // _WIN32
+#if defined(__GNUC__)
+#define C10_EXPORT __attribute__((__visibility__("default")))
+#define C10_HIDDEN __attribute__((__visibility__("hidden")))
+#else // defined(__GNUC__)
+#define C10_EXPORT
+#define C10_HIDDEN
+#endif // defined(__GNUC__)
+#define C10_IMPORT C10_EXPORT
+#endif // _WIN32
+
+#ifdef NO_EXPORT
+#undef C10_EXPORT
+#define C10_EXPORT
+#endif
+
+// Definition of an adaptive XX_API macro, that depends on whether you are
+// building the library itself or not, routes to XX_EXPORT and XX_IMPORT.
+// Basically, you will need to do this for each shared library that you are
+// building, and the instruction is as follows: assuming that you are building
+// a library called libawesome.so. You should:
+// (1) for your cmake target (usually done by "add_library(awesome, ...)"),
+//     define a macro called AWESOME_BUILD_MAIN_LIB using
+//     target_compile_options.
+// (2) define the AWESOME_API macro similar to the one below.
+// And in the source file of your awesome library, use AWESOME_API to
+// annotate public symbols.
+
+// Here, for the C10 library, we will define the macro C10_API for both import
+// and export.
+
+// This one is being used by libc10.so
+#ifdef C10_BUILD_MAIN_LIB
+#define C10_API C10_EXPORT
+#else
+#define C10_API C10_IMPORT
+#endif

package/third-party/ios/ExecutorchLib.xcframework/Info.plist

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>ExecutorchLib.framework/ExecutorchLib</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>ExecutorchLib.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>ExecutorchLib.framework/ExecutorchLib</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64-simulator</string>
+			<key>LibraryPath</key>
+			<string>ExecutorchLib.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>