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

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

@@ -0,0 +1,292 @@
+/*
+ * 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 <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace executorch {
+namespace runtime {
+
+// Version string used to check for compatibility with post-processing
+// tool
+#define ET_PROF_VER 0x00000001
+
+// By default we support profiling upto 1024 perf events. Build
+// targets can override this to increase the profiling buffer size
+// during compilation.
+#ifndef MAX_PROFILE_EVENTS
+#define MAX_PROFILE_EVENTS 1024
+#endif
+// By default we support profiling upto 1024 memory allocation events.
+// Build targets can choose to override this, which will consequently have
+// the effect of increasing/decreasing the profiling buffer size.
+#ifndef MAX_MEM_PROFILE_EVENTS
+#define MAX_MEM_PROFILE_EVENTS 1024
+#endif
+// By default we support profiling only upto 16 allocators. If users
+// have more allocators than these then they can override this during
+// compilation time. There will be an increase/decrease in the profiling
+// buffer size based on the way this value is changed.
+#ifndef MEM_PROFILE_MAX_ALLOCATORS
+#define MEM_PROFILE_MAX_ALLOCATORS 32
+#endif
+// By default we support only one profiling block. If users want to profile
+// something that will be iterated on multiple times then they will have to
+// increment this to support their use case. In post-processing the stats for
+// all these iterations will be consolidated.
+#ifndef MAX_PROFILE_BLOCKS
+#define MAX_PROFILE_BLOCKS 2
+#endif
+
+#define PROF_NAME_MAX_LEN 32
+
+typedef struct alignas(8) {
+  union {
+    const char *name_str;
+    char name[PROF_NAME_MAX_LEN];
+  };
+  // chain_idx == -1 is a null value, when profile event happens out of chain
+  // execution
+  int32_t chain_idx;
+  uint32_t instruction_idx;
+  uint64_t start_time;
+  uint64_t end_time;
+} prof_event_t;
+
+typedef struct alignas(8) {
+  uint32_t allocator_id;
+  uint32_t allocation_size;
+} mem_prof_event_t;
+
+typedef struct alignas(8) {
+  char name[PROF_NAME_MAX_LEN];
+  uint64_t allocator_id;
+} prof_allocator_t;
+
+typedef struct alignas(8) {
+  uint8_t *prof_data;
+  uint32_t num_bytes;
+  uint32_t num_blocks;
+} prof_result_t;
+
+typedef struct alignas(8) {
+  char name[32];
+  uint32_t prof_ver;
+  uint32_t max_prof_entries;
+  uint32_t prof_entries;
+  uint32_t max_allocator_entries;
+  uint32_t allocator_entries;
+  uint32_t max_mem_prof_entries;
+  uint32_t mem_prof_entries;
+} prof_header_t;
+
+/*
+This is what the layout of the profiling buffer looks like.
+---------------------------------------
+| Profiling header                    |
+---------------------------------------
+| Profile events (Perf events)        |
+---------------------------------------
+| Memory allocators info              |
+---------------------------------------
+| Profile events (Memory allocations) |
+---------------------------------------
+*/
+
+// offsets of the various sections in the profiling buffer
+// Total size required for profiling buffer
+constexpr uint32_t prof_buf_size =
+    sizeof(prof_header_t) + sizeof(prof_event_t) * MAX_PROFILE_EVENTS +
+    sizeof(mem_prof_event_t) * MAX_MEM_PROFILE_EVENTS +
+    sizeof(prof_allocator_t) * MEM_PROFILE_MAX_ALLOCATORS;
+
+constexpr size_t prof_header_offset = 0;
+constexpr size_t prof_events_offset = sizeof(prof_header_t);
+constexpr size_t prof_mem_alloc_info_offset =
+    prof_events_offset + sizeof(prof_event_t) * MAX_PROFILE_EVENTS;
+constexpr size_t prof_mem_alloc_events_offset =
+    prof_mem_alloc_info_offset +
+    sizeof(prof_allocator_t) * MEM_PROFILE_MAX_ALLOCATORS;
+
+// Set the initial state for the profiler assuming we're using the
+// statically allocated buffer declared in the profiler module.
+void profiler_init(void);
+
+// This starts the profiling of this event and returns a token
+// by which this event can be referred to in the future.
+uint32_t begin_profiling(const char *name);
+
+// End profiling event represented by token_id
+void end_profiling(uint32_t token_id);
+
+// Dump profiler results, return pointer to prof event array and number of
+// events in it.
+void dump_profile_stats(prof_result_t *prof_result);
+
+void reset_profile_stats();
+
+void track_allocation(int32_t id, uint32_t size);
+
+uint32_t track_allocator(const char *name);
+
+void profiling_create_block(const char *name);
+
+// This class enables scope based profiling where needed. Profiling
+// will be started when the object is created and will end when the
+// object goes out of scope.
+class ExecutorchProfiler {
+public:
+  explicit ExecutorchProfiler(const char *name);
+
+  ~ExecutorchProfiler();
+
+private:
+  uint32_t prof_tok;
+};
+
+typedef struct {
+  int32_t chain_idx;
+  uint32_t instruction_idx;
+} prof_state_t;
+
+const prof_state_t &get_profile_tls_state();
+
+void set_profile_tls_state(const prof_state_t &state);
+
+class ExecutorchProfilerInstructionScope {
+public:
+  explicit ExecutorchProfilerInstructionScope(const prof_state_t &state);
+  ~ExecutorchProfilerInstructionScope();
+
+  // ScopeGuard: non-copyable, non-movable
+  ExecutorchProfilerInstructionScope(
+      const ExecutorchProfilerInstructionScope &) = delete;
+  ExecutorchProfilerInstructionScope &
+  operator=(const ExecutorchProfilerInstructionScope &) = delete;
+
+  ExecutorchProfilerInstructionScope(ExecutorchProfilerInstructionScope &&) =
+      delete;
+  ExecutorchProfilerInstructionScope &
+  operator=(ExecutorchProfilerInstructionScope &&) = delete;
+
+private:
+  prof_state_t old_state_;
+};
+
+} // 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::begin_profiling;
+using ::executorch::runtime::dump_profile_stats;
+using ::executorch::runtime::end_profiling;
+using ::executorch::runtime::ExecutorchProfiler;
+using ::executorch::runtime::ExecutorchProfilerInstructionScope;
+using ::executorch::runtime::get_profile_tls_state;
+using ::executorch::runtime::mem_prof_event_t;
+using ::executorch::runtime::prof_allocator_t;
+using ::executorch::runtime::prof_buf_size;
+using ::executorch::runtime::prof_event_t;
+using ::executorch::runtime::prof_events_offset;
+using ::executorch::runtime::prof_header_offset;
+using ::executorch::runtime::prof_header_t;
+using ::executorch::runtime::prof_mem_alloc_events_offset;
+using ::executorch::runtime::prof_mem_alloc_info_offset;
+using ::executorch::runtime::prof_result_t;
+using ::executorch::runtime::prof_state_t;
+using ::executorch::runtime::profiler_init;
+using ::executorch::runtime::profiling_create_block;
+using ::executorch::runtime::reset_profile_stats;
+using ::executorch::runtime::set_profile_tls_state;
+using ::executorch::runtime::track_allocation;
+using ::executorch::runtime::track_allocator;
+} // namespace executor
+} // namespace torch
+
+#ifdef PROFILING_ENABLED
+
+#define EXECUTORCH_PROFILE_CREATE_BLOCK(name)                                  \
+  ::executorch::runtime::profiling_create_block(name);
+
+// Convenience macros to begin and end profiling. These can be inserted
+// anywhere as it'll be ensured that for the prod builds these will
+// essentially be noops.
+#define EXECUTORCH_BEGIN_PROF(name)                                            \
+  ::executorch::runtime::begin_profiling(name);
+
+#define EXECUTORCH_END_PROF(token_id)                                          \
+  ::executorch::runtime::end_profiling(token_id);
+
+#define EXECUTORCH_SCOPE_PROF(name)                                            \
+  ::executorch::runtime::ExecutorchProfiler profiler(name);
+
+#define EXECUTORCH_PROFILE_INSTRUCTION_SCOPE(chain_idx, instruction_idx)       \
+  ::executorch::runtime::ExecutorchProfilerInstructionScope                    \
+      __profiler_instruction_scope({chain_idx, instruction_idx});
+
+#define EXECUTORCH_DUMP_PROFILE_RESULTS(prof_result)                           \
+  ::executorch::runtime::dump_profile_stats(prof_result);
+
+#define EXECUTORCH_RESET_PROFILE_RESULTS()                                     \
+  ::executorch::runtime::reset_profile_stats();
+
+#define EXECUTORCH_TRACK_ALLOCATOR(name)                                       \
+  ::executorch::runtime::track_allocator(name);
+
+#define EXECUTORCH_TRACK_ALLOCATION(id, size)                                  \
+  ::executorch::runtime::track_allocation(id, size);
+
+#else
+
+#define EXECUTORCH_PROFILE_CREATE_BLOCK(name)                                  \
+  do {                                                                         \
+    (void)(name);                                                              \
+  } while (0)
+
+#define EXECUTORCH_BEGIN_PROF(name)                                            \
+  {                                                                            \
+  }
+
+#define EXECUTORCH_END_PROF(token_id)                                          \
+  do {                                                                         \
+    (void)(token_id);                                                          \
+  } while (0)
+
+#define EXECUTORCH_SCOPE_PROF(name)                                            \
+  do {                                                                         \
+    (void)(name);                                                              \
+  } while (0)
+
+#define EXECUTORCH_PROFILE_INSTRUCTION_SCOPE(chain_idx, instruction_idx)       \
+  do {                                                                         \
+    (void)(chain_idx);                                                         \
+    (void)(instruction_idx);                                                   \
+  } while (0)
+
+#define EXECUTORCH_DUMP_PROFILE_RESULTS(prof_result_test)                      \
+  memset(prof_result_test, 0, sizeof(::executorch::runtime::prof_result_t));
+
+#define EXECUTORCH_RESET_PROFILE_RESULTS()                                     \
+  {                                                                            \
+  }
+
+#define EXECUTORCH_TRACK_ALLOCATOR(name) ((void)(name), -1)
+
+#define EXECUTORCH_TRACK_ALLOCATION(id, size)                                  \
+  do {                                                                         \
+    (void)(id);                                                                \
+    (void)(size);                                                              \
+  } while (0)
+
+#endif

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

