react-native-executorch 0.5.2 → 0.5.4

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/runtime/platform/profiler.h

@@ -1,292 +0,0 @@
-/*
- * 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/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/runtime/platform/runtime.h

@@ -1,35 +0,0 @@
-/*
- * 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/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/runtime/platform/system.h

@@ -1,49 +0,0 @@
-/*
- * 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/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/runtime/platform/types.h

@@ -1,24 +0,0 @@
-/*
- * 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/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/executorch/schema/extended_header.h

@@ -1,76 +0,0 @@
-/*
- * 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.
-   */
-  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;
-};
-
-} // namespace runtime
-} // namespace executorch

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64/Headers/module.modulemap

@@ -1,5 +0,0 @@
-module ExecuTorch {
-  umbrella header "ExecuTorch/ExecuTorch.h"
-
-  export *
-}

package/third-party/ios/ExecutorchLib/frameworks/executorch.xcframework/ios-arm64-simulator/Headers/c10/macros/Export.h

@@ -1,163 +0,0 @@
-#define C10_USING_CUSTOM_GENERATED_MACROS
-#ifndef C10_MACROS_EXPORT_H_
-#define C10_MACROS_EXPORT_H_
-
-/* 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.
-
-#ifndef C10_USING_CUSTOM_GENERATED_MACROS
-#include <c10/macros/cmake_macros.h>
-#endif // C10_USING_CUSTOM_GENERATED_MACROS
-
-#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
-
-// This one is being used by libtorch.so
-#ifdef CAFFE2_BUILD_MAIN_LIB
-#define TORCH_API C10_EXPORT
-#else
-#define TORCH_API C10_IMPORT
-#endif
-
-// You may be wondering: Whose brilliant idea was it to split torch_cuda into
-// two pieces with confusing names?
-// Once upon a time, there _was_ only TORCH_CUDA_API. All was happy until we
-// tried to compile PyTorch for CUDA 11.1, which ran into relocation marker
-// issues when linking big binaries.
-// (https://github.com/pytorch/pytorch/issues/39968) We had two choices:
-//    (1) Stop supporting so many GPU architectures
-//    (2) Do something else
-// We chose #2 and decided to split the behemoth that was torch_cuda into two
-// smaller libraries, one with most of the core kernel functions (torch_cuda_cu)
-// and the other that had..well..everything else (torch_cuda_cpp). The idea was
-// this: instead of linking our static libraries (like the hefty
-// libcudnn_static.a) with another huge library, torch_cuda, and run into pesky
-// relocation marker issues, we could link our static libraries to a smaller
-// part of torch_cuda (torch_cuda_cpp) and avoid the issues.
-
-// libtorch_cuda_cu.so
-#ifdef TORCH_CUDA_CU_BUILD_MAIN_LIB
-#define TORCH_CUDA_CU_API C10_EXPORT
-#elif defined(BUILD_SPLIT_CUDA)
-#define TORCH_CUDA_CU_API C10_IMPORT
-#endif
-
-// libtorch_cuda_cpp.so
-#ifdef TORCH_CUDA_CPP_BUILD_MAIN_LIB
-#define TORCH_CUDA_CPP_API C10_EXPORT
-#elif defined(BUILD_SPLIT_CUDA)
-#define TORCH_CUDA_CPP_API C10_IMPORT
-#endif
-
-// libtorch_cuda.so (where torch_cuda_cu and torch_cuda_cpp are a part of the
-// same api)
-#ifdef TORCH_CUDA_BUILD_MAIN_LIB
-#define TORCH_CUDA_CPP_API C10_EXPORT
-#define TORCH_CUDA_CU_API C10_EXPORT
-#elif !defined(BUILD_SPLIT_CUDA)
-#define TORCH_CUDA_CPP_API C10_IMPORT
-#define TORCH_CUDA_CU_API C10_IMPORT
-#endif
-
-#if defined(TORCH_HIP_BUILD_MAIN_LIB)
-#define TORCH_HIP_CPP_API C10_EXPORT
-#define TORCH_HIP_API C10_EXPORT
-#else
-#define TORCH_HIP_CPP_API C10_IMPORT
-#define TORCH_HIP_API C10_IMPORT
-#endif
-
-#if defined(TORCH_XPU_BUILD_MAIN_LIB)
-#define TORCH_XPU_API C10_EXPORT
-#else
-#define TORCH_XPU_API C10_IMPORT
-#endif
-
-// Enums only need to be exported on windows for non-CUDA files
-#if defined(_WIN32) && defined(__CUDACC__)
-#define C10_API_ENUM C10_API
-#else
-#define C10_API_ENUM
-#endif
-
-#endif // C10_MACROS_MACROS_H_