react-native-executorch 0.4.10 → 0.5.0-nightly-6f4dd53-20251211

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

@@ -0,0 +1,201 @@
+/*
+ * 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
+ * Compiler utility macros.
+ */
+
+#pragma once
+
+/*
+ * Compiler support checks. Follows the logic used by pytorch/c10/util/C++17.h
+ * but may support older versions.
+ */
+
+// https://gcc.gnu.org/projects/cxx-status.html#cxx17
+#if !defined(__clang__) && !defined(_MSC_VER) && defined(__GNUC__) &&          \
+    __GNUC__ < 7
+#error                                                                         \
+    "You're trying to build ExecuTorch with a too old version of GCC. We need GCC 7 or later."
+#endif
+
+// https://clang.llvm.org/cxx_status.html#cxx17
+#if defined(__clang__) && __clang_major__ < 5
+#error                                                                         \
+    "You're trying to build ExecuTorch with a too old version of Clang. We need Clang 5 or later."
+#endif
+
+#if (defined(_MSC_VER) && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)) ||   \
+    (!defined(_MSC_VER) && __cplusplus < 201703L)
+#error "You need C++17 to compile ExecuTorch"
+#endif
+
+#if defined(_MSC_VER) && (defined(min) || defined(max))
+#error                                                                         \
+    "Macro clash with min and max -- define NOMINMAX when compiling your program on Windows"
+#endif
+
+/*
+ * Define annotations aliasing C++ declaration attributes.
+ * See all C++ declaration attributes here:
+ *   https://en.cppreference.com/w/cpp/language/attributes
+ *
+ * Note that ExecuTorch supports a lower C++ standard version than all standard
+ * attributes. Therefore, some annotations are defined using their Clang/GNU
+ * counterparts.
+ *
+ * GNU attribute definitions:
+ *   https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html
+ */
+
+#define ET_NORETURN [[noreturn]]
+#define ET_NOINLINE __attribute__((noinline))
+#define ET_INLINE __attribute__((always_inline)) inline
+#define ET_INLINE_ATTRIBUTE __attribute__((always_inline))
+
+#if defined(__GNUC__)
+
+#define ET_UNREACHABLE() __builtin_unreachable()
+
+#elif defined(_MSC_VER)
+
+#define ET_UNREACHABLE() __assume(0)
+
+#else // defined(__GNUC__)
+
+#define ET_UNREACHABLE()                                                       \
+  while (1)                                                                    \
+    ;
+
+#endif // defined(__GNUC__)
+
+#define ET_DEPRECATED [[deprecated]]
+#define ET_EXPERIMENTAL                                                        \
+  [[deprecated("This API is experimental and may change without notice.")]]
+#define ET_FALLTHROUGH [[fallthrough]]
+#define ET_NODISCARD [[nodiscard]]
+#define ET_UNUSED [[maybe_unused]]
+
+// UNLIKELY Macro
+// example
+// if ET_UNLIKELY(a > 10 && b < 5) {
+//   do something
+// }
+#if (__cplusplus) >= 202002L
+
+#define ET_LIKELY(expr) (expr) [[likely]]
+#define ET_UNLIKELY(expr) (expr) [[unlikely]]
+
+#else
+
+#define ET_LIKELY(expr) (expr)
+#define ET_UNLIKELY(expr) (expr)
+
+#endif // (__cplusplus) >= 202002L
+
+/// Define a C symbol with weak linkage.
+#ifdef _MSC_VER
+// There currently doesn't seem to be a great way to do this in Windows and
+// given that weak linkage is not really critical on Windows, we'll just leave
+// it as a stub.
+#define ET_WEAK
+#else
+#define ET_WEAK __attribute__((weak))
+#endif
+
+/**
+ * Annotation marking a function as printf-like, providing compiler support
+ * for format string argument checking.
+ */
+#ifdef _MSC_VER
+#include <sal.h>
+#define ET_PRINTFLIKE(_string_index, _va_index) _Printf_format_string_
+#else
+#define ET_PRINTFLIKE(_string_index, _va_index)                                \
+  __attribute__((format(printf, _string_index, _va_index)))
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(x) (0)
+#endif
+
+#if __has_builtin(__builtin_strrchr)
+/// Name of the source file without a directory string.
+#define ET_SHORT_FILENAME (__builtin_strrchr("/" __FILE__, '/') + 1)
+#else
+#define ET_SHORT_FILENAME __FILE__
+#endif
+
+#if __has_builtin(__builtin_LINE)
+/// Current line as an integer.
+#define ET_LINE __builtin_LINE()
+#else
+#define ET_LINE __LINE__
+#endif // __has_builtin(__builtin_LINE)
+
+#if __has_builtin(__builtin_FUNCTION)
+/// Name of the current function as a const char[].
+#define ET_FUNCTION __builtin_FUNCTION()
+#else
+#define ET_FUNCTION __FUNCTION__
+#endif // __has_builtin(__builtin_FUNCTION)
+
+// 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.
+// https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html
+#ifndef ET_HAVE_GNU_STATEMENT_EXPRESSIONS
+#if (defined(__GNUC__) && __GNUC__ >= 3) || defined(__clang__)
+#define ET_HAVE_GNU_STATEMENT_EXPRESSIONS 1
+#else
+#define ET_HAVE_GNU_STATEMENT_EXPRESSIONS 0
+#endif
+#endif // ifndef
+
+// Define size_t and ssize_t.
+#ifndef _MSC_VER
+#include <sys/types.h>
+#else
+#include <stddef.h>
+using ssize_t = ptrdiff_t;
+#endif
+
+#ifdef __EXCEPTIONS
+#define ET_HAS_EXCEPTIONS 1
+#elif defined(_MSC_VER) && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
+#define ET_HAS_EXCEPTIONS 1
+#else
+#define ET_HAS_EXCEPTIONS 0
+#endif
+
+// DEPRECATED: Use the non-underscore-prefixed versions instead.
+// TODO(T199005537): Remove these once all users have stopped using them.
+#define __ET_DEPRECATED ET_DEPRECATED
+#define __ET_FALLTHROUGH ET_FALLTHROUGH
+#define __ET_FUNCTION ET_FUNCTION
+#define __ET_HAVE_GNU_STATEMENT_EXPRESSIONS ET_HAVE_GNU_STATEMENT_EXPRESSIONS
+#define __ET_INLINE ET_INLINE
+#define __ET_LIKELY ET_LIKELY
+#define __ET_LINE ET_LINE
+#define __ET_NODISCARD ET_NODISCARD
+#define __ET_NOINLINE ET_NOINLINE
+#define __ET_NORETURN ET_NORETURN
+#define __ET_PRINTFLIKE ET_PRINTFLIKE
+#define __ET_SHORT_FILENAME ET_SHORT_FILENAME
+#define __ET_UNLIKELY ET_UNLIKELY
+#define __ET_UNREACHABLE ET_UNREACHABLE
+#define __ET_UNUSED ET_UNUSED
+#define __ET_WEAK ET_WEAK

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