@@ -0,0 +1,35 @@
+/*
+ * 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 global runtime wrapper functions.
+ */
+
+#pragma once
+
+#include <executorch/runtime/platform/compiler.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * Initialize the ExecuTorch global runtime.
+ */
+void runtime_init();
+
+} // 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::runtime_init;
+} // namespace executor
+} // namespace torch

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

@@ -0,0 +1,49 @@
+/*
+ * 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 host OS to override
+ * symbols in ExecuTorch. PAL functions are defined as C functions so an
+ * implementer can use C in lieu of C++.
+ */
+#pragma once
+
+/**
+ * To enable dynamic linking debugging capability on UNIX-like OS. If enabled
+ * and see an error like: `undefined symbol: dladdr`, install `libdl` to fix.
+ */
+#if defined(ET_USE_LIBDL)
+#include <dlfcn.h>
+#endif
+
+static constexpr const char *DYNAMIC_LIBRARY_NOT_SUPPORTED = "NOT_SUPPORTED";
+static constexpr const char *DYNAMIC_LIBRARY_NOT_FOUND = "NOT_FOUND";
+
+extern "C" {
+
+/**
+ * Return shared library .
+ *
+ * @param[in] addr Address to the symbol we are looking for in shared libraries.
+ * @retval The path to the shared library containing the symbol.
+ */
+inline const char *et_pal_get_shared_library_name(const void *addr) {
+#if defined(ET_USE_LIBDL)
+  Dl_info info;
+  if (dladdr(addr, &info) && info.dli_fname) {
+    return info.dli_fname;
+  } else {
+    return DYNAMIC_LIBRARY_NOT_FOUND;
+  }
+#endif
+  (void)addr;
+  return DYNAMIC_LIBRARY_NOT_SUPPORTED;
+}
+
+} // extern "C"

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