@@ -0,0 +1,177 @@
+/*
+ * 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
+ * ExecuTorch logging API.
+ */
+
+#pragma once
+
+#include <cstdarg>
+#include <cstddef>
+#include <cstdlib>
+
+#include <executorch/runtime/platform/compiler.h>
+#include <executorch/runtime/platform/types.h>
+
+// Set minimum log severity if compiler option is not provided.
+#ifndef ET_MIN_LOG_LEVEL
+#define ET_MIN_LOG_LEVEL Info
+#endif // !defined(ET_MIN_LOG_LEVEL)
+
+/*
+ * Enable logging by default if compiler option is not provided.
+ * This should facilitate less confusion for those developing ExecuTorch.
+ */
+#ifndef ET_LOG_ENABLED
+#define ET_LOG_ENABLED 1
+#endif // !defined(ET_LOG_ENABLED)
+
+// Even though it is supposed to be "portable" some toolchains
+// do not define, so providing a definition here
+#ifndef PRIu64
+#define PRIu64 "llu"
+#endif
+#ifndef PRId64
+#define PRId64 "lld"
+#endif
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Severity level of a log message. Must be ordered from lowest to highest
+ * severity.
+ */
+enum class LogLevel : uint8_t {
+  /**
+   * Log messages provided for highly granular debuggability.
+   *
+   * Log messages using this severity are unlikely to be compiled by default
+   * into most debug builds.
+   */
+  Debug,
+
+  /**
+   * Log messages providing information about the state of the system
+   * for debuggability.
+   */
+  Info,
+
+  /**
+   * Log messages about errors within ExecuTorch during runtime.
+   */
+  Error,
+
+  /**
+   * Log messages that precede a fatal error. However, logging at this level
+   * does not perform the actual abort, something else needs to.
+   */
+  Fatal,
+
+  /**
+   * Number of supported log levels, with values in [0, NumLevels).
+   */
+  NumLevels,
+};
+
+namespace internal {
+
+/**
+ * Get the current timestamp to construct a log event.
+ *
+ * @retval Monotonically non-decreasing timestamp in system ticks.
+ */
+et_timestamp_t get_log_timestamp();
+
+/**
+ * Log a string message.
+ *
+ * Note: This is an internal function. Use the `ET_LOG` macro instead.
+ *
+ * @param[in] level Log severity level.
+ * @param[in] timestamp Timestamp (in system ticks) of the log event.
+ * @param[in] filename Name of the source file creating the log event.
+ * @param[in] function Name of the function creating the log event.
+ * @param[in] line Source file line of the caller.
+ * @param[in] format Format string.
+ * @param[in] args Variable argument list.
+ */
+ET_PRINTFLIKE(6, 0)
+void vlogf(LogLevel level, et_timestamp_t timestamp, const char *filename,
+           const char *function, size_t line, const char *format, va_list args);
+
+/**
+ * Log a string message.
+ *
+ * Note: This is an internal function. Use the `ET_LOG` macro instead.
+ *
+ * @param[in] level Log severity level.
+ * @param[in] timestamp Timestamp (in system ticks) of the log event.
+ * @param[in] filename Name of the source file creating the log event.
+ * @param[in] function Name of the function creating the log event.
+ * @param[in] line Source file line of the caller.
+ * @param[in] format Format string.
+ */
+ET_PRINTFLIKE(6, 7)
+inline void logf(LogLevel level, et_timestamp_t timestamp, const char *filename,
+                 const char *function, size_t line, const char *format, ...) {
+#if ET_LOG_ENABLED
+  va_list args;
+  va_start(args, format);
+  internal::vlogf(level, timestamp, filename, function, line, format, args);
+  va_end(args);
+#endif // ET_LOG_ENABLED
+}
+
+} // namespace internal
+
+} // namespace runtime
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::runtime::LogLevel;
+} // namespace executor
+} // namespace torch
+
+#if ET_LOG_ENABLED
+
+/**
+ * Log a message at the given log severity level.
+ *
+ * @param[in] _level Log severity level.
+ * @param[in] _format Log message format string.
+ */
+#define ET_LOG(_level, _format, ...)                                           \
+  do {                                                                         \
+    const auto _log_level = ::executorch::runtime::LogLevel::_level;           \
+    if (static_cast<uint32_t>(_log_level) >=                                   \
+        static_cast<uint32_t>(                                                 \
+            ::executorch::runtime::LogLevel::ET_MIN_LOG_LEVEL)) {              \
+      const auto _timestamp =                                                  \
+          ::executorch::runtime::internal::get_log_timestamp();                \
+      ::executorch::runtime::internal::logf(_log_level, _timestamp,            \
+                                            ET_SHORT_FILENAME, ET_FUNCTION,    \
+                                            ET_LINE, _format, ##__VA_ARGS__);  \
+    }                                                                          \
+  } while (0)
+#else // ET_LOG_ENABLED
+
+/**
+ * Log a message at the given log severity level.
+ *
+ * @param[in] _level Log severity level.
+ * @param[in] _format Log message format string.
+ */
+#define ET_LOG(_level, _format, ...) ((void)0)
+
+#endif // ET_LOG_ENABLED

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

@@ -0,0 +1,259 @@
+/*
+ * 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
+ * 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
+
+// Use C-style includes so that C code can include this header.
+#include <stddef.h>
+#include <stdint.h>
+
+#include <executorch/runtime/platform/compiler.h>
+#include <executorch/runtime/platform/types.h>
+
+/**
+ * Clients should neither define nor use this macro. Used to optionally declare
+ * the et_pal_*() functions as weak symbols.
+ *
+ * This provides a way to both:
+ * - Include the header and define weak symbols (used by the internal default
+ *   implementations)
+ * - Include the header and define strong symbols (used by client overrides)
+ */
+#ifndef ET_INTERNAL_PLATFORM_WEAKNESS
+#define ET_INTERNAL_PLATFORM_WEAKNESS
+#endif
+
+extern "C" {
+
+/**
+ * Represents the conversion ratio from system ticks to nanoseconds.
+ * To convert, use nanoseconds = ticks * numerator / denominator.
+ */
+typedef struct {
+  uint64_t numerator;
+  uint64_t denominator;
+} et_tick_ratio_t;
+
+/**
+ * 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 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.
+ *
+ * @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.
+ * 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
+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
+ * uppercase letters.
+ */
+typedef enum {
+  kDebug = 'D',
+  kInfo = 'I',
+  kError = 'E',
+  kFatal = 'F',
+  kUnknown = '?', // Exception to the "uppercase letter" rule.
+} et_pal_log_level_t;
+
+/**
+ * Emit a log message via platform output (serial port, console, etc).
+ *
+ * @param[in] timestamp Timestamp of the log event in system ticks since boot.
+ * @param[in] level Severity level of the message. Must be a printable 7-bit
+ *     ASCII uppercase letter.
+ * @param[in] filename Name of the file that created the log event.
+ * @param[in] function Name of the function that created the log event.
+ * @param[in] line Line in the source file where the log event was created.
+ * @param[in] message Message string to log.
+ * @param[in] length Message string length.
+ */
+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
+ * 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 *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().
+ *
+ * @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