@@ -0,0 +1,24 @@
+/*
+ * 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
+ * Public types used by the ExecuTorch Platform Abstraction Layer.
+ */
+
+#pragma once
+
+// Use C-style includes so that C code can include this header.
+#include <stdint.h>
+
+extern "C" {
+
+/// Platform timestamp in system ticks.
+typedef uint64_t et_timestamp_t;
+
+} // extern "C"

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

@@ -0,0 +1,85 @@
+/*
+ * 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/result.h>
+
+namespace executorch {
+namespace runtime {
+
+/**
+ * An extended, ExecuTorch-specific header that may be embedded in the
+ * serialized Program data header.
+ *
+ * For details see //executorch/docs/source/pte-file-format.md
+ */
+struct ExtendedHeader {
+  /**
+   * To find the header, callers should provide at least this many bytes of the
+   * 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;
+
+  /**
+   * The offset into the Program serialized program data where the extended
+   * header should begin.
+   */
+  static constexpr size_t kHeaderOffset = 8;
+
+  /**
+   * The magic bytes that identify the header.
+   *
+   * This is the canonical definition of the expected value. If the header
+   * layout ever changes in a compatibility-breaking way, increment the digits
+   * in the magic. But, doing so will prevent older binaries from recognizing
+   * the presence of the header. The compatibility-preserving way to make
+   * changes is to increase the header's length field and add new fields at the
+   * end.
+   */
+  static constexpr size_t kMagicSize = 4;
+  static constexpr char kMagic[kMagicSize] = {'e', 'h', '0', '0'};
+
+  /**
+   * Look for and parse an ExtendedHeader in the provided data.
+   *
+   * @param[in] data The contents of the beginning of the serialized binary
+   *     Program data, starting at offset 0 (i.e., the head of the file).
+   * @param[in] size Length of `data` in bytes. Must be >= kNumHeadBytes or this
+   *     call will fail.
+   *
+   * @returns an ExtendedHeader if the header was found and is valid. Returns an
+   *     error if size was too short, if the header was not found, or if the
+   *     header appeared to be corrupt.
+   */
+  static Result<ExtendedHeader> Parse(const void *data, size_t size);
+
+  /**
+   * The size in bytes of the Program flatbuffer data, starting from offset
+   * zero.
+   */
+  uint64_t program_size;
+
+  /**
+   * The offset in bytes of the first segment, if present. Zero if no segment
+   * 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
+} // namespace executorch

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