remove extra files

arm64-v8a/include/onnxruntime/core/common/basic_types.h

@@ -1,19 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <cstdint>
-
-namespace onnxruntime {
-
-/** A computed hash value. */
-using HashValue = uint64_t;
-
-/** The type of an argument (input or output).*/
-enum class ArgType : uint8_t {
-  kInput,
-  kOutput,
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/code_location.h

@@ -1,58 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace onnxruntime {
-/**
-   CodeLocation captures information on where in the source code a message came from.
-*/
-struct CodeLocation {
-  /**
-     @param file_path Usually the value of __FILE__
-     @param line Usually the value of __LINE__
-     @param func Usually the value of __PRETTY_FUNCTION__ or __FUNCTION__
-  */
-  CodeLocation(const char* file_path, const int line, const char* func)
-      : file_and_path{file_path}, line_num{line}, function{func} {
-  }
-
-  /**
-     @param file_path Usually the value of __FILE__
-     @param line Usually the value of __LINE__
-     @param func Usually the value of __PRETTY_FUNCTION__ or __FUNCTION__
-     @param stacktrace Stacktrace from source of message.
-  */
-  CodeLocation(const char* file_path, const int line, const char* func, const std::vector<std::string>& stacktrace)
-      : file_and_path{file_path}, line_num{line}, function{func}, stacktrace(stacktrace) {
-  }
-
-  std::string FileNoPath() const {
-    // assuming we always have work to do, so not trying to avoid creating a new string if
-    // no path was removed.
-    return file_and_path.substr(file_and_path.find_last_of("/\\") + 1);
-  }
-
-  enum Format {
-    kFilename,
-    kFilenameAndPath
-  };
-
-  std::string ToString(Format format = Format::kFilename) const {
-    std::ostringstream out;
-    out << (format == Format::kFilename ? FileNoPath() : file_and_path) << ":" << line_num << " " << function;
-    return out.str();
-  }
-  //utf-8. Because on Windows we compile our code with "/utf-8". And we assume the other platforms only use utf-8.
-  const std::string file_and_path;
-  const int line_num;
-  //utf-8
-  const std::string function;
-  const std::vector<std::string> stacktrace;
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/common.h

@@ -1,287 +0,0 @@
-/**
- * Copyright (c) 2016-present, Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// Portions Copyright (c) Microsoft Corporation
-
-#pragma once
-
-#include <climits>
-#include <cstring>
-#include <algorithm>
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <numeric>
-#include <set>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "core/common/code_location.h"
-#include "core/common/exceptions.h"
-#include "core/common/make_string.h"
-#include "core/common/status.h"
-
-
-namespace onnxruntime {
-
-using TimePoint = std::chrono::high_resolution_clock::time_point;
-
-#ifdef _WIN32
-#define ORT_UNUSED_PARAMETER(x) (x)
-#else
-#define ORT_UNUSED_PARAMETER(x) (void)(x)
-#endif
-
-#ifndef ORT_HAVE_ATTRIBUTE
-#ifdef __has_attribute
-#define ORT_HAVE_ATTRIBUTE(x) __has_attribute(x)
-#else
-#define ORT_HAVE_ATTRIBUTE(x) 0
-#endif
-#endif
-
-// ORT_ATTRIBUTE_UNUSED
-//
-// Prevents the compiler from complaining about or optimizing away variables
-// that appear unused on Linux
-#if ORT_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
-#undef ORT_ATTRIBUTE_UNUSED
-#define ORT_ATTRIBUTE_UNUSED __attribute__((__unused__))
-#else
-#define ORT_ATTRIBUTE_UNUSED
-#endif
-
-#ifdef ORT_NO_EXCEPTIONS
-// Print the given final message, the message must be a null terminated char*
-// ORT will abort after printing the message.
-// For Android, will print to Android system log
-// For other platforms, will print to stderr
-void PrintFinalMessage(const char* msg);
-#endif
-
-// macro to explicitly ignore the return value from a function call so Code Analysis doesn't complain
-#define ORT_IGNORE_RETURN_VALUE(fn) \
-  static_cast<void>(fn)
-
-std::vector<std::string> GetStackTrace();
-// these is a helper function that gets defined by platform/Telemetry
-void LogRuntimeError(uint32_t session_id, const common::Status& status, const char* file,
-                     const char* function, uint32_t line);
-
-// __PRETTY_FUNCTION__ isn't a macro on gcc, so use a check for _MSC_VER
-// so we only define it as one for MSVC
-#if (_MSC_VER && !defined(__PRETTY_FUNCTION__))
-#define __PRETTY_FUNCTION__ __FUNCTION__
-#endif
-
-// Capture where a message is coming from. Use __FUNCTION__ rather than the much longer __PRETTY_FUNCTION__
-#define ORT_WHERE ::onnxruntime::CodeLocation(__FILE__, __LINE__, static_cast<const char*>(__FUNCTION__))
-
-#define ORT_WHERE_WITH_STACK \
-  ::onnxruntime::CodeLocation(__FILE__, __LINE__, static_cast<const char*>(__PRETTY_FUNCTION__), ::onnxruntime::GetStackTrace())
-
-#ifdef ORT_NO_EXCEPTIONS
-
-#define ORT_TRY if (true)
-#define ORT_CATCH(x) else if (false)
-#define ORT_RETHROW
-
-// In order to ignore the catch statement when a specific exception (not ... ) is caught and referred
-// in the body of the catch statements, it is necessary to wrap the body of the catch statement into
-// a lambda function. otherwise the exception referred will be undefined and cause build break
-#define ORT_HANDLE_EXCEPTION(func)
-
-// Throw an exception with optional message.
-// NOTE: The arguments get streamed into a string via ostringstream::operator<<
-// DO NOT use a printf format string, as that will not work as you expect.
-#define ORT_THROW(...)                                                    \
-  do {                                                                    \
-    ::onnxruntime::PrintFinalMessage(                                     \
-        ::onnxruntime::OnnxRuntimeException(                              \
-            ORT_WHERE_WITH_STACK, ::onnxruntime::MakeString(__VA_ARGS__)) \
-            .what());                                                     \
-    abort();                                                              \
-  } while (false)
-
-// Just in order to mark things as not implemented. Do not use in final code.
-#define ORT_NOT_IMPLEMENTED(...)                                                       \
-  do {                                                                                 \
-    ::onnxruntime::PrintFinalMessage(                                                  \
-        ::onnxruntime::NotImplementedException(::onnxruntime::MakeString(__VA_ARGS__)) \
-            .what());                                                                  \
-    abort();                                                                           \
-  } while (false)
-
-// Check condition.
-// NOTE: The arguments get streamed into a string via ostringstream::operator<<
-// DO NOT use a printf format string, as that will not work as you expect.
-#define ORT_ENFORCE(condition, ...)                                                   \
-  do {                                                                                \
-    if (!(condition)) {                                                               \
-      ::onnxruntime::PrintFinalMessage(                                               \
-          ::onnxruntime::OnnxRuntimeException(ORT_WHERE_WITH_STACK, #condition,       \
-                                              ::onnxruntime::MakeString(__VA_ARGS__)) \
-              .what());                                                               \
-      abort();                                                                        \
-    }                                                                                 \
-  } while (false)
-
-#define ORT_THROW_EX(ex, ...)                                                                      \
-  do {                                                                                             \
-    ::onnxruntime::PrintFinalMessage(                                                              \
-        ::onnxruntime::MakeString(#ex, "(", ::onnxruntime::MakeString(__VA_ARGS__), ")").c_str()); \
-    abort();                                                                                       \
-  } while (false)
-
-#else
-
-#define ORT_TRY try
-#define ORT_CATCH(x) catch (x)
-#define ORT_RETHROW throw;
-
-#define ORT_HANDLE_EXCEPTION(func) func()
-
-// Throw an exception with optional message.
-// NOTE: The arguments get streamed into a string via ostringstream::operator<<
-// DO NOT use a printf format string, as that will not work as you expect.
-#define ORT_THROW(...) \
-  throw ::onnxruntime::OnnxRuntimeException(ORT_WHERE_WITH_STACK, ::onnxruntime::MakeString(__VA_ARGS__))
-
-// Just in order to mark things as not implemented. Do not use in final code.
-#define ORT_NOT_IMPLEMENTED(...) \
-  throw ::onnxruntime::NotImplementedException(::onnxruntime::MakeString(__VA_ARGS__))
-
-// Check condition.
-// NOTE: The arguments get streamed into a string via ostringstream::operator<<
-// DO NOT use a printf format string, as that will not work as you expect.
-#define ORT_ENFORCE(condition, ...)                                                      \
-  do {                                                                                   \
-    if (!(condition)) {                                                                  \
-      throw ::onnxruntime::OnnxRuntimeException(ORT_WHERE_WITH_STACK, #condition,        \
-                                                ::onnxruntime::MakeString(__VA_ARGS__)); \
-    }                                                                                    \
-  } while (false)
-
-#define ORT_THROW_EX(ex, ...) \
-  throw ex(__VA_ARGS__)
-
-#endif
-
-#define ORT_MAKE_STATUS(category, code, ...)                     \
-  ::onnxruntime::common::Status(::onnxruntime::common::category, \
-                                ::onnxruntime::common::code,     \
-                                ::onnxruntime::MakeString(__VA_ARGS__))
-
-// Check condition. if met, return status.
-#define ORT_RETURN_IF(condition, ...)                                                                          \
-  do {                                                                                                         \
-    if (condition) {                                                                                           \
-      return ::onnxruntime::common::Status(::onnxruntime::common::ONNXRUNTIME,                                 \
-                                           ::onnxruntime::common::FAIL,                                        \
-                                           ::onnxruntime::MakeString(ORT_WHERE.ToString(), " ", __VA_ARGS__)); \
-    }                                                                                                          \
-  } while (false)
-
-// Check condition. if not met, return status.
-#define ORT_RETURN_IF_NOT(condition, ...) \
-  ORT_RETURN_IF(!(condition), __VA_ARGS__)
-
-// Macros to disable the copy and/or move ctor and assignment methods
-// These are usually placed in the private: declarations for a class.
-
-#define ORT_DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete
-
-#define ORT_DISALLOW_ASSIGNMENT(TypeName) TypeName& operator=(const TypeName&) = delete
-
-#define ORT_DISALLOW_COPY_AND_ASSIGNMENT(TypeName) \
-  ORT_DISALLOW_COPY(TypeName);                     \
-  ORT_DISALLOW_ASSIGNMENT(TypeName)
-
-#define ORT_DISALLOW_MOVE(TypeName) \
-  TypeName(TypeName&&) = delete;    \
-  TypeName& operator=(TypeName&&) = delete
-
-#define ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(TypeName) \
-  ORT_DISALLOW_COPY_AND_ASSIGNMENT(TypeName);           \
-  ORT_DISALLOW_MOVE(TypeName)
-
-#define ORT_RETURN_IF_ERROR_SESSIONID(expr, session_id)                                                                \
-  do {                                                                                                                 \
-    auto _status = (expr);                                                                                             \
-    if ((!_status.IsOK())) {                                                                                           \
-      ::onnxruntime::LogRuntimeError(session_id, _status, __FILE__, static_cast<const char*>(__FUNCTION__), __LINE__); \
-      return _status;                                                                                                  \
-    }                                                                                                                  \
-  } while (0)
-
-#define ORT_RETURN_IF_ERROR_SESSIONID_(expr) ORT_RETURN_IF_ERROR_SESSIONID(expr, session_id_)
-#define ORT_RETURN_IF_ERROR(expr) ORT_RETURN_IF_ERROR_SESSIONID(expr, 0)
-
-#define ORT_THROW_IF_ERROR(expr)                                                                              \
-  do {                                                                                                        \
-    auto _status = (expr);                                                                                    \
-    if ((!_status.IsOK())) {                                                                                  \
-      ::onnxruntime::LogRuntimeError(0, _status, __FILE__, static_cast<const char*>(__FUNCTION__), __LINE__); \
-      ORT_THROW(_status);                                                                                     \
-    }                                                                                                         \
-  } while (0)
-
-// use this macro when cannot early return
-#define ORT_CHECK_AND_SET_RETVAL(expr) \
-  do {                                 \
-    if (retval.IsOK()) {               \
-      retval = (expr);                 \
-    }                                  \
-  } while (0)
-
-inline long long TimeDiffMicroSeconds(TimePoint start_time) {
-  auto end_time = std::chrono::high_resolution_clock::now();
-  return std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count();
-}
-
-inline long long TimeDiffMicroSeconds(TimePoint start_time, TimePoint end_time) {
-  return std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count();
-}
-
-struct null_type {};
-inline std::string ToUTF8String(const std::string& s) { return s; }
-#ifdef _WIN32
-/**
- * Convert a wide character string to a UTF-8 string
- */
-std::string ToUTF8String(const std::wstring& s);
-
-std::wstring ToWideString(const std::string& s);
-inline std::wstring ToWideString(const std::wstring& s) { return s; }
-#else
-inline std::string ToWideString(const std::string& s) { return s; }
-#endif
-
-constexpr size_t kMaxStrLen = 2048;
-
-// Returns whether `key` is in `container`.
-// Like C++20's map/set contains() member function.
-template <typename Key, typename... OtherContainerArgs,
-          template <typename...> typename AssociativeContainer,
-          typename LookupKey>
-inline bool Contains(const AssociativeContainer<Key, OtherContainerArgs...>& container, LookupKey&& key) {
-  return container.find(std::forward<LookupKey>(key)) != container.end();
-}
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/const_pointer_container.h

@@ -1,85 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <type_traits>
-
-namespace onnxruntime {
-/**
-   Container has T* entries. e.g. std::vector<T*>, and this class provides const access to those
-   via iterators and direct access, as the standard behavior only makes the pointer constant,
-   and not what is pointed too. i.e. you get a const pointer to T not a pointer to const T without this wrapper.
-   See https://stackoverflow.com/questions/8017036/understanding-const-iterator-with-pointers
-*/
-template <typename Container>
-class ConstPointerContainer {
- public:
-  using T = typename std::remove_pointer<typename Container::value_type>::type;
-
-  class ConstIterator {
-   public:
-    using const_iterator = typename Container::const_iterator;
-    using iterator_category = std::input_iterator_tag;
-    using value_type = T*;
-    using difference_type = std::ptrdiff_t;
-    using pointer = T**;
-    using reference = T*&;
-
-    /** Construct iterator for container that will return const T* entries.*/
-    explicit ConstIterator(const_iterator position) noexcept : current_{position}, item_{nullptr} {}
-    ConstIterator(const ConstIterator& other) = default;
-    ConstIterator& operator=(const ConstIterator& other) = default;
-
-    bool operator==(const ConstIterator& other) const noexcept { return current_ == other.current_; }
-    bool operator!=(const ConstIterator& other) const noexcept { return current_ != other.current_; }
-
-    ConstIterator& operator++() {
-      ++current_;
-      return *this;
-    }
-
-    ConstIterator operator++(int) {
-      ConstIterator tmp{*this};
-      ++(*this);
-      return tmp;
-    }
-
-    const T*& operator*() const {
-      item_ = *current_;
-      return item_;
-    }
-
-    const T** operator->() const { return &(operator*()); };
-
-   private:
-    const_iterator current_;
-    mutable const T* item_;
-  };
-
-  /**
-     Construct wrapper class that will provide const access to the pointers in a container of non-const pointers.
-     @param data Container with non-const pointers. e.g. std::vector<T*>
-  */
-  explicit ConstPointerContainer(const Container& data) noexcept : data_(data) {}
-
-  size_t size() const noexcept { return data_.size(); }
-  bool empty() const noexcept { return data_.empty(); }
-
-  ConstIterator cbegin() const noexcept { return ConstIterator(data_.cbegin()); }
-  ConstIterator cend() const noexcept { return ConstIterator(data_.cend()); }
-
-  ConstIterator begin() const noexcept { return ConstIterator(data_.cbegin()); }
-  ConstIterator end() const noexcept { return ConstIterator(data_.cend()); }
-
-  const T* operator[](size_t index) const { return data_[index]; }
-
-  const T* at(size_t index) const {
-    ORT_ENFORCE(index < data_.size());
-    return data_[index];
-  }
-
- private:
-  const Container& data_;
-};
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/denormal.h

@@ -1,12 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-namespace onnxruntime {
-
-// Set or unset flush-to-zero and denormal=as-zero if SSE3 instructions are supported.
-// Return true if SSE3 instruction is supported, otherwise return false.
-bool SetDenormalAsZero(bool on);
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/eigen_common_wrapper.h

@@ -1,62 +0,0 @@
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-//
-//-----------------------------------------------------------------------------
-#pragma once
-#include "onnxruntime_config.h"
-// build/external/eigen/unsupported/Eigen/CXX11/src/Tensor/TensorEvaluator.h:162:71:
-// error: ignoring attributes on template argument "Eigen::PacketType<const float, Eigen::DefaultDevice>::type {aka __vector(4) float}" [-Werror=ignored-attributes]
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#if __GNUC__ >= 6
-#pragma GCC diagnostic ignored "-Wignored-attributes"
-#endif
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic ignored "-Wunused-result"
-#ifdef HAS_DEPRECATED_COPY
-#pragma GCC diagnostic ignored "-Wdeprecated-copy"
-#endif
-// cmake/external/eigen/unsupported/Eigen/CXX11/../../../Eigen/src/Core/arch/NEON/PacketMath.h:1633:9:
-// error: ‘void* memcpy(void*, const void*, size_t)’ copying an object of non-trivial type ‘Eigen::internal::Packet4c’
-// {aka ‘struct Eigen::internal::eigen_packet_wrapper<int, 2>’} from an array of ‘const int8_t’
-// {aka ‘const signed char’} [-Werror=class-memaccess]
-#ifdef HAS_CLASS_MEMACCESS
-#pragma GCC diagnostic ignored "-Wclass-memaccess"
-#endif
-
-// cmake/external/eigen\Eigen/src/Core/util/Meta.h:454:25:
-// error: 'result_of<Eigen::internal::scalar_product_op<unsigned long long> (const unsigned long long &, const unsigned long long &)>'
-// is deprecated [-Werror,-Wdeprecated-declarations]
-//   typedef typename std::result_of<T>::type type1;
-#ifdef HAS_DEPRECATED_DECLARATIONS
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-// cmake/external/eigen\Eigen/CXX11/src/Tensor/TensorTrace.h:130:9:
-// error: variable 'num_distinct_reduce_dims' set but not used [-Werror,-Wunused-but-set-variable]
-//   int num_distinct_reduce_dims = 0;
-#ifdef HAS_UNUSED_BUT_SET_VARIABLE
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
-#endif
-
-#elif defined(_MSC_VER)
-// build\windows\debug\external\eigen3\unsupported\eigen\cxx11\src/Tensor/Tensor.h(76):
-// warning C4554: '&': check operator precedence for possible error; use parentheses to clarify precedence
-
-// unsupported\eigen\cxx11\src\Tensor\TensorUInt128.h(150,0): Warning C4245: 'initializing': conversion from '__int64'
-// to 'uint64_t', signed/unsigned mismatch
-#pragma warning(push)
-#pragma warning(disable : 4554)
-#pragma warning(disable : 4245)
-#pragma warning(disable : 4127)
-#endif
-
-#include "unsupported/Eigen/CXX11/Tensor"
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#elif defined(_MSC_VER)
-#pragma warning(pop)
-#endif

arm64-v8a/include/onnxruntime/core/common/exceptions.h

@@ -1,71 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <algorithm>
-#include <exception>
-#include <iterator>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include "core/common/common.h"
-#include "core/common/code_location.h"
-
-namespace onnxruntime {
-
-class NotImplementedException : public std::logic_error {
- public:
-  explicit NotImplementedException(const char* _Message = "Function not yet implemented") noexcept : std::logic_error(_Message){};
-  explicit NotImplementedException(const std::string& _Message = "Function not yet implemented") noexcept : std::logic_error(_Message){};
-};
-
-class TypeMismatchException : public std::logic_error {
- public:
-  TypeMismatchException() noexcept : logic_error("Type mismatch"){};
-};
-
-class OnnxRuntimeException : public std::exception {
- public:
-  OnnxRuntimeException(const CodeLocation& location, const std::string& msg) noexcept
-      : OnnxRuntimeException(location, nullptr, msg) {
-  }
-
-  /**
-     Create a new exception that captures the location it was thrown from.
-     @param location Location in the source code the exception is being thrown from
-     @param failed_condition Optional string containing the condition that failed.
-     e.g. "tensor.Size() == input.Size()". May be nullptr.
-     @param msg Message containing additional information about the exception cause.
-  */
-  OnnxRuntimeException(const CodeLocation& location, const char* failed_condition, const std::string& msg)
-      : location_{location} {
-    std::ostringstream ss;
-
-    ss << location.ToString(CodeLocation::kFilenameAndPath);  // output full path in case just the filename is ambiguous
-    if (failed_condition != nullptr) {
-      ss << " " << failed_condition << " was false.";
-    }
-
-    ss << " " << msg << "\n";
-    if (!location.stacktrace.empty()) {
-      ss << "Stacktrace:\n";
-      // skip the first entry in the stacktrace as we have that information from location.ToString()
-      std::copy(std::next(location.stacktrace.begin()), location.stacktrace.end(), std::ostream_iterator<std::string>(ss, "\n"));
-    }
-
-    what_ = ss.str();
-  }
-
-  const char* what() const noexcept override {
-    return what_.c_str();
-  }
-
- private:
-  const CodeLocation location_;
-  const std::vector<std::string> stacktrace_;
-  std::string what_;
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/gpu_profiler_common.h

@@ -1,472 +0,0 @@
-#pragma once
-
-#include "core/common/profiler_common.h"
-#include "core/common/inlined_containers.h"
-
-#include <map>
-#include <memory>
-#include <mutex>
-#include <sstream>
-#include <string>
-#include <vector>
-#include <utility>
-
-namespace onnxruntime {
-namespace profiling {
-
-// The classes in this header are implemented as template/inline classes
-// to avoid having to export symbols from the main onnxruntime shared library
-// to ExecutionProvider (EP) shared libraries.
-// More context: The main onnxruntime shared library is optimized for size
-// using --gc-sections during link time to ensure that any unreferenced code
-// is not retained. This poses a problem in using a design pattern where the
-// (abstract) base class is implemented in the main onnxruntime shared library,
-// but (concrete) subclasses are implemented in EP shared libraries. Now, because
-// EP shared libraries are loaded at runtime (as of 11/2022), there will be no
-// references to the base class symbols when the main onnxruntime shared library
-// is compiled. Thus, the base class symbols will not be included in the
-// main onnxruntime shared library. This manifests in being unable to load
-// EP shared libs (because the base class symbols referenced by derived
-// classes are missing).
-// We solve this by implementing base classes that are common to all GPU profilers
-// inline in this header.
-
-class ProfilerActivityBuffer {
- public:
-  ProfilerActivityBuffer() noexcept
-      : data_(nullptr), size_(0) {}
-
-  ProfilerActivityBuffer(const char* data, size_t size) noexcept
-      : data_(std::make_unique<char[]>(size)), size_(size) {
-    memcpy(data_.get(), data, size_);
-  }
-
-  ProfilerActivityBuffer(const ProfilerActivityBuffer& other) noexcept
-      : ProfilerActivityBuffer(other.GetData(), other.GetSize()) {}
-
-  ProfilerActivityBuffer(ProfilerActivityBuffer&& other) noexcept
-      : ProfilerActivityBuffer() {
-    std::swap(data_, other.data_);
-    std::swap(size_, other.size_);
-  }
-
-  ProfilerActivityBuffer& operator=(const ProfilerActivityBuffer& other) noexcept {
-    if (&other == this) {
-      return *this;
-    }
-
-    new (this) ProfilerActivityBuffer{other};
-    return *this;
-  }
-
-  ProfilerActivityBuffer& operator=(ProfilerActivityBuffer&& other) noexcept {
-    if (&other == this) {
-      return *this;
-    }
-
-    new (this) ProfilerActivityBuffer{std::move(other)};
-    return *this;
-  }
-
-  static ProfilerActivityBuffer CreateFromPreallocatedBuffer(std::unique_ptr<char[]>&& buffer_ptr, size_t size) {
-    ProfilerActivityBuffer res{};
-    res.data_ = std::move(buffer_ptr);
-    res.size_ = size;
-    return res;
-  }
-
-  // accessors
-  char* GetData() { return data_.get(); }
-  const char* GetData() const { return data_.get(); }
-  size_t GetSize() const { return size_; }
-
- private:
-  std::unique_ptr<char[]> data_;
-  size_t size_;
-}; /* end class ProfilerActivityBuffer */
-
-template <typename TDerived>
-class GPUTracerManager {
- public:
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(GPUTracerManager);
-  virtual ~GPUTracerManager() {}
-
-  uint64_t RegisterClient() {
-    std::lock_guard<std::mutex> lock(manager_instance_mutex_);
-    auto res = next_client_id_++;
-    per_client_events_by_ext_correlation_.insert({res, {}});
-    ++num_active_clients_;
-    return res;
-  }
-
-  void DeregisterClient(uint64_t client_handle) {
-    std::lock_guard<std::mutex> lock(manager_instance_mutex_);
-    auto it = per_client_events_by_ext_correlation_.find(client_handle);
-    if (it == per_client_events_by_ext_correlation_.end()) {
-      return;
-    }
-    per_client_events_by_ext_correlation_.erase(it);
-    --num_active_clients_;
-    if (num_active_clients_ == 0 && tracing_enabled_) {
-      StopLogging();
-    }
-  }
-
-  void StartLogging() {
-    std::lock_guard<std::mutex> lock(manager_instance_mutex_);
-    if (tracing_enabled_) {
-      return;
-    }
-
-    auto this_as_derived = static_cast<TDerived*>(this);
-    tracing_enabled_ = this_as_derived->OnStartLogging();
-  }
-
-  void Consume(uint64_t client_handle, const TimePoint& start_time, std::map<uint64_t, Events>& events) {
-    auto this_as_derived = static_cast<TDerived*>(this);
-    events.clear();
-    {
-      // Flush any pending activity records before starting
-      // to process the accumulated activity records.
-      std::lock_guard<std::mutex> lock_manager(manager_instance_mutex_);
-      if (!tracing_enabled_) {
-        return;
-      }
-
-      this_as_derived->FlushActivities();
-    }
-
-    std::vector<ProfilerActivityBuffer> activity_buffers;
-    {
-      std::lock_guard<std::mutex> lock(unprocessed_activity_buffers_mutex_);
-      std::swap(unprocessed_activity_buffers_, activity_buffers);
-      unprocessed_activity_buffers_.clear();
-    }
-
-    {
-      // Ensure that at most one thread is working through the activity buffers at any time.
-      std::lock_guard<std::mutex> lock_two(activity_buffer_processor_mutex_);
-      this_as_derived->ProcessActivityBuffers(activity_buffers, start_time);
-      auto it = per_client_events_by_ext_correlation_.find(client_handle);
-      if (it == per_client_events_by_ext_correlation_.end()) {
-        return;
-      }
-      std::swap(events, it->second);
-    }
-  }
-
-  void PushCorrelation(uint64_t client_handle,
-                       uint64_t external_correlation_id,
-                       TimePoint profiling_start_time) {
-    auto this_as_derived = static_cast<TDerived*>(this);
-    std::lock_guard<std::mutex> lock(manager_instance_mutex_);
-    if (!tracing_enabled_) {
-      return;
-    }
-
-    auto it = per_client_events_by_ext_correlation_.find(client_handle);
-    if (it == per_client_events_by_ext_correlation_.end()) {
-      // not a registered client, do nothing
-      return;
-    }
-
-    // external_correlation_id is simply the timestamp of this event,
-    // relative to profiling_start_time. i.e., it was computed as:
-    // external_correlation_id =
-    //      std::chrono::duration_cast<std::chrono::microseconds>(event_start_time - profiling_start_time).count()
-    //
-    // Because of the relative nature of the external_correlation_id, the same
-    // external_correlation_id can be reused across different clients, which then makes it
-    // impossible to recover the client from the external_correlation_id, which in turn
-    // makes it impossible to map events (which are tagged with external_correlation_id) to clients.
-    //
-    // To address these difficulties, we construct a new correlation_id (let's call it unique_cid)
-    // as follows:
-    // unique_cid =
-    //    external_correlation_id +
-    //    std::chrono::duration_cast<std::chrono::microseconds>(profiling_start_time.time_since_epoch()).count()
-    // now, unique_cid is monotonically increasing with time, so it can be used to reliably map events to clients.
-    //
-    // Of course, clients expect lists of events to be returned (on a call to Consume()), that are
-    // still keyed on the external_correlation_id that they've specified here, so we need to remember the
-    // offset to be subtracted
-    uint64_t offset = std::chrono::duration_cast<std::chrono::microseconds>(profiling_start_time.time_since_epoch()).count();
-    auto unique_cid = external_correlation_id + offset;
-    unique_correlation_id_to_client_offset_[unique_cid] = std::make_pair(client_handle, offset);
-    this_as_derived->PushUniqueCorrelation(unique_cid);
-  }
-
-  void PopCorrelation(uint64_t& popped_external_correlation_id) {
-    auto this_as_derived = static_cast<TDerived*>(this);
-    std::lock_guard<std::mutex> lock(manager_instance_mutex_);
-    if (!tracing_enabled_) {
-      return;
-    }
-    uint64_t unique_cid;
-    this_as_derived->PopUniqueCorrelation(unique_cid);
-    // lookup the offset and subtract it before returning popped_external_correlation_id to the client
-    auto client_it = unique_correlation_id_to_client_offset_.find(unique_cid);
-    if (client_it == unique_correlation_id_to_client_offset_.end()) {
-      popped_external_correlation_id = 0;
-      return;
-    }
-    popped_external_correlation_id = unique_cid - client_it->second.second;
-  }
-
-  void PopCorrelation() {
-    uint64_t unused;
-    PopCorrelation(unused);
-  }
-
- protected:
-  GPUTracerManager() {
-    auto this_as_derived = static_cast<TDerived*>(this);
-    uint64_t gpu_ts1, gpu_ts2, cpu_ts;
-
-    // Get the CPU and GPU timestamps to warm up
-    gpu_ts1 = this_as_derived->GetGPUTimestampInNanoseconds();
-    cpu_ts = this->GetCPUTimestampInNanoseconds();
-
-    // Estimate the skew/offset between the CPU and GPU timestamps.
-    gpu_ts1 = this_as_derived->GetGPUTimestampInNanoseconds();
-    cpu_ts = this->GetCPUTimestampInNanoseconds();
-    gpu_ts2 = this_as_derived->GetGPUTimestampInNanoseconds();
-
-    auto gpu_ts = (gpu_ts1 + gpu_ts2) / 2;
-    offset_to_add_to_gpu_timestamps_ = cpu_ts - gpu_ts;
-  }
-
-#if 0
-  // Functional API to be implemented by subclasses
-  // Included here only for documentation purposes
-protected:
-  bool OnStartLogging();
-  void OnStopLogging();
-  void ProcessActivityBuffers(const std::vector<ProfilerActivityBuffer>& buffers,
-                              const TimePoint& start_time);
-  bool PushUniqueCorrelation(uint64_t unique_cid);
-  void PopUniqueCorrelation(uint64_t& popped_unique_cid);
-  void FlushActivities();
-  uint64_t GetGPUTimestampInNanoseconds();
-#endif
-
-  void EnqueueActivityBuffer(ProfilerActivityBuffer&& buffer) {
-    std::lock_guard<std::mutex> lock(unprocessed_activity_buffers_mutex_);
-    unprocessed_activity_buffers_.emplace_back(std::move(buffer));
-  }
-
-  // To be called by subclasses only from ProcessActivityBuffers
-  void MapEventToClient(uint64_t tracer_correlation_id, EventRecord&& event) {
-    auto it = tracer_correlation_to_unique_correlation_.find(tracer_correlation_id);
-    if (it == tracer_correlation_to_unique_correlation_.end()) {
-      // We're yet to receive a mapping to unique_correlation_id for this tracer_correlation_id
-      DeferEventMapping(std::move(event), tracer_correlation_id);
-      return;
-    }
-    auto unique_correlation_id = it->second;
-    auto p_event_list = GetEventListForUniqueCorrelationId(unique_correlation_id);
-    if (p_event_list != nullptr) {
-      p_event_list->emplace_back(std::move(event));
-    }
-  }
-
-  // To be called by subclasses only from ProcessActivityBuffers
-  void NotifyNewCorrelation(uint64_t tracer_correlation_id, uint64_t unique_correlation_id) {
-    tracer_correlation_to_unique_correlation_[tracer_correlation_id] = unique_correlation_id;
-    auto pending_it = events_pending_client_mapping_.find(tracer_correlation_id);
-    if (pending_it == events_pending_client_mapping_.end()) {
-      return;
-    }
-    // Map the pending events to the right client
-    MapEventsToClient(unique_correlation_id, std::move(pending_it->second));
-    events_pending_client_mapping_.erase(pending_it);
-  }
-
-  uint64_t NormalizeGPUTimestampToCPUEpoch(uint64_t gpu_timestamp_in_nanoseconds) {
-    return gpu_timestamp_in_nanoseconds + this->offset_to_add_to_gpu_timestamps_;
-  }
-
- private:
-  // Requires: manager_instance_mutex_ should be held
-  void StopLogging() {
-    auto this_as_derived = static_cast<TDerived*>(this);
-    if (!tracing_enabled_) {
-      return;
-    }
-    this_as_derived->OnStopLogging();
-    tracing_enabled_ = false;
-    Clear();
-  }
-
-  // Requires: manager_instance_mutex_ should be held
-  void Clear() {
-    unprocessed_activity_buffers_.clear();
-    unique_correlation_id_to_client_offset_.clear();
-    per_client_events_by_ext_correlation_.clear();
-    tracer_correlation_to_unique_correlation_.clear();
-    events_pending_client_mapping_.clear();
-  }
-
-  Events* GetEventListForUniqueCorrelationId(uint64_t unique_correlation_id) {
-    auto client_it = unique_correlation_id_to_client_offset_.find(unique_correlation_id);
-    if (client_it == unique_correlation_id_to_client_offset_.end()) {
-      return nullptr;
-    }
-
-    // See the comments on the GetUniqueCorrelationId method for an explanation of
-    // of this offset computation and why it's required.
-    auto const& client_handle_offset = client_it->second;
-    auto external_correlation = unique_correlation_id - client_handle_offset.second;
-    auto& event_list = per_client_events_by_ext_correlation_[client_handle_offset.first][external_correlation];
-    return &event_list;
-  }
-
-  void MapEventsToClient(uint64_t unique_correlation_id, std::vector<EventRecord>&& events) {
-    auto p_event_list = GetEventListForUniqueCorrelationId(unique_correlation_id);
-    if (p_event_list != nullptr) {
-      p_event_list->insert(p_event_list->end(),
-                           std::make_move_iterator(events.begin()),
-                           std::make_move_iterator(events.end()));
-    }
-  }
-
-  void DeferEventMapping(EventRecord&& event, uint64_t tracer_correlation_id) {
-    events_pending_client_mapping_[tracer_correlation_id].emplace_back(std::move(event));
-  }
-
-  uint64_t GetCPUTimestampInNanoseconds() {
-    return std::chrono::duration_cast<std::chrono::nanoseconds>(
-               std::chrono::high_resolution_clock::now().time_since_epoch())
-        .count();
-  }
-
-  std::mutex manager_instance_mutex_;
-  uint64_t next_client_id_ = 1;
-  uint64_t num_active_clients_ = 0;
-  bool tracing_enabled_ = false;
-  std::mutex unprocessed_activity_buffers_mutex_;
-  std::mutex activity_buffer_processor_mutex_;
-
-  // Unprocessed activity buffers
-  std::vector<ProfilerActivityBuffer> unprocessed_activity_buffers_;
-
-  // Keyed on unique_correlation_id -> (client_id/client_handle, offset)
-  // unique_correlation_id - offset == external_correlation_id
-  InlinedHashMap<uint64_t, std::pair<uint64_t, uint64_t>> unique_correlation_id_to_client_offset_;
-
-  // Keyed on tracer_correlation_id -> unique_correlation_id
-  InlinedHashMap<uint64_t, uint64_t> tracer_correlation_to_unique_correlation_;
-
-  // client_id/client_handle -> external_correlation_id -> events
-  InlinedHashMap<uint64_t, std::map<uint64_t, Events>> per_client_events_by_ext_correlation_;
-
-  // Keyed on tracer correlation_id, keeps track of activity records
-  // for which we haven't established the external_correlation_id yet.
-  InlinedHashMap<uint64_t, std::vector<EventRecord>> events_pending_client_mapping_;
-
-  // An offset to add to (the possibly skewed) GPU timestamps
-  // to normalize GPU timestamps with CPU timestamps
-  int64_t offset_to_add_to_gpu_timestamps_;
-}; /* class GPUTracerManager */
-
-// Base class for a GPU profiler
-template <typename TManager>
-class GPUProfilerBase : public EpProfiler {
- protected:
-  GPUProfilerBase() = default;
-  virtual ~GPUProfilerBase() {}
-
-  void MergeEvents(std::map<uint64_t, Events>& events_to_merge, Events& events) {
-    Events merged_events;
-
-    auto event_iter = std::make_move_iterator(events.begin());
-    auto event_end = std::make_move_iterator(events.end());
-    for (auto& map_iter : events_to_merge) {
-      if (map_iter.second.empty()) {
-        continue;
-      }
-
-      auto ts = static_cast<long long>(map_iter.first);
-
-      // find the last occurrence of a matching timestamp,
-      // if one exists
-      while (event_iter != event_end &&
-             (event_iter->ts < ts ||
-              (event_iter->ts == ts &&
-               (event_iter + 1) != event_end &&
-               (event_iter + 1)->ts == ts))) {
-        merged_events.emplace_back(*event_iter);
-        ++event_iter;
-      }
-
-      bool copy_op_names = false;
-      std::string op_name;
-      std::string parent_name;
-
-      if (event_iter != event_end && event_iter->ts == ts) {
-        // We've located a parent event, copy the op_name and set
-        // this event's parent_name property to the name of the parent.
-        copy_op_names = true;
-        op_name = event_iter->args["op_name"];
-        parent_name = event_iter->name;
-        merged_events.emplace_back(*event_iter);
-        ++event_iter;
-      }
-
-      for (auto& evt : map_iter.second) {
-        if (copy_op_names) {
-          // If we have found a matching parent event,
-          // then inherit some names from the parent.
-          evt.args["op_name"] = op_name;
-          evt.args["parent_name"] = parent_name;
-        }
-      }
-
-      merged_events.insert(merged_events.end(),
-                           std::make_move_iterator(map_iter.second.begin()),
-                           std::make_move_iterator(map_iter.second.end()));
-    }
-
-    // move any remaining events
-    merged_events.insert(merged_events.end(), event_iter, event_end);
-    std::swap(events, merged_events);
-  }
-
-  uint64_t client_handle_;
-  TimePoint profiling_start_time_;
-
- public:
-  virtual bool StartProfiling(TimePoint profiling_start_time) override {
-    auto& manager = TManager::GetInstance();
-    manager.StartLogging();
-    profiling_start_time_ = profiling_start_time;
-    return true;
-  }
-
-  virtual void EndProfiling(TimePoint start_time, Events& events) override {
-    auto& manager = TManager::GetInstance();
-    std::map<uint64_t, Events> event_map;
-    manager.Consume(client_handle_, start_time, event_map);
-    MergeEvents(event_map, events);
-  }
-
-  virtual void Start(uint64_t id) override {
-    auto& manager = TManager::GetInstance();
-    manager.PushCorrelation(client_handle_, id, profiling_start_time_);
-  }
-
-  virtual void Stop(uint64_t) override {
-    auto& manager = TManager::GetInstance();
-    manager.PopCorrelation();
-  }
-}; /* class GPUProfilerBase */
-
-// Convert a pointer to a hex string
-static inline std::string PointerToHexString(const void* ptr) {
-  std::ostringstream sstr;
-  sstr << std::hex << ptr;
-  return sstr.str();
-}
-
-} /* end namespace profiling */
-} /* end namespace onnxruntime */

arm64-v8a/include/onnxruntime/core/common/gsl.h

@@ -1,6 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "gsl/gsl"

arm64-v8a/include/onnxruntime/core/common/hash_combine.h

@@ -1,21 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-namespace onnxruntime {
-
-// Combine hash value `seed` with hash value `h`, updating `seed` in place.
-// TODO(edgchen1) find a better implementation? e.g., see a more recent version of boost::hash_combine()
-inline void HashCombineWithHashValue(size_t h, size_t& seed) {
-  seed ^= h + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-}
-
-// Combine hash value `seed` with the hash value of `value`, updating `seed` in place.
-// The hash value computation is specified by the `Hash` template parameter.
-template <typename T, typename Hash = std::hash<T>>
-inline void HashCombine(const T& value, size_t& seed) {
-  HashCombineWithHashValue(Hash{}(value), seed);
-}
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/inlined_containers.h

@@ -1,175 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <cmath>
-
-#include "core/common/inlined_containers_fwd.h"
-
-#ifndef DISABLE_ABSEIL
-
-#ifdef _MSC_VER
-#pragma warning(push)
-// C4127: conditional expression is constant
-#pragma warning(disable : 4127)
-// C4324: structure was padded due to alignment specifier
-// Usage of alignas causes some internal padding in places.
-#pragma warning(disable : 4324)
-#endif  // _MSC_VER
-
-#include <absl/container/flat_hash_set.h>
-#include <absl/container/flat_hash_map.h>
-
-#include <absl/container/node_hash_set.h>
-#include <absl/container/node_hash_map.h>
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif  // _MSC_VER
-
-#else  // DISABLE_ABSEIL
-
-#include <unordered_set>
-#include <unordered_map>
-#include <set>
-#include <map>
-
-#endif  // DISABLE_ABSEIL
-
-namespace onnxruntime {
-
-#ifndef DISABLE_ABSEIL
-// InlinedHashSet and InlinedHashMap are preferred
-// hash based containers. They store their values in the
-// buckets array that is allocated in one shot. It eliminates
-// per-node new/delete calls. Always call reserve() on any hash set/map
-// when the number of items is known in advance.
-// This does not allocate a dummy 'end' node on default construction.
-template <typename T, typename Allocator>
-class InlinedHashSet : public absl::flat_hash_set<T,
-                                                  absl::container_internal::hash_default_hash<T>,
-                                                  absl::container_internal::hash_default_eq<T>,
-                                                  Allocator> {
-  using Base = absl::flat_hash_set<T,
-                                   absl::container_internal::hash_default_hash<T>,
-                                   absl::container_internal::hash_default_eq<T>,
-                                   Allocator>;
-
- public:
-  using Base::Base;
-};
-
-template <typename Key, typename Value,
-          typename Allocator>
-class InlinedHashMap : public absl::flat_hash_map<Key, Value,
-                                                  absl::container_internal::hash_default_hash<Key>,
-                                                  absl::container_internal::hash_default_eq<Key>,
-                                                  Allocator> {
-  using Base = absl::flat_hash_map<Key, Value,
-                                   absl::container_internal::hash_default_hash<Key>,
-                                   absl::container_internal::hash_default_eq<Key>,
-                                   Allocator>;
-
- public:
-  using Base::Base;
-};
-
-// Use this hash set/map where pointer stability is required, otherwise use
-// InlinedHashSet and InlinedHashMap
-// This does not allocate a dummy 'end' node on default construction.
-// Use reserve() when the number of elements is known.
-template <typename T, typename Allocator>
-class NodeHashSet : public absl::node_hash_set<T,
-                                               absl::container_internal::hash_default_hash<T>,
-                                               absl::container_internal::hash_default_eq<T>,
-                                               Allocator> {
-  using Base = absl::node_hash_set<T,
-                                   absl::container_internal::hash_default_hash<T>,
-                                   absl::container_internal::hash_default_eq<T>,
-                                   Allocator>;
-
- public:
-  using Base::Base;
-};
-
-template <typename Key, typename Value, typename Allocator>
-class NodeHashMap : public absl::node_hash_map<Key, Value,
-                                               absl::container_internal::hash_default_hash<Key>,
-                                               absl::container_internal::hash_default_eq<Key>,
-                                               Allocator> {
-  using Base = absl::node_hash_map<Key, Value,
-                                   absl::container_internal::hash_default_hash<Key>,
-                                   absl::container_internal::hash_default_eq<Key>,
-                                   Allocator>;
-
- public:
-  using Base::Base;
-};
-
-#else  // DISABLE_ABSEIL
-
-template <typename T, typename Allocator>
-class InlinedHashSet : public std::unordered_set<T,
-                                                 std::hash<T>,
-                                                 std::equal_to<T>,
-                                                 Allocator> {
-  using Base = std::unordered_set<T,
-                                  std::hash<T>,
-                                  std::equal_to<T>,
-                                  Allocator>;
-
- public:
-  using Base::Base;
-};
-
-template <typename Key, typename Value,
-          typename Allocator>
-class InlinedHashMap : public std::unordered_map<Key, Value,
-                                                 std::hash<Key>,
-                                                 std::equal_to<Key>,
-                                                 Allocator> {
-  using Base = std::unordered_map<Key, Value,
-                                  std::hash<Key>,
-                                  std::equal_to<Key>,
-                                  Allocator>;
-
- public:
-  using Base::Base;
-};
-
-// Use this hash set/map where pointer stability is required, otherwise use
-// InlinedHashSet and InlinedHashMap
-// This does not allocate a dummy 'end' node on default construction.
-// Use reserve() when the number of elements is known.
-template <typename T, typename Allocator>
-class NodeHashSet : public std::unordered_set<T,
-                                              std::hash<T>,
-                                              std::equal_to<T>,
-                                              Allocator> {
-  using Base = std::unordered_set<T,
-                                  std::hash<T>,
-                                  std::equal_to<T>,
-                                  Allocator>;
-
- public:
-  using Base::Base;
-};
-
-template <typename Key, typename Value, typename Allocator>
-class NodeHashMap : public std::unordered_map<Key, Value,
-                                       std::hash<Key>,
-                                       std::equal_to<Key>,
-                                       Allocator> {
-  using Base = std::unordered_map<Key, Value,
-                                  std::hash<Key>,
-                                  std::equal_to<Key>,
-                                  Allocator>;
-
- public:
-  using Base::Base;
-};
-
-#endif  // DISABLE_ABSEIL
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/inlined_containers_fwd.h

@@ -1,147 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <memory>
-#include <utility>
-
-#ifndef DISABLE_ABSEIL
-#ifdef _MSC_VER
-#pragma warning(push)
-// C4127: conditional expression is constant
-#pragma warning(disable : 4127)
-// C4324: structure was padded due to alignment specifier
-// Usage of alignas causes some internal padding in places.
-#pragma warning(disable : 4324)
-#else
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102329#c2
-#if !defined(__clang__) && defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
-#endif
-#endif  // _MSC_VER
-
-#include <absl/container/inlined_vector.h>
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#else
-#if !defined(__clang__) && defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-#endif  // _MSC_VER
-
-#else
-
-#include <vector>
-
-#endif  // DISABLE_ABSEIL
-
-// Forward declarations for contexts where abseil can not be compiled and
-// not really needed but we want to have it in the headers that are included
-// e.g. CUDA 10 and .CU files
-// InlinedVector seems to be fine with old CUDA
-
-//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// This file contains code and comments derived from llvm/ADT/SmallVector.h
-//
-// Specifically CalculateInlinedVectorDefaultInlinedElements<T>() template is derived from
-// CalculateSmallVectorDefaultInlinedElements<T>() and its comments.
-
-namespace onnxruntime {
-#ifndef DISABLE_ABSEIL
-/// Inspired by LLVM SmallVector with ONNX Runtime adjustments for abseil.
-///
-/// Helper class for calculating the default number of inline elements for
-/// `InlinedVector<T>`.
-/// This produces the following on MSVC x64
-///    int8_t  -> 41
-//     int16_t -> 21
-//     int32_t -> 11
-//     int64_t -> 6
-//     std::string 40 -> 1
-template <typename T>
-struct CalculateInlinedVectorDefaultInlinedElements {
-  // Parameter controlling the default number of inlined elements
-  // for `InlinedVector<T>`.
-  //
-  // The default number of inlined elements ensures that
-  // 1. There is at least one inlined element.
-  // 2. `sizeof(InlinedVector<T>) <= kPreferredInlinedVectorSizeof` unless
-  // it contradicts 1.
-  static constexpr size_t kPreferredInlinedVectorSizeof = 64;
-
-  // static_assert that sizeof(T) is not "too big".
-  //
-  // Because the InlinedVector must have at least one inlined element, it is possible
-  // for an arbitrarily large inlined element to allocate an arbitrarily large
-  // amount of inline storage. So we want to call attention to these cases and
-  // make sure that users are making an intentional decision if they request a lot of inline storage.
-  //
-  // We want this assertion to trigger in pathological cases, but otherwise
-  // not be too easy to hit. To accomplish that, the cutoff is actually somewhat
-  // larger than kPreferredInlinedVectorSizeof (otherwise,
-  // `InlinedVector<InlinedVector<T>>` would be one easy way to trip it, and that
-  // pattern seems useful in practice).
-  //
-  // One wrinkle is that this assertion is in theory non-portable, since
-  // sizeof(absl::InlinedVector<T, 1>) is in general platform-dependent. However, we don't expect this
-  // to be much of an issue, because most LLVM development happens on 64-bit
-  // hosts, and therefore sizeof(T) is expected to *decrease* when compiled for
-  // 32-bit hosts, dodging the issue. The reverse situation, where development
-  // happens on a 32-bit host and then fails due to sizeof(T) *increasing* on a
-  // 64-bit host, is expected to be very rare.
-  static_assert(
-      sizeof(absl::InlinedVector<T, 1>) <= kPreferredInlinedVectorSizeof,
-      "You are trying to use a default number of inlined elements for "
-      "`InlinedVector<T>` but `sizeof(T)` is really big! Please use an "
-      "explicit number of inlined elements with `InlinedVector<T, N>` to make "
-      "sure you really want that much inline storage.");
-
-  // Discount the size of the header itself when calculating the maximum inline
-  // bytes.
-  static constexpr size_t PreferredInlineBytes =
-      kPreferredInlinedVectorSizeof - (sizeof(absl::InlinedVector<T, 1>) - sizeof(T));
-  static constexpr size_t NumElementsThatFit = PreferredInlineBytes / sizeof(T);
-  static constexpr size_t value =
-      NumElementsThatFit == 0 ? 1 : NumElementsThatFit;
-};
-
-// Use InlinedVector for small arrays that can fit on a stack with a default
-// value pre-calculated.
-// Use TensorShapeVector for shapes.
-template <typename T,
-          size_t N = CalculateInlinedVectorDefaultInlinedElements<T>::value,
-          typename Allocator = std::allocator<T>>
-using InlinedVector = absl::InlinedVector<T, N, Allocator>;
-
-#else
-
-template <typename T,
-          size_t N = 0,
-          typename Allocator = std::allocator<T>>
-using InlinedVector = std::vector<T, Allocator>;
-
-#endif  // DISABLE_ABSEIL
-
-template <typename T,
-          typename Allocator = std::allocator<T>>
-class InlinedHashSet;
-
-template <typename Key, typename Value,
-          typename Allocator = std::allocator<std::pair<const Key, Value>>>
-class InlinedHashMap;
-
-template <typename T, typename Allocator = std::allocator<T>>
-class NodeHashSet;
-
-template <typename Key, typename Value,
-          typename Allocator = std::allocator<std::pair<const Key, Value>>>
-class NodeHashMap;
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/logging/capture.h

@@ -1,115 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <cstdarg>
-#include "core/common/gsl.h"
-#include "core/common/common.h"
-#include "core/common/code_location.h"
-#include "core/common/logging/severity.h"
-
-namespace onnxruntime {
-namespace logging {
-
-class Logger;
-enum class DataType;
-
-/**
-   Class to capture the details of a log message.
-*/
-class Capture {
- public:
-  /**
-     Initializes a new instance of the Capture class.
-     @param logger The logger.
-     @param severity The severity.
-     @param category The category.
-     @param dataType Type of the data.
-     @param location The file location the log message is coming from.
-  */
-  Capture(const Logger& logger, logging::Severity severity, const char* category,
-          logging::DataType dataType, const CodeLocation& location)
-      : logger_{&logger}, severity_{severity}, category_{category}, data_type_{dataType}, location_{location} {
-  }
-
-  /**
-     The stream that can capture the message via operator<<.
-     @returns Output stream.
-  */
-  std::ostream& Stream() noexcept {
-    return stream_;
-  }
-
-#ifdef _MSC_VER
-// add SAL annotation for printf format string. requires Code Analysis to run to validate usage.
-#define msvc_printf_check _Printf_format_string_
-#define __attribute__(x)  // Disable for MSVC. Supported by GCC and CLang.
-#else
-#define msvc_printf_check
-#endif
-
-  /**
-     Captures a printf style log message.
-     @param name="format">The printf format.
-     @param name="">Arguments to the printf format if needed.
-     @remarks
-     A maximum of 2K of output will be captured currently.
-     Non-static method, so 'this' is implicit first arg, and we use format(printf(2,3)
-  */
-  void CapturePrintf(msvc_printf_check const char* format, ...) __attribute__((format(printf, 2, 3)));
-
-  /**
-     Process a printf style log message.
-     @param format The printf format.
-     @param ... Arguments to the printf format if needed.
-     @remarks
-     A maximum of 2K of output will be captured currently.
-     Note: As va_list is 'char *', we have to disambiguate this from CapturePrintf
-     so that something like "One string: %s", "the string" does not consider "the string"
-     to be the va_list.
-  */
-  void ProcessPrintf(msvc_printf_check const char* format, va_list args);
-
-  logging::Severity Severity() const noexcept {
-    return severity_;
-  }
-
-  char SeverityPrefix() const noexcept {
-    // Carefully setup so severity_ is a valid index
-    GSL_SUPPRESS(bounds .2) {
-      return logging::SEVERITY_PREFIX[static_cast<int>(severity_)];
-    }
-  }
-
-  const char* Category() const noexcept {
-    return category_;
-  }
-
-  logging::DataType DataType() const noexcept {
-    return data_type_;
-  }
-
-  const CodeLocation& Location() const noexcept {
-    return location_;
-  }
-
-  std::string Message() const noexcept {
-    return stream_.str();
-  }
-
-  ~Capture();
-
- private:
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(Capture);
-
-  const Logger* logger_;
-  const logging::Severity severity_;
-  const char* category_;
-  const logging::DataType data_type_;
-  const CodeLocation location_;
-
-  std::ostringstream stream_;
-};
-}  // namespace logging
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/logging/isink.h

@@ -1,41 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-
-#include "core/common/logging/logging.h"
-
-namespace onnxruntime {
-namespace logging {
-class ISink {
- public:
-  ISink() = default;
-
-  /**
-     Sends the message to the sink.
-     @param timestamp The timestamp.
-     @param logger_id The logger identifier.
-     @param message The captured message.
-  */
-  void Send(const Timestamp& timestamp, const std::string& logger_id, const Capture& message) {
-    SendImpl(timestamp, logger_id, message);
-  }
-
-  /**
-    Sends a Profiling Event Record to the sink.
-    @param Profiling Event Record
-  */
-  virtual void SendProfileEvent(profiling::EventRecord&) const {};
-
-  virtual ~ISink() = default;
-
- private:
-  // Make Code Analysis happy by disabling all for now. Enable as needed.
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(ISink);
-
-  virtual void SendImpl(const Timestamp& timestamp, const std::string& logger_id, const Capture& message) = 0;
-};
-}  // namespace logging
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/logging/logging.h

@@ -1,337 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <atomic>
-#include <chrono>
-#include <climits>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <string>
-
-#include "core/common/common.h"
-#include "core/common/profiler_common.h"
-#include "core/common/logging/capture.h"
-#include "core/common/logging/severity.h"
-
-#include "core/common/logging/macros.h"
-
-/*
-
-  Logging overview and expected usage:
-
-  At program startup:
-  * Create one or more ISink instances. If multiple, combine using composite_sink.
-  * Create a LoggingManager instance with the sink/s with is_default_instance set to true
-  * Only one instance should be created in this way, and it should remain valid for
-  until the program no longer needs to produce log output.
-
-  You can either use the static default Logger which LoggingManager will create when constructed
-  via LoggingManager::DefaultLogger(), or separate Logger instances each with different log ids
-  via LoggingManager::CreateLogger.
-
-  The log id is passed to the ISink instance with the sink determining how the log id is used
-  in the output.
-
-  LoggingManager
-  * creates the Logger instances used by the application
-  * provides a static default logger instance
-  * owns the log sink instance
-  * applies checks on severity and output of user data
-
-  The log macros create a Capture instance to capture the information to log.
-  If the severity and/or user filtering settings would prevent logging, no evaluation
-  of the log arguments will occur, so no performance cost beyond the severity and user
-  filtering check.
-
-  A sink can do further filter as needed.
-
-*/
-
-namespace onnxruntime {
-
-namespace logging {
-
-using Timestamp = std::chrono::time_point<std::chrono::system_clock>;
-
-#ifndef NDEBUG
-ORT_ATTRIBUTE_UNUSED static bool vlog_enabled = true;  // Set directly based on your needs.
-#else
-constexpr bool vlog_enabled = false;  // no VLOG output
-#endif
-
-enum class DataType {
-  SYSTEM = 0,  ///< System data.
-  USER = 1     ///< Contains potentially sensitive user data.
-};
-
-// Internal log categories.
-// Logging interface takes const char* so arbitrary values can also be used.
-struct Category {
-  static const char* onnxruntime;  ///< General output
-  static const char* System;       ///< Log output regarding interactions with the host system
-  // TODO: What other high level categories are meaningful? Model? Optimizer? Execution?
-};
-
-class ISink;
-class Logger;
-class Capture;
-
-/// <summary>
-/// The logging manager.
-/// Owns the log sink and potentially provides a default Logger instance.
-/// Provides filtering based on a minimum LogSeverity level, and of messages with DataType::User if enabled.
-/// </summary>
-class LoggingManager final {
- public:
-  enum InstanceType {
-    Default,  ///< Default instance of LoggingManager that should exist for the lifetime of the program
-    Temporal  ///< Temporal instance. CreateLogger(...) should be used, however DefaultLogger() will NOT be provided via this instance.
-  };
-
-  /**
-     Initializes a new instance of the LoggingManager class.
-     @param sink The sink to write to. Use CompositeSink if you need to write to multiple places.
-     @param default_min_severity The default minimum severity. Messages with lower severity will be ignored unless
-     overridden in CreateLogger.
-     @param default_filter_user_data If set to true ignore messages with DataType::USER unless overridden in CreateLogger.
-     @param instance_type If InstanceType::Default, this is the default instance of the LoggingManager
-     and is expected to exist for the lifetime of the program.
-     It creates and owns the default logger that calls to the static DefaultLogger method return.
-     @param default_logger_id Logger Id to use for the default logger. nullptr/ignored if instance_type == Temporal.
-     @param default_max_vlog_level Default maximum level for VLOG messages to be created unless overridden in CreateLogger.
-     Requires a severity of kVERBOSE for VLOG messages to be logged.
-  */
-  LoggingManager(std::unique_ptr<ISink> sink, Severity default_min_severity, bool default_filter_user_data,
-                 InstanceType instance_type,
-                 const std::string* default_logger_id = nullptr,
-                 int default_max_vlog_level = -1);
-
-  /**
-     Creates a new logger instance which will use the provided logger_id and default severity and vlog levels.
-     @param logger_id The log identifier.
-     @returns A new Logger instance that the caller owns.
-  */
-  std::unique_ptr<Logger> CreateLogger(const std::string& logger_id);
-
-  /**
-     Creates a new logger instance which will use the provided logger_id, severity and vlog levels.
-     @param logger_id The log identifier.
-     @param min_severity The minimum severity. Requests to create messages with lower severity will be ignored.
-     @param filter_user_data If set to true ignore messages with DataType::USER.
-     @param max_vlog_level Maximum level for VLOG messages to be created.
-     @returns A new Logger instance that the caller owns.
-  */
-  std::unique_ptr<Logger> CreateLogger(const std::string& logger_id,
-                                       Severity min_severity, bool filter_user_data, int max_vlog_level = -1);
-
-  /**
-     Gets the default logger instance if set. Throws if no default logger is currently registered.
-     @remarks
-     Creating a LoggingManager instance with is_default_instance == true registers a default logger.
-     Note that the default logger is only valid until the LoggerManager that registered it is destroyed.
-     @returns The default logger if available.
-  */
-  static const Logger& DefaultLogger();
-
-  /**
-    Return a boolean indicating if the default logger has been initialized
-  */
-  static bool HasDefaultLogger() { return nullptr != s_default_logger_; }
-
-  /**
-     Change the minimum severity level for log messages to be output by the default logger.
-     @param severity The severity.
-  */
-  static void SetDefaultLoggerSeverity(Severity severity);
-
-  /**
-     Change the maximum verbosity level for log messages to be output by the default logger.
-     @remarks
-     To activate the verbose log, the logger severity must also be set to kVERBOSE.
-     @param vlog_level The verbosity level.
-  */
-  static void SetDefaultLoggerVerbosity(int vlog_level);
-
-  /**
-     Logs a FATAL level message and creates an exception that can be thrown with error information.
-     @param category The log category.
-     @param location The location the log message was generated.
-     @param format_str The printf format string.
-     @param ... The printf arguments.
-     @returns A new Logger instance that the caller owns.
-  */
-  static std::exception LogFatalAndCreateException(const char* category,
-                                                   const CodeLocation& location,
-                                                   const char* format_str, ...);
-
-  /**
-     Logs the message using the provided logger id.
-     @param logger_id The log identifier.
-     @param message The log message.
-  */
-  void Log(const std::string& logger_id, const Capture& message) const;
-
-  /**
-    Sends a Profiling Event Record to the sink.
-    @param Profiling Event Record
-  */
-  void SendProfileEvent(profiling::EventRecord& eventRecord) const;
-  ~LoggingManager();
-
- private:
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(LoggingManager);
-
-  Timestamp GetTimestamp() const noexcept;
-  void CreateDefaultLogger(const std::string& logger_id);
-
-  std::unique_ptr<ISink> sink_;
-  const Severity default_min_severity_;
-  const bool default_filter_user_data_;
-  const int default_max_vlog_level_;
-  bool owns_default_logger_;
-
-  static Logger* s_default_logger_;
-
-  struct Epochs {
-    const std::chrono::time_point<std::chrono::high_resolution_clock> high_res;
-    const std::chrono::time_point<std::chrono::system_clock> system;
-    const std::chrono::minutes localtime_offset_from_utc;
-  };
-
-  static const Epochs& GetEpochs() noexcept;
-};
-
-/**
-   Logger provides a per-instance log id. Everything else is passed back up to the LoggingManager
-*/
-class Logger {
- public:
-  /**
-     Initializes a new instance of the Logger class.
-     @param loggingManager The logging manager.
-     @param id The identifier for messages coming from this Logger.
-     @param severity Minimum severity for messages to be created and logged.
-     @param filter_user_data Should USER data be filtered from output.
-     @param vlog_level Minimum level for VLOG messages to be created. Note that a severity of kVERBOSE must be provided
-     for VLOG messages to be logged.
-  */
-  Logger(const LoggingManager& loggingManager, std::string id,
-         Severity severity, bool filter_user_data, int vlog_level)
-      : logging_manager_{&loggingManager},
-        id_{id},
-        min_severity_{severity},
-        filter_user_data_{filter_user_data},
-        max_vlog_level_{vlog_level} {
-  }
-
-  /**
-     Get the minimum severity level for log messages to be output.
-     @returns The severity.
-  */
-  Severity GetSeverity() const noexcept { return min_severity_; }
-
-  /**
-     Change the minimum severity level for log messages to be output.
-     @param severity The severity.
-  */
-  void SetSeverity(Severity severity) noexcept { min_severity_ = severity; }
-
-  /**
-     Change the maximum verbosity level for log messages to be output.
-     @remarks
-     To activate the verbose log, the logger severity must also be set to kVERBOSE.
-     @param vlog_level The verbosity.
-  */
-  void SetVerbosity(int vlog_level) noexcept { max_vlog_level_ = vlog_level; }
-
-  /**
-     Check if output is enabled for the provided LogSeverity and DataType values.
-     @param severity The severity.
-     @param data_type Type of the data.
-     @returns True if a message with these values will be logged.
-  */
-  bool OutputIsEnabled(Severity severity, DataType data_type) const noexcept {
-    return (severity >= min_severity_ && (data_type != DataType::USER || !filter_user_data_));
-  }
-
-  /**
-     Return the maximum VLOG level allowed. Disabled unless logging VLOG messages
-  */
-  int VLOGMaxLevel() const noexcept {
-    return min_severity_ > Severity::kVERBOSE ? -1 : max_vlog_level_;
-  }
-
-  /**
-     Logs the captured message.
-     @param message The log message.
-  */
-  void Log(const Capture& message) const {
-    logging_manager_->Log(id_, message);
-  }
-
-  /**
-    Sends a Profiling Event Record to the sink.
-    @param Profiling Event Record
-  */
-  void SendProfileEvent(profiling::EventRecord& eventRecord) const {
-    logging_manager_->SendProfileEvent(eventRecord);
-  }
-
- private:
-  const LoggingManager* logging_manager_;
-  const std::string id_;
-  Severity min_severity_;
-  const bool filter_user_data_;
-  int max_vlog_level_;
-};
-
-inline const Logger& LoggingManager::DefaultLogger() {
-  if (s_default_logger_ == nullptr) {
-    // fail early for attempted misuse. don't use logging macros as we have no logger.
-    ORT_THROW("Attempt to use DefaultLogger but none has been registered.");
-  }
-
-  return *s_default_logger_;
-}
-
-inline void LoggingManager::SetDefaultLoggerSeverity(Severity severity) {
-  if (s_default_logger_ == nullptr) {
-    // fail early for attempted misuse. don't use logging macros as we have no logger.
-    ORT_THROW("Attempt to use DefaultLogger but none has been registered.");
-  }
-
-  s_default_logger_->SetSeverity(severity);
-}
-
-inline void LoggingManager::SetDefaultLoggerVerbosity(int vlog_level) {
-  if (s_default_logger_ == nullptr) {
-    // fail early for attempted misuse. don't use logging macros as we have no logger.
-    ORT_THROW("Attempt to use DefaultLogger but none has been registered.");
-  }
-
-  s_default_logger_->SetVerbosity(vlog_level);
-}
-
-inline Timestamp LoggingManager::GetTimestamp() const noexcept {
-  static const Epochs& epochs = GetEpochs();
-
-  const auto high_res_now = std::chrono::high_resolution_clock::now();
-  return std::chrono::time_point_cast<std::chrono::system_clock::duration>(
-      epochs.system + (high_res_now - epochs.high_res) + epochs.localtime_offset_from_utc);
-}
-
-/**
-   Return the current thread id.
-*/
-unsigned int GetThreadId();
-
-/**
-   Return the current process id.
-*/
-unsigned int GetProcessId();
-
-}  // namespace logging
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/logging/macros.h

@@ -1,278 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-// NOTE: Don't include this file directly. Include logging.h
-
-#define CREATE_MESSAGE(logger, severity, category, datatype) \
-  ::onnxruntime::logging::Capture(logger, ::onnxruntime::logging::Severity::k##severity, category, datatype, ORT_WHERE)
-
-/*
-  Both printf and stream style logging are supported.
-  Not that printf currently has a 2K limit to the message size.
-
-  LOGS_* macros are for stream style
-  LOGF_* macros are for printf style
-
-  The Message class captures the log input, and pushes it through the logger in its destructor.
-
-  Use the *FATAL* macros if you want a Severity::kFatal message to also throw.
-
-  There are a few variants to minimize the length of the macro name required in the calling code.
-  They are optimized so the shortest names are for the (expected) most common usage. This can be
-  tweaked if needed.
-
-  Explicit logger vs LoggingManager::DefaulLogger()
-  Default is for a logger instance to be explicitly passed in.
-  The logger instance provides an identifier so that log messages from different runs can be separated.
-
-  Variants with DEFAULT in the macro name use the default logger provided by logging manager. This is
-  static so accessible from any code, provided a LoggingManager instance created with InstanceType::Default
-  exists somewhere. See logging.h for further explanation of the expected setup.
-
-  DataType
-  Default uses DataType::SYSTEM.
-
-  Variants with USER in the macro name use DataType::USER. This is data that could be PII, and may need to
-  be filtered from output. LoggingManager applies this filtering.
-
-  Category
-  Default category is ::onnxruntime::Logging::Category::onnxruntime.
-
-  If you wish to provide a different category, use variants with CATEGORY in the macro name
-
-*/
-
-/**
- * Note:
- * The stream style logging macros (something like `LOGS() << message`) are designed to be appended to.
- * Normally, we can isolate macro code in a separate scope (e.g., `do {...} while(0)`), but here we need the macro code
- * to interact with subsequent code (i.e., the values to log).
- *
- * When an unisolated conditional is involved, extra care needs to be taken to avoid unexpected parsing behavior.
- * For example:
- *
- * if (enabled)
- *   Capture().Stream()
- *
- * is more direct, but
- *
- * if (!enabled) {
- * } else Capture().Stream()
- *
- * ensures that the `if` does not unintentionally associate with a subsequent `else`.
- */
-
-// Logging with explicit category
-
-// iostream style logging. Capture log info in Message, and push to the logger in ~Message.
-#define LOGS_CATEGORY(logger, severity, category)                              \
-  if (!(logger).OutputIsEnabled(::onnxruntime::logging::Severity::k##severity, \
-                                ::onnxruntime::logging::DataType::SYSTEM)) {   \
-    /* do nothing */                                                           \
-  } else                                                                       \
-    CREATE_MESSAGE(logger, severity, category, ::onnxruntime::logging::DataType::SYSTEM).Stream()
-
-#define LOGS_USER_CATEGORY(logger, severity, category)                         \
-  if (!(logger).OutputIsEnabled(::onnxruntime::logging::Severity::k##severity, \
-                                ::onnxruntime::logging::DataType::USER)) {     \
-    /* do nothing */                                                           \
-  } else                                                                       \
-    CREATE_MESSAGE(logger, severity, category, ::onnxruntime::logging::DataType::USER).Stream()
-
-// printf style logging. Capture log info in Message, and push to the logger in ~Message.
-#define LOGF_CATEGORY(logger, severity, category, format_str, ...)                         \
-  do {                                                                                     \
-    if ((logger).OutputIsEnabled(::onnxruntime::logging::Severity::k##severity,            \
-                                 ::onnxruntime::logging::DataType::SYSTEM))                \
-      CREATE_MESSAGE(logger, severity, category, ::onnxruntime::logging::DataType::SYSTEM) \
-          .CapturePrintf(format_str, ##__VA_ARGS__);                                       \
-  } while (0)
-
-#define LOGF_USER_CATEGORY(logger, severity, category, format_str, ...)                  \
-  do {                                                                                   \
-    if ((logger).OutputIsEnabled(::onnxruntime::logging::Severity::k##severity,          \
-                                 ::onnxruntime::logging::DataType::USER))                \
-      CREATE_MESSAGE(logger, severity, category, ::onnxruntime::logging::DataType::USER) \
-          .CapturePrintf(format_str, ##__VA_ARGS__);                                     \
-  } while (0)
-
-// Logging with category of "onnxruntime"
-
-#define LOGS(logger, severity) \
-  LOGS_CATEGORY(logger, severity, ::onnxruntime::logging::Category::onnxruntime)
-
-#define LOGS_USER(logger, severity) \
-  LOGS_USER_CATEGORY(logger, severity, ::onnxruntime::logging::Category::onnxruntime)
-
-// printf style logging. Capture log info in Message, and push to the logger in ~Message.
-#define LOGF(logger, severity, format_str, ...) \
-  LOGF_CATEGORY(logger, severity, ::onnxruntime::logging::Category::onnxruntime, format_str, ##__VA_ARGS__)
-
-#define LOGF_USER(logger, severity, format_str, ...) \
-  LOGF_USER_CATEGORY(logger, severity, ::onnxruntime::logging::Category::onnxruntime, format_str, ##__VA_ARGS__)
-
-/*
-  Macros that use the default logger.
-  A LoggingManager instance must be currently valid for the default logger to be available.
-*/
-
-// Logging with explicit category
-
-#define LOGS_DEFAULT_CATEGORY(severity, category) \
-  LOGS_CATEGORY(::onnxruntime::logging::LoggingManager::DefaultLogger(), severity, category)
-
-#define LOGS_USER_DEFAULT_CATEGORY(severity, category) \
-  LOGS_USER_CATEGORY(::onnxruntime::logging::LoggingManager::DefaultLogger(), severity, category)
-
-#define LOGF_DEFAULT_CATEGORY(severity, category, format_str, ...) \
-  LOGF_CATEGORY(::onnxruntime::logging::LoggingManager::DefaultLogger(), severity, category, format_str, ##__VA_ARGS__)
-
-#define LOGF_USER_DEFAULT_CATEGORY(severity, category, format_str, ...) \
-  LOGF_USER_CATEGORY(::onnxruntime::logging::LoggingManager::DefaultLogger(), severity, category, format_str, ##__VA_ARGS__)
-
-// Logging with category of "onnxruntime"
-
-#define LOGS_DEFAULT(severity) \
-  LOGS_DEFAULT_CATEGORY(severity, ::onnxruntime::logging::Category::onnxruntime)
-
-#define LOGS_USER_DEFAULT(severity) \
-  LOGS_USER_DEFAULT_CATEGORY(severity, ::onnxruntime::logging::Category::onnxruntime)
-
-#define LOGF_DEFAULT(severity, format_str, ...) \
-  LOGF_DEFAULT_CATEGORY(severity, ::onnxruntime::logging::Category::onnxruntime, format_str, ##__VA_ARGS__)
-
-#define LOGF_USER_DEFAULT(severity, format_str, ...) \
-  LOGF_USER_DEFAULT_CATEGORY(severity, ::onnxruntime::logging::Category::onnxruntime, format_str, ##__VA_ARGS__)
-
-/*
-  Conditional logging
-*/
-
-// Logging with explicit category
-
-#define LOGS_CATEGORY_IF(boolean_expression, logger, severity, category) \
-  if (!((boolean_expression) == true)) {                                 \
-    /* do nothing */                                                     \
-  } else                                                                 \
-    LOGS_CATEGORY(logger, severity, category)
-
-#define LOGS_DEFAULT_CATEGORY_IF(boolean_expression, severity, category) \
-  if (!((boolean_expression) == true)) {                                 \
-    /* do nothing */                                                     \
-  } else                                                                 \
-    LOGS_DEFAULT_CATEGORY(severity, category)
-
-#define LOGS_USER_CATEGORY_IF(boolean_expression, logger, severity, category) \
-  if (!((boolean_expression) == true)) {                                      \
-    /* do nothing */                                                          \
-  } else                                                                      \
-    LOGS_USER_CATEGORY(logger, severity, category)
-
-#define LOGS_USER_DEFAULT_CATEGORY_IF(boolean_expression, severity, category) \
-  if (!((boolean_expression) == true)) {                                      \
-    /* do nothing */                                                          \
-  } else                                                                      \
-    LOGS_USER_DEFAULT_CATEGORY(severity, category)
-
-#define LOGF_CATEGORY_IF(boolean_expression, logger, severity, category, format_str, ...)                   \
-  do {                                                                                                      \
-    if ((boolean_expression) == true) LOGF_CATEGORY(logger, severity, category, format_str, ##__VA_ARGS__); \
-  } while (0)
-
-#define LOGF_DEFAULT_CATEGORY_IF(boolean_expression, severity, category, format_str, ...)                   \
-  do {                                                                                                      \
-    if ((boolean_expression) == true) LOGF_DEFAULT_CATEGORY(severity, category, format_str, ##__VA_ARGS__); \
-  } while (0)
-
-#define LOGF_USER_CATEGORY_IF(boolean_expression, logger, severity, category, format_str, ...)                   \
-  do {                                                                                                           \
-    if ((boolean_expression) == true) LOGF_USER_CATEGORY(logger, severity, category, format_str, ##__VA_ARGS__); \
-  } while (0)
-
-#define LOGF_USER_DEFAULT_CATEGORY_IF(boolean_expression, severity, category, format_str, ...)                   \
-  do {                                                                                                           \
-    if ((boolean_expression) == true) LOGF_USER_DEFAULT_CATEGORY(severity, category, format_str, ##__VA_ARGS__); \
-  } while (0)
-
-// Logging with category of "onnxruntime"
-
-#define LOGS_IF(boolean_expression, logger, severity) \
-  LOGS_CATEGORY_IF(boolean_expression, logger, severity, ::onnxruntime::logging::Category::onnxruntime)
-
-#define LOGS_DEFAULT_IF(boolean_expression, severity) \
-  LOGS_DEFAULT_CATEGORY_IF(boolean_expression, severity, ::onnxruntime::logging::Category::onnxruntime)
-
-#define LOGS_USER_IF(boolean_expression, logger, severity) \
-  LOGS_USER_CATEGORY_IF(boolean_expression, logger, severity, ::onnxruntime::logging::Category::onnxruntime)
-
-#define LOGS_USER_DEFAULT_IF(boolean_expression, severity) \
-  LOGS_USER_DEFAULT_CATEGORY_IF(boolean_expression, severity, ::onnxruntime::logging::Category::onnxruntime)
-
-#define LOGF_IF(boolean_expression, logger, severity, format_str, ...) \
-  LOGF_CATEGORY_IF(boolean_expression, logger, severity, ::onnxruntime::logging::Category::onnxruntime, format_str, ##__VA_ARGS__)
-
-#define LOGF_DEFAULT_IF(boolean_expression, severity, format_str, ...) \
-  LOGF_DEFAULT_CATEGORY_IF(boolean_expression, severity, ::onnxruntime::logging::Category::onnxruntime, format_str, ##__VA_ARGS__)
-
-#define LOGF_USER_IF(boolean_expression, logger, severity, format_str, ...)                                  \
-  LOGF_USER_CATEGORY_IF(boolean_expression, logger, severity, ::onnxruntime::logging::Category::onnxruntime, \
-                        format_str, ##__VA_ARGS__)
-
-#define LOGF_USER_DEFAULT_IF(boolean_expression, severity, format_str, ...)                                  \
-  LOGF_USER_DEFAULT_CATEGORY_IF(boolean_expression, severity, ::onnxruntime::logging::Category::onnxruntime, \
-                                format_str, ##__VA_ARGS__)
-
-/*
-  Debug verbose logging of caller provided level.
-  Disabled in Release builds.
-  Use the _USER variants for VLOG statements involving user data that may need to be filtered.
-*/
-#ifndef NDEBUG
-#define VLOGS(logger, level)                                                         \
-  if (!(::onnxruntime::logging::vlog_enabled && level <= (logger).VLOGMaxLevel())) { \
-    /* do nothing */                                                                 \
-  } else                                                                             \
-    LOGS_CATEGORY(logger, VERBOSE, "VLOG" #level)
-
-#define VLOGS_USER(logger, level)                                                    \
-  if (!(::onnxruntime::logging::vlog_enabled && level <= (logger).VLOGMaxLevel())) { \
-    /* do nothing */                                                                 \
-  } else                                                                             \
-    LOGS_USER_CATEGORY(logger, VERBOSE, "VLOG" #level)
-
-#define VLOGF(logger, level, format_str, ...)                                     \
-  do {                                                                            \
-    if (::onnxruntime::logging::vlog_enabled && level <= (logger).VLOGMaxLevel()) \
-      LOGF_CATEGORY(logger, VERBOSE, "VLOG" #level, format_str, ##__VA_ARGS__);   \
-  } while (0)
-
-#define VLOGF_USER(logger, level, format_str, ...)                                   \
-  do {                                                                               \
-    if (::onnxruntime::logging::vlog_enabled && level <= (logger).VLOGMaxLevel())    \
-      LOGF_USER_CATEGORY(logger, VERBOSE, "VLOG" #level, format_str, ##__VA_ARGS__); \
-  } while (0)
-#else
-// Disabled in Release builds.
-#define VLOGS(logger, level) \
-  if constexpr (true) {} else LOGS_CATEGORY(logger, VERBOSE, "VLOG" #level)
-#define VLOGS_USER(logger, level) \
-  if constexpr (true) {} else LOGS_USER_CATEGORY(logger, VERBOSE, "VLOG" #level)
-#define VLOGF(logger, level, format_str, ...)
-#define VLOGF_USER(logger, level, format_str, ...)
-#endif
-
-
-
-// Default logger variants
-#define VLOGS_DEFAULT(level) \
-  VLOGS(::onnxruntime::logging::LoggingManager::DefaultLogger(), level)
-
-#define VLOGS_USER_DEFAULT(level) \
-  VLOGS_USER(::onnxruntime::logging::LoggingManager::DefaultLogger(), level)
-
-#define VLOGF_DEFAULT(level, format_str, ...) \
-  VLOGF(::onnxruntime::logging::LoggingManager::DefaultLogger(), level, format_str, ##__VA_ARGS__)
-
-#define VLOGF_USER_DEFAULT(level, format_str, ...) \
-  VLOGF_USER(::onnxruntime::logging::LoggingManager::DefaultLogger(), level, format_str, ##__VA_ARGS__)

arm64-v8a/include/onnxruntime/core/common/logging/severity.h

@@ -1,22 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-namespace onnxruntime {
-namespace logging {
-// mild violation of naming convention. the 'k' lets us use token concatenation in the macro
-// ::onnxruntime::Logging::Severity::k##severity. It's not legal to have ::onnxruntime::Logging::Severity::##severity
-// the uppercase makes the LOG macro usage look as expected for passing an enum value as it will be LOGS(logger, ERROR)
-enum class Severity {
-  kVERBOSE = 0,
-  kINFO = 1,
-  kWARNING = 2,
-  kERROR = 3,
-  kFATAL = 4
-};
-
-constexpr const char* SEVERITY_PREFIX = "VIWEF";
-
-}  // namespace logging
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/make_string.h

@@ -1,126 +0,0 @@
-/**
- * Copyright (c) 2016-present, Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// Portions Copyright (c) Microsoft Corporation
-
-#pragma once
-
-#include <locale>
-#include <sstream>
-#include <type_traits>
-
-namespace onnxruntime {
-
-namespace detail {
-
-inline void MakeStringImpl(std::ostringstream& /*ss*/) noexcept {
-}
-
-template <typename T>
-inline void MakeStringImpl(std::ostringstream& ss, const T& t) noexcept {
-  ss << t;
-}
-
-template <typename T, typename... Args>
-inline void MakeStringImpl(std::ostringstream& ss, const T& t, const Args&... args) noexcept {
-  MakeStringImpl(ss, t);
-  MakeStringImpl(ss, args...);
-}
-
-// see MakeString comments for explanation of why this is necessary
-template <typename... Args>
-inline std::string MakeStringImpl(const Args&... args) noexcept {
-  std::ostringstream ss;
-  MakeStringImpl(ss, args...);
-  return ss.str();
-}
-
-//
-// Infrastructure to convert char[n] to char* to reduce binary size
-//
-
-// default is to leave the type as is
-template <class T>
-struct if_char_array_make_ptr {
-  using type = T;
-};
-
-// specialization that matches an array reference, which is what the char array from a string literal
-// used in a call to MakeString will be.
-// if the type is a char[n] array we 'decay' it to a char* so that the usages can be folded.
-template <class T, size_t N>
-struct if_char_array_make_ptr<T (&)[N]> {
-  // remove a single extent (T[x] -> T, but T[x][y] -> T[y]) so we only match char[x],
-  // and get the type name without the 'const' so both 'const char (&)[n]' and 'char (&)[n]' are matched.
-  using element_type = typename std::remove_const<typename std::remove_extent<T>::type>::type;
-  using type = typename std::conditional<std::is_same<char, element_type>::value, T*, T (&)[N]>::type;
-};
-
-// helper to make usage simpler in MakeString
-template <class T>
-using if_char_array_make_ptr_t = typename if_char_array_make_ptr<T>::type;
-}  // namespace detail
-
-/**
- * Makes a string by concatenating string representations of the arguments.
- * This version uses the current locale.
- */
-template <typename... Args>
-std::string MakeString(const Args&... args) {
-  // We need to update the types from the MakeString template instantiation to decay any char[n] to char*.
-  //   e.g. MakeString("in", "out") goes from MakeString<char[2], char[3]> to MakeStringImpl<char*, char*>
-  //        so that MakeString("out", "in") will also match MakeStringImpl<char*, char*> instead of requiring
-  //        MakeStringImpl<char[3], char[2]>.
-  //
-  // We have to do the type processing before any actual work, so this function purely implements the type processing.
-  // If we do not do it this way we do not get the full binary size reduction.
-  //
-  // See https://stackoverflow.com/a/29418212/684911 for overall details of the approach, but note it does not cover
-  // the need to do the type processing as a separate step.
-
-  return detail::MakeStringImpl(detail::if_char_array_make_ptr_t<Args const&>(args)...);
-}
-
-/**
- * Makes a string by concatenating string representations of the arguments.
- * This version uses std::locale::classic().
- */
-template <typename... Args>
-std::string MakeStringWithClassicLocale(const Args&... args) {
-  std::ostringstream ss;
-  ss.imbue(std::locale::classic());
-  detail::MakeStringImpl(ss, args...);
-  return ss.str();
-}
-
-// MakeString versions for already-a-string types.
-
-inline std::string MakeString(const std::string& str) {
-  return str;
-}
-
-inline std::string MakeString(const char* cstr) {
-  return cstr;
-}
-
-inline std::string MakeStringWithClassicLocale(const std::string& str) {
-  return str;
-}
-
-inline std::string MakeStringWithClassicLocale(const char* cstr) {
-  return cstr;
-}
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/narrow.h

@@ -1,77 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-// onnxruntime::narrow() is like gsl::narrow() but it is also available when exceptions are disabled.
-
-#if !defined(ORT_NO_EXCEPTIONS)
-
-#include "gsl/narrow"
-
-namespace onnxruntime {
-using gsl::narrow;
-}  // namespace onnxruntime
-
-#else  // ^^ !defined(ORT_NO_EXCEPTIONS) ^^ / vv defined(ORT_NO_EXCEPTIONS) vv
-
-#include <cstdio>     // std::fprintf
-#include <exception>  // std::terminate
-#include <type_traits>
-
-#include "gsl/util"  // gsl::narrow_cast
-
-namespace onnxruntime {
-
-namespace detail {
-[[noreturn]] inline void OnNarrowingError() noexcept {
-  std::fprintf(stderr, "%s", "narrowing error\n");
-  std::terminate();
-}
-}  // namespace detail
-
-// This implementation of onnxruntime::narrow was copied and adapted from:
-// https://github.com/microsoft/GSL/blob/a3534567187d2edc428efd3f13466ff75fe5805c/include/gsl/narrow
-
-// narrow() : a checked version of narrow_cast() that terminates if the cast changed the value
-template <class T, class U, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
-// clang-format off
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-                      // clang-format on
-    constexpr T narrow(U u) noexcept {
-  constexpr const bool is_different_signedness =
-      (std::is_signed<T>::value != std::is_signed<U>::value);
-
-  // clang-format off
-GSL_SUPPRESS(es.103) // NO-FORMAT: attribute // don't overflow
-GSL_SUPPRESS(es.104) // NO-FORMAT: attribute // don't underflow
-GSL_SUPPRESS(p.2) // NO-FORMAT: attribute // don't rely on undefined behavior
-  // clang-format on
-  const T t = gsl::narrow_cast<T>(u);  // While this is technically undefined behavior in some cases (i.e., if the source value is of floating-point type
-                                       // and cannot fit into the destination integral type), the resultant behavior is benign on the platforms
-                                       // that we target (i.e., no hardware trap representations are hit).
-
-  if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{})))) {
-    detail::OnNarrowingError();
-  }
-
-  return t;
-}
-
-template <class T, class U, typename std::enable_if<!std::is_arithmetic<T>::value>::type* = nullptr>
-// clang-format off
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-                      // clang-format on
-    constexpr T narrow(U u) noexcept {
-  const T t = gsl::narrow_cast<T>(u);
-
-  if (static_cast<U>(t) != u) {
-    detail::OnNarrowingError();
-  }
-
-  return t;
-}
-
-}  // namespace onnxruntime
-
-#endif  // defined(ORT_NO_EXCEPTIONS)

arm64-v8a/include/onnxruntime/core/common/optional.h

@@ -1,23 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-#include <optional>
-
-namespace onnxruntime {
-
-using std::optional;
-
-#ifndef ORT_NO_EXCEPTIONS
-using std::bad_optional_access;
-#endif
-
-using std::nullopt;
-using std::nullopt_t;
-
-using std::in_place;
-using std::in_place_t;
-
-using std::make_optional;
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/parse_string.h

@@ -1,85 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <locale>
-#include <sstream>
-#include <string_view>
-#include <type_traits>
-
-#include "core/common/common.h"
-
-namespace onnxruntime {
-
-/**
- * Tries to parse a value from an entire string.
- */
-template <typename T>
-bool TryParseStringWithClassicLocale(std::string_view str, T& value) {
-  if constexpr (std::is_integral<T>::value && std::is_unsigned<T>::value) {
-    // if T is unsigned integral type, reject negative values which will wrap
-    if (!str.empty() && str[0] == '-') {
-      return false;
-    }
-  }
-
-  // don't allow leading whitespace
-  if (!str.empty() && std::isspace(str[0], std::locale::classic())) {
-    return false;
-  }
-
-  std::istringstream is{std::string{str}};
-  is.imbue(std::locale::classic());
-  T parsed_value{};
-
-  const bool parse_successful =
-      is >> parsed_value &&
-      is.get() == std::istringstream::traits_type::eof();  // don't allow trailing characters
-  if (!parse_successful) {
-    return false;
-  }
-
-  value = std::move(parsed_value);
-  return true;
-}
-
-inline bool TryParseStringWithClassicLocale(std::string_view str, std::string& value) {
-  value = str;
-  return true;
-}
-
-inline bool TryParseStringWithClassicLocale(std::string_view str, bool& value) {
-  if (str == "0" || str == "False" || str == "false") {
-    value = false;
-    return true;
-  }
-
-  if (str == "1" || str == "True" || str == "true") {
-    value = true;
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Parses a value from an entire string.
- */
-template <typename T>
-Status ParseStringWithClassicLocale(std::string_view s, T& value) {
-  ORT_RETURN_IF_NOT(TryParseStringWithClassicLocale(s, value), "Failed to parse value: \"", value, "\"");
-  return Status::OK();
-}
-
-/**
- * Parses a value from an entire string.
- */
-template <typename T>
-T ParseStringWithClassicLocale(std::string_view s) {
-  T value{};
-  ORT_THROW_IF_ERROR(ParseStringWithClassicLocale(s, value));
-  return value;
-}
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/profiler_common.h

@@ -1,93 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "core/common/common.h"
-
-#include <string>
-#include <unordered_map>
-
-namespace onnxruntime {
-namespace profiling {
-
-enum EventCategory {
-  SESSION_EVENT = 0,
-  NODE_EVENT,
-  KERNEL_EVENT,
-  API_EVENT,
-  EVENT_CATEGORY_MAX
-};
-
-// Event descriptions for the above session events.
-static constexpr const char* event_category_names_[EVENT_CATEGORY_MAX] = {
-    "Session",
-    "Node",
-    "Kernel",
-    "Api"};
-
-// Timing record for all events.
-struct EventRecord {
-  EventRecord() = default;
-  EventRecord(EventCategory category,
-              int process_id,
-              int thread_id,
-              std::string&& event_name,
-              long long time_stamp,
-              long long duration,
-              std::unordered_map<std::string, std::string>&& event_args)
-      : cat(category),
-        pid(process_id),
-        tid(thread_id),
-        name(std::move(event_name)),
-        ts(time_stamp),
-        dur(duration),
-        args(std::move(event_args)) {}
-
-  EventRecord(EventCategory category,
-              int process_id,
-              int thread_id,
-              const std::string& event_name,
-              long long time_stamp,
-              long long duration,
-              const std::unordered_map<std::string, std::string>& event_args)
-      : cat(category),
-        pid(process_id),
-        tid(thread_id),
-        name(event_name),
-        ts(time_stamp),
-        dur(duration),
-        args(event_args) {}
-
-  EventRecord(const EventRecord& other) = default;
-  EventRecord(EventRecord&& other) noexcept = default;
-  EventRecord& operator=(const EventRecord& other) = default;
-  EventRecord& operator=(EventRecord&& other) = default;
-
-  EventCategory cat = EventCategory::API_EVENT;
-  int pid = -1;
-  int tid = -1;
-  std::string name{};
-  long long ts = 0;
-  long long dur = 0;
-  std::unordered_map<std::string, std::string> args{};
-};
-
-using Events = std::vector<EventRecord>;
-
-//Execution Provider Profiler
-class EpProfiler {
- public:
-  virtual ~EpProfiler() = default;
-  virtual bool StartProfiling(TimePoint profiling_start_time) = 0;      // called when profiling starts
-  virtual void EndProfiling(TimePoint start_time, Events& events) = 0;  // called when profiling ends, save all captures numbers to "events"
-  virtual void Start(uint64_t){};                                       // called before op start, accept an id as argument to identify the op
-  virtual void Stop(uint64_t){};                                        // called after op stop, accept an id as argument to identify the op
-};
-
-// Demangle C++ symbols
-std::string demangle(const char* name);
-std::string demangle(const std::string& name);
-
-}  // namespace profiling
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/span_utils.h

@@ -1,88 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <algorithm>
-
-#include "core/common/gsl.h"
-
-namespace onnxruntime {
-
-// AsSpan inspired by Fekir's Blog https://fekir.info/post/span-the-missing-constructor/
-// Used under MIT license
-
-// Use AsSpan for less typing on any container including initializer list to create a span
-// (unnamed, untyped initializer list does not automatically convert to gsl::span).
-// {1, 2, 3} as such does not have a type
-// (see https://scottmeyers.blogspot.com/2014/03/if-braced-initializers-have-no-type-why.html)
-//
-//   Example: AsSpan({1, 2, 3}) results in gsl::span<const int>
-//
-// The above would deduce to std::initializer_list<int> and the result is gsl::span<const int>
-//
-// AsSpan<int64_t>({1, 2, 3}) produces gsl::span<const int64_t>
-//
-// We can also do std::array<int64_t, 3>{1, 2, 3} that can be automatically converted to span
-// without memory allocation.
-//
-// If type conversion is not required, then for C++17 std::array template parameters are
-// auto-deduced. Example: std::array{1, 2, 3}.
-// We are aiming at not allocating memory dynamically.
-
-namespace details {
-template <class P>
-constexpr auto AsSpanImpl(P* p, size_t s) {
-  return gsl::span<P>(p, s);
-}
-}  // namespace details
-
-template <class C>
-constexpr auto AsSpan(C& c) {
-  return details::AsSpanImpl(c.data(), c.size());
-}
-
-template <class C>
-constexpr auto AsSpan(const C& c) {
-  return details::AsSpanImpl(c.data(), c.size());
-}
-
-template <class C>
-constexpr auto AsSpan(C&& c) {
-  return details::AsSpanImpl(c.data(), c.size());
-}
-
-template <class T>
-constexpr auto AsSpan(std::initializer_list<T> c) {
-  return details::AsSpanImpl(c.begin(), c.size());
-}
-
-template <class T, size_t N>
-constexpr auto AsSpan(T (&arr)[N]) {
-  return details::AsSpanImpl(arr, N);
-}
-
-template <class T, size_t N>
-constexpr auto AsSpan(const T (&arr)[N]) {
-  return details::AsSpanImpl(arr, N);
-}
-
-template <class T>
-inline gsl::span<const T> EmptySpan() { return gsl::span<const T>(); }
-
-template <class U, class T>
-[[nodiscard]] inline gsl::span<U> ReinterpretAsSpan(gsl::span<T> src) {
-  // adapted from gsl-lite span::as_span():
-  // https://github.com/gsl-lite/gsl-lite/blob/4720a2980a30da085b4ddb4a0ea2a71af7351a48/include/gsl/gsl-lite.hpp#L4102-L4108
-  Expects(src.size_bytes() % sizeof(U) == 0);
-  return gsl::span<U>(reinterpret_cast<U*>(src.data()), src.size_bytes() / sizeof(U));
-}
-
-template <class T1, size_t Extent1, class T2, size_t Extent2>
-[[nodiscard]] inline bool SpanEq(gsl::span<T1, Extent1> a, gsl::span<T2, Extent2> b) {
-  static_assert(std::is_same_v<std::remove_const_t<T1>, std::remove_const_t<T2>>,
-                "T1 and T2 should be the same type except for const qualification");
-  return std::equal(a.begin(), a.end(), b.begin(), b.end());
-}
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/spin_pause.h

@@ -1,28 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#if defined(_M_AMD64)
-#include <intrin.h>
-#endif
-
-#if defined(__x86_64__)
-#include <xmmintrin.h>
-#endif
-
-namespace onnxruntime {
-
-namespace concurrency {
-
-// Intrinsic to use in spin-loops
-
-inline void SpinPause() {
-#if defined(_M_AMD64) || defined(__x86_64__)
-  _mm_pause();
-#endif
-}
-
-}  // namespace concurrency
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/status.h

@@ -1,195 +0,0 @@
-/* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-==============================================================================*/
-// Modifications Copyright (c) Microsoft.
-
-#pragma once
-
-#include <memory>
-#include <ostream>
-#include <string>
-#ifdef _WIN32
-#include <winerror.h>
-#endif
-#include "core/common/gsl.h"
-namespace onnxruntime {
-namespace common {
-
-enum StatusCategory {
-  NONE = 0,
-  SYSTEM = 1,
-  ONNXRUNTIME = 2,
-};
-
-/**
-   Error code for ONNXRuntime.
-*/
-enum StatusCode {
-  OK = 0,
-  FAIL = 1,
-  INVALID_ARGUMENT = 2,
-  NO_SUCHFILE = 3,
-  NO_MODEL = 4,
-  ENGINE_ERROR = 5,
-  RUNTIME_EXCEPTION = 6,
-  INVALID_PROTOBUF = 7,
-  MODEL_LOADED = 8,
-  NOT_IMPLEMENTED = 9,
-  INVALID_GRAPH = 10,
-  EP_FAIL = 11
-};
-
-constexpr const char* StatusCodeToString(StatusCode status) noexcept {
-  switch (status) {
-    case StatusCode::OK:
-      return "SUCCESS";
-    case StatusCode::FAIL:
-      return "FAIL";
-    case StatusCode::INVALID_ARGUMENT:
-      return "INVALID_ARGUMENT";
-    case StatusCode::NO_SUCHFILE:
-      return "NO_SUCHFILE";
-    case StatusCode::NO_MODEL:
-      return "NO_MODEL";
-    case StatusCode::ENGINE_ERROR:
-      return "ENGINE_ERROR";
-    case StatusCode::RUNTIME_EXCEPTION:
-      return "RUNTIME_EXCEPTION";
-    case StatusCode::INVALID_PROTOBUF:
-      return "INVALID_PROTOBUF";
-    case StatusCode::MODEL_LOADED:
-      return "MODEL_LOADED";
-    case StatusCode::NOT_IMPLEMENTED:
-      return "NOT_IMPLEMENTED";
-    case StatusCode::INVALID_GRAPH:
-      return "INVALID_GRAPH";
-    case StatusCode::EP_FAIL:
-      return "EP_FAIL";
-    default:
-      return "GENERAL ERROR";
-  }
-}
-
-#ifdef _WIN32
-constexpr HRESULT StatusCodeToHRESULT(StatusCode status) noexcept {
-  switch (status) {
-    case StatusCode::OK:
-      return S_OK;
-    case StatusCode::FAIL:
-      return E_FAIL;
-    case StatusCode::INVALID_ARGUMENT:
-      return E_INVALIDARG;
-    case StatusCode::NO_SUCHFILE:
-      return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-    case StatusCode::NO_MODEL:
-      return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
-    case StatusCode::ENGINE_ERROR:
-      return E_FAIL;
-    case StatusCode::RUNTIME_EXCEPTION:
-      return E_FAIL;
-    case StatusCode::INVALID_PROTOBUF:
-      return HRESULT_FROM_WIN32(ERROR_FILE_CORRUPT);
-    case StatusCode::MODEL_LOADED:
-      return HRESULT_FROM_WIN32(ERROR_INTERNAL_ERROR);
-    case StatusCode::NOT_IMPLEMENTED:
-      return E_NOTIMPL;
-    case StatusCode::INVALID_GRAPH:
-      return HRESULT_FROM_WIN32(ERROR_FILE_CORRUPT);
-    case StatusCode::EP_FAIL:
-      return HRESULT_FROM_WIN32(ERROR_INTERNAL_ERROR);
-    default:
-      return E_FAIL;
-  }
-}
-#endif
-
-class [[nodiscard]] Status {
- public:
-  Status() noexcept = default;
-
-  Status(StatusCategory category, int code, const std::string& msg);
-
-  Status(StatusCategory category, int code, const char* msg);
-
-  Status(StatusCategory category, int code);
-
-  GSL_SUPPRESS(r.11)
-  Status(const Status& other)
-      : state_((other.state_ == nullptr) ? nullptr : new State(*other.state_)) {}
-  GSL_SUPPRESS(r.11)
-  Status& operator=(const Status& other) {
-    if (state_ != other.state_) {
-      if (other.state_ == nullptr) {
-        state_.reset();
-      } else {
-        state_.reset(new State(*other.state_));
-      }
-    }
-    return *this;
-  }
-
-  Status(Status&&) = default;
-  Status& operator=(Status&&) = default;
-  ~Status() = default;
-
-  bool IsOK() const {
-    return (state_ == nullptr);
-  }
-
-  int Code() const noexcept;
-
-  StatusCategory Category() const noexcept;
-
-  const std::string& ErrorMessage() const noexcept;
-
-  std::string ToString() const;
-
-  bool operator==(const Status& other) const {
-    return (this->state_ == other.state_) || (ToString() == other.ToString());
-  }
-
-  bool operator!=(const Status& other) const {
-    return !(*this == other);
-  }
-
-  static Status OK() {
-    return Status();
-  }
-
- private:
-  static const std::string& EmptyString() noexcept;
-
-  struct State {
-    State(StatusCategory cat0, int code0, const std::string& msg0)
-        : category(cat0), code(code0), msg(msg0) {}
-
-    State(StatusCategory cat0, int code0, const char* msg0)
-        : category(cat0), code(code0), msg(msg0) {}
-
-    const StatusCategory category;
-    const int code;
-    const std::string msg;
-  };
-
-  // As long as Code() is OK, state_ == nullptr.
-  std::unique_ptr<State> state_;
-};
-
-inline std::ostream& operator<<(std::ostream& out, const Status& status) {
-  return out << status.ToString();
-}
-
-}  // namespace common
-
-// make Status directly available in the onnxruntime namespace as it is widely used
-using common::Status;
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/common/string_helper.h

@@ -1,11 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-#include <string>
-
-// forward declaration
-struct OrtAllocator;
-namespace onnxruntime {
-char* StrDup(const std::string& str, OrtAllocator* allocator);
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/alloc_kind.h

@@ -1,36 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-#include <iosfwd>
-
-namespace onnxruntime {
-// The ml-Values fall into the following categories with respect to their
-// memory management:
-//   - inference inputs: owned (allocated and freed) by caller, and is by
-//     default read-only by the runtime.
-//   - inference outputs: allocated by runtime, ownership transferred to
-//     caller. TODO: Make sure this semantics is clear in InferenceSession API.
-//   - weights (constant tensors): can be allocated once (statically), and
-//     reused by all inference calls within an InferenceSession.
-//   - tensor values: The lifetimes of these tensor-values are statically
-//     determined, which is used for memory reuse/sharing optimizations. The
-//     runtime allocates/frees these values at the right time (as determined
-//     by the static allocation plan). Note that this is simplified since we
-//     do not try to optimize for "slice" like ops, where we may be able to
-//     conditionally reuse memory/data in some cases but not others.
-//     Generalizing this is future work.
-
-enum class AllocKind {
-  kNotSet = -1,
-  kAllocate = 0,
-  kReuse = 1,
-  kPreExisting = 2,
-  kAllocateStatically = 3,
-  kAllocateOutput = 4,
-  kShare = 5,
-  kAllocatedExternally = 6
-};
-
-std::ostream& operator<<(std::ostream& out, AllocKind alloc_kind);
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/allocator.h

@@ -1,194 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "core/common/common.h"
-#include "core/framework/allocator_stats.h"
-#include "core/session/onnxruntime_c_api.h"
-#include "ortdevice.h"
-#include "ortmemoryinfo.h"
-
-// This configures the arena based allocator used by ORT
-// See docs/C_API.md for details on what these mean and how to choose these values
-struct OrtArenaCfg {
-  OrtArenaCfg() : max_mem(0),
-                  arena_extend_strategy(-1),
-                  initial_chunk_size_bytes(-1),
-                  max_dead_bytes_per_chunk(-1),
-                  initial_growth_chunk_size_bytes(-1) {}
-  OrtArenaCfg(size_t max_mem, int arena_extend_strategy, int initial_chunk_size_bytes,
-              int max_dead_bytes_per_chunk, int initial_growth_chunk_size_bytes)
-      : max_mem(max_mem),
-        arena_extend_strategy(arena_extend_strategy),
-        initial_chunk_size_bytes(initial_chunk_size_bytes),
-        max_dead_bytes_per_chunk(max_dead_bytes_per_chunk),
-        initial_growth_chunk_size_bytes(initial_growth_chunk_size_bytes) {}
-
-  size_t max_mem;                       // use 0 to allow ORT to choose the default
-  int arena_extend_strategy;            // use -1 to allow ORT to choose the default, 0 = kNextPowerOfTwo, 1 = kSameAsRequested
-  int initial_chunk_size_bytes;         // use -1 to allow ORT to choose the default
-  int max_dead_bytes_per_chunk;         // use -1 to allow ORT to choose the default
-  int initial_growth_chunk_size_bytes;  // use -1 to allow ORT to choose the default
-};
-
-namespace onnxruntime {
-constexpr const char* CPU = "Cpu";
-constexpr const char* CUDA = "Cuda";
-constexpr const char* CUDA_PINNED = "CudaPinned";
-constexpr const char* CANN = "Cann";
-constexpr const char* CANN_PINNED = "CannPinned";
-constexpr const char* DML = "DML";
-constexpr const char* HIP = "Hip";
-constexpr const char* HIP_PINNED = "HipPinned";
-constexpr const char* OpenVINO_CPU = "OpenVINO_CPU";
-constexpr const char* OpenVINO_GPU = "OpenVINO_GPU";
-
-constexpr size_t kAllocAlignment = 256;
-
-class IAllocator;
-class Stream;
-namespace synchronize {
-class Notification;
-}
-using WaitNotificationFn = std::function<void(Stream&, synchronize::Notification&)>;
-void* AllocateBufferWithOptions(IAllocator& allocator, size_t size, bool use_reserve, Stream* stream, WaitNotificationFn wait_fn);
-
-template <typename T>
-using IAllocatorUniquePtr = std::unique_ptr<T, std::function<void(T*)>>;
-
-class IAllocator {
- public:
-  IAllocator(const OrtMemoryInfo& info) : memory_info_(info) {}
-  virtual ~IAllocator() = default;
-  /**
-  @remarks Use SafeInt when calculating the size of memory to allocate using Alloc.
-  */
-  virtual void* Alloc(size_t size) = 0;
-
-  virtual void Free(void* p) = 0;
-
-  // TODO: Find a better name than Reserve() and update in all places.
-  // Reserve() is an interface exposed for an implementation of IAllocator
-  // to optionally implement some allocation logic that by-passes any arena-based
-  // logic that may be housed in the Alloc() implementation.
-  // There are SessionOptions config(s) that allow users to allocate some memory
-  // by-passing arena-based logic.
-  // By default, the base implementation  just calls Alloc().
-  virtual void* Reserve(size_t size) { return Alloc(size); }
-
-  const OrtMemoryInfo& Info() const { return memory_info_; };
-
-  // Each implementation of IAllocator can override and provide their own implementation
-  virtual void GetStats(AllocatorStats* /*stats*/) { return; }
-
-  static bool CalcMemSizeForArray(size_t nmemb, size_t size, size_t* out) noexcept {
-    return CalcMemSizeForArrayWithAlignment(nmemb, size, 0, out);
-  }
-
-  /**
-   * Calculate the memory size for an array. The size is bounds checked using SafeInt.
-   * \tparam alignment must be power of 2
-   * \param nmemb Number of members or elements in the array
-   * \param size Size of each element
-   * \param out Total size required after any alignment is applied
-   * \return true, successful. false, overflow
-   */
-  [[nodiscard]] static bool CalcMemSizeForArrayWithAlignment(size_t nmemb, size_t size, size_t alignment, size_t* out) noexcept;
-
-  /**
-   * https://cwe.mitre.org/data/definitions/190.html
-   * \param alignment must be power of 2
-   * \param nmemb Number of members or elements in the array
-   * \param size Size of each element
-   * \param out Total size required after any alignment is applied
-   * \return true, successful. false, overflow
-   * \remarks This was the original API and was implemented in the header. Replaced with the above version
-   *          implemented in the .cc file so that the SafeInt dependency is internal.
-   */
-  template <size_t alignment>
-  [[nodiscard]] static bool CalcMemSizeForArrayWithAlignment(size_t nmemb, size_t size, size_t* out) noexcept;
-
-  /**
-   * allocate memory for an array which has nmemb items of data, each size bytes long
-   */
-  void* AllocArray(size_t nmemb, size_t size) {
-    size_t len;
-    if (!CalcMemSizeForArray(nmemb, size, &len))
-      return nullptr;
-    return Alloc(len);
-  }
-
-  /**
-   * allocate memory for an array which has nmemb items of data, each size bytes long
-   */
-  template <size_t alignment>
-  void* AllocArrayWithAlignment(size_t nmemb, size_t size) {
-    size_t len;
-    if (!CalcMemSizeForArrayWithAlignment(nmemb, size, alignment, &len))
-      return nullptr;
-    return Alloc(len);
-  }
-
-  /**
-     Create a std::unique_ptr that is allocated and freed by the provided IAllocator.
-     @param allocator The allocator.
-     @param count_or_bytes The exact bytes to allocate if T is void, otherwise the number of elements to allocate.
-     @param use_reserve If true, call Reserve() instead of Alloc() to allocate memory.
-     @param stream Which stream instance allocated chunk will be used with.
-     @param wait_fn If the allocator want to dynamic reuse a chunk from another stream, use this wait_fn to sync on
-                    the target stream to make the reuse safe.
-     @returns std::unique_ptr with allocated memory and deleter.
-  */
-  template <typename T>
-  static IAllocatorUniquePtr<T> MakeUniquePtr(std::shared_ptr<IAllocator> allocator, size_t count_or_bytes,
-                                              bool use_reserve = false,
-                                              Stream* stream = nullptr, WaitNotificationFn wait_fn = nullptr) {
-    if (allocator == nullptr) return nullptr;
-    // for now limit to fundamental types. we could support others, but to do so either we or the caller
-    // needs to call the dtor for the objects, for buffers allocated on device we don't have destructor
-    // static_assert(std::is_fundamental<T>::value, "Fundamental type required as no destructors are called.");
-
-    size_t alloc_size = count_or_bytes;
-
-    // if T is not void, 'count_or_bytes' == number of items so allow for that
-    if constexpr (!std::is_void<T>::value) {
-      // sizeof(void) isn't valid, but the compiler isn't smart enough to ignore that this line isn't
-      // reachable if T is void. use std::conditional to 'use' void* in the sizeof call
-      if (!CalcMemSizeForArray(
-              count_or_bytes, sizeof(typename std::conditional<std::is_void<T>::value, void*, T>::type), &alloc_size)) {
-        return nullptr;
-      }
-    }
-
-    // allocate
-    T* p = static_cast<T*>(AllocateBufferWithOptions(*allocator, alloc_size, use_reserve, stream, std::move(wait_fn)));
-    return IAllocatorUniquePtr<T>{
-        p,
-        [allocator = std::move(allocator)](T* p) { allocator->Free(p); }};
-  }
-
- private:
-  OrtMemoryInfo memory_info_;
-};
-
-template <size_t alignment>
-bool IAllocator::CalcMemSizeForArrayWithAlignment(size_t nmemb, size_t size, size_t* out) noexcept {
-  return CalcMemSizeForArrayWithAlignment(nmemb, size, alignment, out);
-}
-
-class CPUAllocator : public IAllocator {
- public:
-  explicit CPUAllocator(const OrtMemoryInfo& memory_info) : IAllocator(memory_info) {}
-
-  CPUAllocator() : IAllocator(OrtMemoryInfo(CPU, OrtAllocatorType::OrtDeviceAllocator)) {}
-
-  void* Alloc(size_t size) override;
-  void Free(void* p) override;
-};
-
-using AllocatorPtr = std::shared_ptr<IAllocator>;
-
-void* AllocatorDefaultAlloc(size_t size);
-void AllocatorDefaultFree(void* p);
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/buffer_deleter.h

@@ -1,36 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "core/framework/allocator.h"
-
-namespace onnxruntime {
-
-// TODO: Do we need this class or is IAllocator::MakeUniquePtr sufficient/better
-class BufferDeleter {
- public:
-  BufferDeleter() = default;
-  explicit BufferDeleter(AllocatorPtr alloc)
-      : alloc_(std::move(alloc)) {}
-
-  void operator()(void* p) const {
-    if (alloc_)
-      alloc_->Free(p);
-  }
-
- private:
-  // TODO: we may need consider the lifetime of alloc carefully
-  // The alloc_ here is the allocator that used to allocate the buffer
-  // And need go with the unique_ptr together. If it is using our internal
-  // allocator, it is ok as our allocators are global managed. But if it
-  // is provide by user, user need to be very careful about it.
-  // A weak_ptr may be a choice to reduce the impact, but that require to
-  // change our current allocator mgr to use shared_ptr. Will revisit it
-  // later.
-  AllocatorPtr alloc_{nullptr};
-};
-
-using BufferUniquePtr = std::unique_ptr<void, BufferDeleter>;
-using BufferNakedPtr = void*;
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/customregistry.h

@@ -1,60 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "core/common/status.h"
-#include "core/common/logging/logging.h"
-#include "core/framework/op_kernel.h"
-#include "core/framework/kernel_def_builder.h"
-#include "core/framework/kernel_registry.h"
-
-#if !defined(ORT_MINIMAL_BUILD)
-#include "core/graph/schema_registry.h"
-#endif
-
-namespace onnxruntime {
-
-/**
-   Represents a registry that contains both custom kernels and custom schemas.
-*/
-class CustomRegistry final {
- public:
-  CustomRegistry()
-      : kernel_registry_(std::make_shared<KernelRegistry>())
-#if !defined(ORT_MINIMAL_BUILD)
-        ,
-        opschema_registry_(std::make_shared<onnxruntime::OnnxRuntimeOpSchemaRegistry>())
-#endif
-  {
-  }
-
-  /**
-   * Register a kernel definition together with kernel factory method to this session.
-   * If any conflict happened between registered kernel def and built-in kernel def,
-   * registered kernel will have higher priority.
-   * Call this before invoking Initialize().
-   * @return OK if success.
-   */
-  common::Status RegisterCustomKernel(KernelDefBuilder& kernel_def_builder, const KernelCreateFn& kernel_creator);
-
-  common::Status RegisterCustomKernel(KernelCreateInfo&);
-
-  const std::shared_ptr<KernelRegistry>& GetKernelRegistry();
-
-#if !defined(ORT_MINIMAL_BUILD)
-  common::Status RegisterOpSet(std::vector<ONNX_NAMESPACE::OpSchema>& schemas, const std::string& domain,
-                               int baseline_opset_version, int opset_version);
-
-  const std::shared_ptr<onnxruntime::OnnxRuntimeOpSchemaRegistry>& GetOpschemaRegistry();
-#endif
-
- private:
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(CustomRegistry);
-  std::shared_ptr<KernelRegistry> kernel_registry_;
-#if !defined(ORT_MINIMAL_BUILD)
-  std::shared_ptr<onnxruntime::OnnxRuntimeOpSchemaRegistry> opschema_registry_;
-#endif
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/data_types.h

@@ -1,1062 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <cstdint>
-#include <cstring>
-#include <string>
-#include <type_traits>
-#include <map>
-#include <unordered_map>
-#include "core/common/gsl.h"
-#include "core/common/common.h"
-#include "core/common/exceptions.h"
-#include "core/framework/endian.h"
-#include "core/framework/float16.h"
-#include "core/framework/to_tensor_proto_element_type.h"
-#if !defined(ORT_MINIMAL_BUILD)
-#include "onnx/defs/schema.h"
-#else
-#include "onnx/defs/data_type_utils.h"
-#endif
-#include "onnx/onnx_pb.h"
-#include "onnx/onnx-operators_pb.h"
-
-struct OrtValue;
-
-namespace ONNX_NAMESPACE {
-class TypeProto;
-}  // namespace ONNX_NAMESPACE
-
-namespace onnxruntime {
-/// Predefined registered types
-
-#if !defined(DISABLE_ML_OPS)
-
-// maps (only used by ML ops)
-using MapStringToString = std::map<std::string, std::string>;
-using MapStringToInt64 = std::map<std::string, int64_t>;
-using MapStringToFloat = std::map<std::string, float>;
-using MapStringToDouble = std::map<std::string, double>;
-using MapInt64ToString = std::map<int64_t, std::string>;
-using MapInt64ToInt64 = std::map<int64_t, int64_t>;
-using MapInt64ToFloat = std::map<int64_t, float>;
-using MapInt64ToDouble = std::map<int64_t, double>;
-
-// vectors/sequences
-using VectorMapStringToFloat = std::vector<MapStringToFloat>;
-using VectorMapInt64ToFloat = std::vector<MapInt64ToFloat>;
-
-#endif
-
-using VectorString = std::vector<std::string>;
-using VectorInt64 = std::vector<int64_t>;
-
-// Forward declarations
-class DataTypeImpl;
-class TensorTypeBase;
-#if !defined(DISABLE_SPARSE_TENSORS)
-class SparseTensorTypeBase;
-#endif
-class SequenceTensorTypeBase;
-class NonTensorTypeBase;
-#if !defined(DISABLE_OPTIONAL_TYPE)
-class OptionalTypeBase;
-#endif
-class PrimitiveDataTypeBase;
-class Tensor;
-class TensorSeq;
-
-// DataTypeImpl pointer as unique DataTypeImpl identifier.
-using MLDataType = const DataTypeImpl*;
-// be used with class MLValue
-using DeleteFunc = void (*)(void*);
-using CreateFunc = void* (*)();
-
-/**
- * \brief Base class for MLDataType
- *
- */
-class DataTypeImpl {
- public:
-  enum class GeneralType {
-    kInvalid = 0,
-    kNonTensor = 1,
-    kTensor = 2,
-    kTensorSequence = 3,
-    kSparseTensor = 4,
-    kOptional = 5,
-    kPrimitive = 6,
-  };
-
-  const GeneralType type_;
-  const size_t size_;
-
- protected:
-  DataTypeImpl(GeneralType type, size_t size) : type_{type}, size_{size} {}
-
- public:
-  virtual ~DataTypeImpl() = default;
-
-  /**
-   * \brief this API will be used to check type compatibility at runtime
-   *
-   * \param type_proto a TypeProto instance that is constructed for a specific type
-   *        will be checked against a TypeProto instance contained within a corresponding
-   *        MLDataType instance.
-   */
-  virtual bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const = 0;
-
-  size_t Size() const { return size_; }
-
-  virtual DeleteFunc GetDeleteFunc() const = 0;
-
-  /**
-   * \brief Retrieves an instance of TypeProto for
-   *        a given MLDataType
-   * \returns optional TypeProto. Only ONNX types
-              has type proto, non-ONNX types will return nullptr.
-   */
-  virtual const ONNX_NAMESPACE::TypeProto* GetTypeProto() const = 0;
-
-  bool IsTensorType() const {
-    return type_ == GeneralType::kTensor;
-  }
-
-  bool IsTensorSequenceType() const {
-    return type_ == GeneralType::kTensorSequence;
-  }
-
-  bool IsSparseTensorType() const {
-    return type_ == GeneralType::kSparseTensor;
-  }
-
-  bool IsOptionalType() const {
-    return type_ == GeneralType::kOptional;
-  }
-
-  bool IsNonTensorType() const {
-    return type_ == GeneralType::kNonTensor;
-  }
-
-  bool IsPrimitiveDataType() const {
-    return type_ == GeneralType::kPrimitive;
-  }
-
-  // Returns this if this is of tensor-type and null otherwise
-  const TensorTypeBase* AsTensorType() const;
-
-  const SequenceTensorTypeBase* AsSequenceTensorType() const;
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-  // Returns this if this is of sparse-tensor-type and null otherwise
-  const SparseTensorTypeBase* AsSparseTensorType() const;
-#endif
-
-#if !defined(DISABLE_OPTIONAL_TYPE)
-  const OptionalTypeBase* AsOptionalType() const;
-#endif
-
-  const NonTensorTypeBase* AsNonTensorType() const;
-
-  // Returns this if this is one of the primitive data types (specialization of PrimitiveDataTypeBase)
-  // and null otherwise
-  const PrimitiveDataTypeBase* AsPrimitiveDataType() const;
-
-  // Return the type meta that we are using in the runtime.
-  template <typename T>
-  static MLDataType GetType();
-
-  // Return the types for a concrete tensor type, like Tensor_Float
-  template <typename elemT>
-  static MLDataType GetTensorType();
-
-  template <typename elemT>
-  static MLDataType GetSequenceTensorType();
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-  // Return the MLDataType for a concrete sparse tensor type.
-  template <typename elemT>
-  static MLDataType GetSparseTensorType();
-#endif
-
-  template <typename T, typename elemT>
-  static MLDataType GetOptionalType();
-
-  /**
-   * Convert an ONNX TypeProto to onnxruntime DataTypeImpl.
-   * However, this conversion is lossy. Don't try to use 'this->GetTypeProto()' converting it back.
-   * Even though GetTypeProto() will not have the original information, it will still have enough to correctly
-   * map to MLDataType.
-   * \param proto
-   */
-  static MLDataType TypeFromProto(const ONNX_NAMESPACE::TypeProto& proto);
-
-  static const TensorTypeBase* TensorTypeFromONNXEnum(int type);
-  static const SequenceTensorTypeBase* SequenceTensorTypeFromONNXEnum(int type);
-#if !defined(DISABLE_SPARSE_TENSORS)
-  static const SparseTensorTypeBase* SparseTensorTypeFromONNXEnum(int type);
-#endif
-
-  static const char* ToString(MLDataType type);
-  static std::vector<std::string> ToString(const std::vector<MLDataType>& types);
-  // Registers ONNX_NAMESPACE::DataType (internalized string) with
-  // MLDataType. DataType is produced by internalizing an instance of
-  // TypeProto contained within MLDataType
-  static void RegisterDataType(MLDataType);
-  static MLDataType GetDataType(const std::string&);
-
-  static const std::vector<MLDataType>& AllTensorTypes();
-  static const std::vector<MLDataType>& AllFixedSizeTensorTypes();
-  static const std::vector<MLDataType>& AllSequenceTensorTypes();
-  static const std::vector<MLDataType>& AllFixedSizeSequenceTensorTypes();
-  static const std::vector<MLDataType>& AllNumericTensorTypes();
-  static const std::vector<MLDataType>& AllIEEEFloatTensorTypes();
-  static const std::vector<MLDataType>& AllFixedSizeTensorExceptHalfTypes();
-  static const std::vector<MLDataType>& AllIEEEFloatTensorExceptHalfTypes();
-  static const std::vector<MLDataType>& AllTensorAndSequenceTensorTypes();
-  static const std::vector<MLDataType>& AllFixedSizeTensorAndSequenceTensorTypes();
-  static const std::vector<MLDataType>& AllOptionalTypes();
-  static const std::vector<MLDataType>& AllTensorAndSequenceTensorAndOptionalTypes();
-};
-
-std::ostream& operator<<(std::ostream& out, MLDataType data_type);
-
-/*
- * Type registration helpers
- */
-namespace data_types_internal {
-/// TensorType helpers
-///
-
-/// Is a given type on the list of types?
-/// Accepts a list of types and the first argument is the type
-/// We are checking if it is listed among those that follow
-template <typename T, typename... Types>
-struct IsAnyOf;
-
-/// Two types remaining, end of the list
-template <typename T, typename Tail>
-struct IsAnyOf<T, Tail> : public std::is_same<T, Tail> {
-};
-
-template <typename T, typename H, typename... Tail>
-struct IsAnyOf<T, H, Tail...> {
-  static constexpr bool value = (std::is_same<T, H>::value ||
-                                 IsAnyOf<T, Tail...>::value);
-};
-
-/// Tells if the specified type is one of fundamental types
-/// that can be contained within a tensor.
-/// We do not have raw fundamental types, rather a subset
-/// of fundamental types is contained within tensors.
-template <typename T>
-struct IsTensorContainedType : public IsAnyOf<T, float, uint8_t, int8_t, uint16_t, int16_t,
-                                              int32_t, int64_t, std::string, bool, MLFloat16,
-                                              double, uint32_t, uint64_t, BFloat16> {
-};
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-/// Use "IsSparseTensorContainedType<T>::value" to test if a type T
-/// is permitted as the element-type of a sparse-tensor.
-
-template <typename T>
-struct IsSparseTensorContainedType : public IsAnyOf<T, float, uint8_t, int8_t, uint16_t, int16_t,
-                                                    int32_t, int64_t, std::string, bool, MLFloat16,
-                                                    double, uint32_t, uint64_t, BFloat16> {
-};
-#endif
-
-#if !defined(DISABLE_OPTIONAL_TYPE)
-/// Tells if the specified type is one of ORT types
-/// that can be contained within an optional struct.
-template <typename T>
-struct IsOptionalOrtType : public IsAnyOf<T, Tensor, TensorSeq> {
-};
-#endif
-
-/// This template's Get() returns a corresponding MLDataType
-/// It dispatches the call to either GetTensorType<>() or
-/// GetType<>()
-template <typename T, bool TensorContainedType>
-struct GetMLDataType;
-
-template <typename T>
-struct GetMLDataType<T, true> {
-  static MLDataType Get() {
-    return DataTypeImpl::GetTensorType<T>();
-  }
-};
-
-template <typename T>
-struct GetMLDataType<T, false> {
-  static MLDataType Get() {
-    return DataTypeImpl::GetType<T>();
-  }
-};
-
-struct TensorTypeHelper {
-  static void Set(ONNX_NAMESPACE::TensorProto_DataType element_type,
-                  ONNX_NAMESPACE::TypeProto& proto) {
-    proto.mutable_tensor_type()->set_elem_type(element_type);
-  }
-};
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-struct SparseTensorTypeHelper {
-  static void Set(ONNX_NAMESPACE::TensorProto_DataType element_type,
-                  ONNX_NAMESPACE::TypeProto& proto) {
-    proto.mutable_sparse_tensor_type()->set_elem_type(element_type);
-  }
-};
-#endif  // !defined(DISABLE_SPARSE_TENSORS)
-
-#if !defined(DISABLE_ML_OPS)
-/// Map helpers
-
-void CopyMutableMapValue(const ONNX_NAMESPACE::TypeProto&,
-                         ONNX_NAMESPACE::TypeProto&);
-
-struct MapTypeHelper {
-  // V can be either a primitive type (in which case it is a tensor)
-  // or other preregistered types
-  template <typename V>
-  static MLDataType GetValueType() {
-    return GetMLDataType<V, IsTensorContainedType<V>::value>::Get();
-  }
-
-  static void Set(ONNX_NAMESPACE::TensorProto_DataType key_type, const ONNX_NAMESPACE::TypeProto* value_proto,
-                  ONNX_NAMESPACE::TypeProto& proto) {
-    ORT_ENFORCE(value_proto != nullptr, "expected a registered ONNX type");
-    proto.mutable_map_type()->set_key_type(key_type);
-    CopyMutableMapValue(*value_proto, proto);
-  }
-};
-#endif
-
-/// Sequence helpers
-
-// Element type is a primitive type so we set it to a tensor<elemT>
-void CopyMutableSeqElement(const ONNX_NAMESPACE::TypeProto&,
-                           ONNX_NAMESPACE::TypeProto&);
-
-// helper to create TypeProto with minimal binary size impact
-struct SequenceTypeHelper {
-  template <typename T>
-  static MLDataType GetElemType() {
-    return GetMLDataType<T, IsTensorContainedType<T>::value>::Get();
-  }
-
-  static void Set(const ONNX_NAMESPACE::TypeProto* elem_proto,
-                  ONNX_NAMESPACE::TypeProto& proto) {
-    ORT_ENFORCE(elem_proto != nullptr, "expected a registered ONNX type");
-    CopyMutableSeqElement(*elem_proto, proto);
-  }
-};
-
-/// Optional helpers
-
-void CopyMutableOptionalElement(const ONNX_NAMESPACE::TypeProto&,
-                                ONNX_NAMESPACE::TypeProto&);
-
-// helper to create TypeProto with minimal binary size impact
-struct OptionalTypeHelper {
-  template <typename T, typename elemT>
-  static MLDataType GetElemType() {
-    if constexpr (std::is_same<T, Tensor>::value) {
-      return DataTypeImpl::GetTensorType<elemT>();
-    } else {
-      static_assert(std::is_same<T, TensorSeq>::value, "Unsupported element type for optional type");
-      return DataTypeImpl::GetSequenceTensorType<elemT>();
-    }
-  }
-
-  static void Set(const onnx::TypeProto* elem_proto, ONNX_NAMESPACE::TypeProto& proto) {
-    ORT_ENFORCE(elem_proto != nullptr, "expected a registered ONNX type");
-    CopyMutableOptionalElement(*elem_proto, proto);
-  }
-};
-
-/// OpaqueTypes helpers
-
-void AssignOpaqueDomainName(const char* domain, const char* name,
-                            ONNX_NAMESPACE::TypeProto& proto);
-
-}  // namespace data_types_internal
-
-//The suppressed warning is: "The type with a virtual function needs either public virtual or protected nonvirtual destructor."
-//However, we do not allocate this type on heap.
-#if defined(_MSC_VER) && !defined(__clang__)
-#pragma warning(push)
-#pragma warning(disable : 26436)
-#endif
-/// All tensors base
-class TensorTypeBase : public DataTypeImpl {
- public:
-  static MLDataType Type();
-
-  /// We first compare type_proto pointers and then
-  /// if they do not match try to account for the case
-  /// where TypeProto was created ad-hoc and not queried from MLDataType
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const override;
-
-  DeleteFunc GetDeleteFunc() const override;
-
-  const ONNX_NAMESPACE::TypeProto* GetTypeProto() const override;
-
-  virtual MLDataType GetElementType() const {
-    // should never reach here.
-    ORT_NOT_IMPLEMENTED(__FUNCTION__, " is not implemented");
-  }
-
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(TensorTypeBase);
-
- protected:
-  ONNX_NAMESPACE::TypeProto& MutableTypeProto();
-
-  TensorTypeBase();
-  ~TensorTypeBase() override;
-
- private:
-  struct Impl;
-  Impl* impl_;
-};
-
-/**
- * \brief Tensor type. This type does not have a C++ type associated with
- * it at registration time except the element type. One of the types mentioned
- * above at IsTensorContainedType<> list is acceptable.
- *
- * \details
- *        Usage:
- *        ORT_REGISTER_TENSOR(ELEMENT_TYPE)
- *        Currently all of the Tensors irrespective of the dimensions are mapped to Tensor<type>
- *        type. IsCompatible() currently ignores shape.
- */
-
-template <typename elemT>
-class TensorType : public TensorTypeBase {
- public:
-  static_assert(data_types_internal::IsTensorContainedType<elemT>::value,
-                "Requires one of the tensor fundamental types");
-
-  static MLDataType Type();
-
-  /// Tensors only can contain basic data types
-  /// that have been previously registered with ONNXRuntime
-  MLDataType GetElementType() const override {
-    return DataTypeImpl::GetType<elemT>();
-  }
-
- private:
-  TensorType() {
-    using namespace data_types_internal;
-    TensorTypeHelper::Set(utils::ToTensorProtoElementType<elemT>(), MutableTypeProto());
-  }
-};
-
-#if defined(DISABLE_OPTIONAL_TYPE)
-
-// TODO is this still needed after removing kernel def hashes?
-/// Common base-class for all disabled types. We need DataTypeImpl::ToString to work in a minimal build
-/// with disabled types to keep the ORT format model kernel hashes stable.
-class DisabledTypeBase : public DataTypeImpl {
- public:
-  static MLDataType Type();
-
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto&) const override {
-    // We always want to return false for the IsCompatible() for a disabled type
-    // because this will ensure that no kernel supporting the disabled type will
-    // be matched to a model node requiring that type and the model load will
-    // result in failure.
-    return false;
-  }
-
-  DeleteFunc GetDeleteFunc() const override {
-    ORT_THROW("Type is disabled in this build.");
-  }
-
-  // This must work
-  const ONNX_NAMESPACE::TypeProto* GetTypeProto() const override;
-
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(DisabledTypeBase);
-
- protected:
-  // This must work
-  ONNX_NAMESPACE::TypeProto& MutableTypeProto();
-
-  DisabledTypeBase(DataTypeImpl::GeneralType type, size_t size);
-  ~DisabledTypeBase() override;
-
- private:
-  struct Impl;
-  Impl* impl_;
-};
-
-#endif
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-/// Common base-class for all sparse-tensors (with different element types).
-class SparseTensorTypeBase : public DataTypeImpl {
- public:
-  static MLDataType Type();
-
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const override;
-
-  DeleteFunc GetDeleteFunc() const override;
-
-  const ONNX_NAMESPACE::TypeProto* GetTypeProto() const override;
-
-  virtual MLDataType GetElementType() const {
-    // should never reach here.
-    ORT_NOT_IMPLEMENTED(__FUNCTION__, " is not implemented");
-  }
-
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(SparseTensorTypeBase);
-
- protected:
-  ONNX_NAMESPACE::TypeProto& MutableTypeProto();
-
-  SparseTensorTypeBase();
-  ~SparseTensorTypeBase() override;
-
- private:
-  struct Impl;
-  Impl* impl_;
-};
-
-template <typename elemT>
-class SparseTensorType : public SparseTensorTypeBase {
- public:
-  static_assert(data_types_internal::IsSparseTensorContainedType<elemT>::value,
-                "Requires one of the sparse-tensor fundamental types");
-
-  static MLDataType Type();
-
-  /// Return a MLDataType representing the element-type
-  MLDataType GetElementType() const override {
-    return DataTypeImpl::GetType<elemT>();
-  }
-
- private:
-  SparseTensorType() {
-    using namespace data_types_internal;
-    SparseTensorTypeHelper::Set(utils::ToTensorProtoElementType<elemT>(), MutableTypeProto());
-  }
-};
-
-#endif  // !defined(DISABLE_SPARSE_TENSORS)
-
-/// Common base-class for all optional types.
-
-#if !defined(DISABLE_OPTIONAL_TYPE)
-class OptionalTypeBase : public DataTypeImpl {
- public:
-  static MLDataType Type();
-
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const override;
-
-  DeleteFunc GetDeleteFunc() const override {
-    // should never reach here.
-    ORT_NOT_IMPLEMENTED(__FUNCTION__, " is not implemented");
-  }
-
-  const ONNX_NAMESPACE::TypeProto* GetTypeProto() const override;
-
-  virtual MLDataType GetElementType() const {
-    // should never reach here.
-    ORT_NOT_IMPLEMENTED(__FUNCTION__, " is not implemented");
-  }
-
-  OptionalTypeBase(const OptionalTypeBase&) = delete;
-  OptionalTypeBase& operator=(const OptionalTypeBase&) = delete;
-
- protected:
-  ONNX_NAMESPACE::TypeProto& MutableTypeProto();
-
-  OptionalTypeBase();
-  ~OptionalTypeBase() override;
-
- private:
-  struct Impl;
-  Impl* impl_;
-};
-#endif
-
-// Derive from OptionalTypeBase if the Optional type support is enabled,
-// else derive from DisabledTypeBase
-template <typename T, typename elemT>
-class OptionalType :
-#if !defined(DISABLE_OPTIONAL_TYPE)
-    public OptionalTypeBase
-#else
-    public DisabledTypeBase
-#endif
-{
- public:
-  static MLDataType Type();
-
-#if !defined(DISABLE_OPTIONAL_TYPE)
-  static_assert(data_types_internal::IsOptionalOrtType<T>::value,
-                "Requires one of the supported types: Tensor or TensorSeq");
-
-  static_assert(data_types_internal::IsTensorContainedType<elemT>::value,
-                "Requires one of the tensor fundamental types");
-
-  MLDataType GetElementType() const override {
-    return data_types_internal::OptionalTypeHelper::GetElemType<T, elemT>();
-  }
-#endif
-
- private:
-#if !defined(DISABLE_OPTIONAL_TYPE)
-  OptionalType()
-#else
-  OptionalType() : DisabledTypeBase { DataTypeImpl::GeneralType::kOptional, 0 }
-#endif
-  {
-    using namespace data_types_internal;
-    OptionalTypeHelper::Set(OptionalTypeHelper::GetElemType<T, elemT>()->GetTypeProto(), MutableTypeProto());
-  }
-};  // namespace onnxruntime
-
-/**
- * \brief Provide a specialization for your C++ Non-tensor type
- *        so your implementation FromDataTypeContainer/ToDataTypeContainer
- *        functions correctly. Otherwise you get a default implementation
- *        which may not be what you need/want.
- *
- * This class is used to create OrtValue, fetch data from OrtValue via
- * C/C++ APIs
- */
-template <class T>
-struct NonTensorTypeConverter {
-  static void FromContainer(MLDataType /*dtype*/, const void* /*data*/, size_t /*data_size*/, OrtValue& /*output*/) {
-    ORT_THROW("Not implemented");
-  }
-  static void ToContainer(const OrtValue& /*input*/, size_t /*data_size*/, void* /*data*/) {
-    ORT_THROW("Not implemented");
-  }
-};
-
-/**
- * \brief Base type for all non-tensors, maps, sequences and opaques
- */
-class NonTensorTypeBase : public DataTypeImpl {
- public:
-  DeleteFunc GetDeleteFunc() const override = 0;
-
-  virtual CreateFunc GetCreateFunc() const = 0;
-
-  const ONNX_NAMESPACE::TypeProto* GetTypeProto() const override;
-
-  // \brief Override for Non-tensor types to initialize non-tensor CPP
-  // data representation from data. The caller of the interface
-  // should have a shared definition of the data which is used to initialize
-  // CPP data representation. This is used from C API.
-  //
-  // \param data - pointer to a data container structure non_tensor type specific
-  // \param data_size - size of the data container structure, used for rudimentary checks
-  // \param output - reference to a default constructed non-tensor type
-  // \returns OrtValue
-  // \throw if there is an error
-  virtual void FromDataContainer(const void* data, size_t data_size, OrtValue& output) const;
-
-  // \brief Override for Non-tensor types to fetch data from the internal CPP data representation
-  // The caller of the interface should have a shared definition of the data which is used to initialize
-  // CPP data representation. This is used from C API.
-  //
-  // \param input - OrtValue containing data
-  // \param data_size - size of the structure that is being passed for receiving data, used for
-  //                    validation
-  // \param data - pointer to receiving data structure
-  virtual void ToDataContainer(const OrtValue& input, size_t data_size, void* data) const;
-
-  NonTensorTypeBase(const NonTensorTypeBase&) = delete;
-  NonTensorTypeBase& operator=(const NonTensorTypeBase&) = delete;
-
- protected:
-  NonTensorTypeBase(size_t size);
-  ~NonTensorTypeBase() override;
-
-  ONNX_NAMESPACE::TypeProto& MutableTypeProto();
-
-  bool IsMapCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const;
-
-  bool IsSequenceCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const;
-
-  bool IsOpaqueCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const;
-
- private:
-  struct Impl;
-  Impl* impl_;
-};
-
-// This is where T is the actual CPPRuntimeType
-template <typename T>
-class NonTensorType : public NonTensorTypeBase {
- private:
-  static void Delete(void* p) {
-    delete static_cast<T*>(p);
-  }
-
- public:
-  DeleteFunc GetDeleteFunc() const override {
-    return &Delete;
-  }
-
-  CreateFunc GetCreateFunc() const override {
-    return []() -> void* { return new T(); };
-  }
-
- protected:
-  NonTensorType() : NonTensorTypeBase(sizeof(T)) {}
-};
-
-#if !defined(DISABLE_ML_OPS)
-/**
- * \brief MapType. Use this type to register
- * mapping types.
- *
- * \param T - cpp type that you wish to register as runtime MapType
- *
- * \details Usage: ORT_REGISTER_MAP(C++Type)
- *          The type is required to have mapped_type and
- *          key_type defined
- */
-template <typename CPPType>
-class MapType : public NonTensorType<CPPType> {
- public:
-  static_assert(data_types_internal::IsTensorContainedType<typename CPPType::key_type>::value,
-                "Requires one of the tensor fundamental types as key");
-
-  static MLDataType Type();
-
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const override {
-    return this->IsMapCompatible(type_proto);
-  }
-
- private:
-  MapType() {
-    using namespace data_types_internal;
-    MapTypeHelper::Set(utils::ToTensorProtoElementType<typename CPPType::key_type>(),
-                       MapTypeHelper::GetValueType<typename CPPType::mapped_type>()->GetTypeProto(),
-                       this->MutableTypeProto());
-  }
-};
-#endif
-
-/**
- * \brief SequenceType. Use to register sequence for non-tensor types.
- *
- *  \param T - CPP type that you wish to register as Sequence
- *             runtime type.
- *
- * \details Usage: ORT_REGISTER_SEQ(C++Type)
- *          The type is required to have value_type defined
- */
-template <typename CPPType>
-class SequenceType : public NonTensorType<CPPType> {
- public:
-  static MLDataType Type();
-
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const override {
-    return this->IsSequenceCompatible(type_proto);
-  }
-
- private:
-  SequenceType() {
-    using namespace data_types_internal;
-    SequenceTypeHelper::Set(SequenceTypeHelper::GetElemType<typename CPPType::value_type>()->GetTypeProto(),
-                            this->MutableTypeProto());
-  }
-};
-
-/**
- * \brief SequenceTensorTypeBase serves as a base type class for
- *        Tensor sequences. Akin to TensorTypeBase.
- *        Runtime representation is always TensorSeq.
- */
-class SequenceTensorTypeBase : public DataTypeImpl {
- public:
-  static MLDataType Type();
-
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const override;
-
-  virtual MLDataType GetElementType() const {
-    // should never reach here.
-    ORT_NOT_IMPLEMENTED(__FUNCTION__, " is not implemented");
-  }
-
-  DeleteFunc GetDeleteFunc() const override;
-
-  const ONNX_NAMESPACE::TypeProto* GetTypeProto() const override;
-
-  SequenceTensorTypeBase(const SequenceTensorTypeBase&) = delete;
-  SequenceTensorTypeBase& operator=(const SequenceTensorTypeBase&) = delete;
-
- protected:
-  SequenceTensorTypeBase();
-  ~SequenceTensorTypeBase();
-
-  ONNX_NAMESPACE::TypeProto& MutableTypeProto();
-
- private:
-  struct Impl;
-  Impl* impl_;
-};
-#if defined(_MSC_VER) && !defined(__clang__)
-#pragma warning(pop)
-#endif
-/**
- * \brief SequenceTensorType. Use to register sequence for non-tensor types.
- *
- *  \param CPPRuntime - We always use TensorSeq
- *
- *  \param TensorElemType - one of the primitive types
- *
- * \details Usage: ORT_REGISTER_SEQ_TENSOR_TYPE()
- *          The type is required to have value_type defined
- */
-template <typename TensorElemType>
-class SequenceTensorType : public SequenceTensorTypeBase {
- public:
-  static_assert(data_types_internal::IsTensorContainedType<TensorElemType>::value,
-                "Requires one of the tensor fundamental types");
-
-  static MLDataType Type();
-
-  /// Return a MLDataType representing the element-type
-  MLDataType GetElementType() const override {
-    return DataTypeImpl::GetType<TensorElemType>();
-  }
-
- private:
-  SequenceTensorType() {
-    using namespace data_types_internal;
-    SequenceTypeHelper::Set(SequenceTypeHelper::GetElemType<TensorElemType>()->GetTypeProto(),
-                            MutableTypeProto());
-  }
-};
-
-/**
- * \brief OpaqueType
- *
- * \tparam T - cpp runtume that implements the Opaque type
- *
- * \tparam const char D[] - domain must be extern to be unique
- *
- * \tparam const char N[] - name must be extern to be unique
- *
- * \details Only one CPP type can be associated with a particular
- *          OpaqueType registration
- *
- */
-template <typename T, const char D[], const char N[]>
-class OpaqueType : public NonTensorType<T> {
- public:
-  static MLDataType Type();
-
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto& type_proto) const override {
-    return this->IsOpaqueCompatible(type_proto);
-  }
-
-  void FromDataContainer(const void* data, size_t data_size, OrtValue& output) const override {
-    NonTensorTypeConverter<T>::FromContainer(this, data, data_size, output);
-  }
-
-  void ToDataContainer(const OrtValue& input, size_t data_size, void* data) const override {
-    NonTensorTypeConverter<T>::ToContainer(input, data_size, data);
-  }
-
- private:
-  OpaqueType() {
-    data_types_internal::AssignOpaqueDomainName(D, N, this->MutableTypeProto());
-  }
-};
-
-/**
- * \brief PrimitiveDataTypeBase
- *        Base class for primitive Tensor contained types
- *
- * \details This class contains an integer constant that can be
- *          used for input data type dispatching
- *
- */
-class PrimitiveDataTypeBase : public DataTypeImpl {
- public:
-  bool IsCompatible(const ONNX_NAMESPACE::TypeProto&) const override {
-    return false;
-  }
-
-  const ONNX_NAMESPACE::TypeProto* GetTypeProto() const final {
-    return nullptr;
-  }
-
-  int32_t GetDataType() const {
-    return data_type_;
-  }
-
- protected:
-  PrimitiveDataTypeBase(size_t size, int32_t data_type)
-      : DataTypeImpl{GeneralType::kPrimitive, size}, data_type_{data_type} {}
-
- private:
-  const int32_t data_type_;
-};
-
-/**
- * \brief PrimitiveDataType
- *        Typed specialization for primitive types.
- *        Concrete instances of this class are used by Tensor.
- *
- * \param T - primitive data type
- *
- */
-template <typename T>
-class PrimitiveDataType : public PrimitiveDataTypeBase {
- private:
-  static void Delete(void* p) {
-    delete static_cast<T*>(p);
-  }
-
- public:
-  static MLDataType Type();
-
-  DeleteFunc GetDeleteFunc() const override {
-    return &Delete;
-  }
-
- private:
-  PrimitiveDataType()
-      : PrimitiveDataTypeBase{sizeof(T),
-                              utils::ToTensorProtoElementType<T>()} {
-  }
-};
-
-inline const TensorTypeBase* DataTypeImpl::AsTensorType() const {
-  return IsTensorType() ? static_cast<const TensorTypeBase*>(this) : nullptr;
-}
-
-inline const SequenceTensorTypeBase* DataTypeImpl::AsSequenceTensorType() const {
-  return IsTensorSequenceType() ? static_cast<const SequenceTensorTypeBase*>(this) : nullptr;
-}
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-inline const SparseTensorTypeBase* DataTypeImpl::AsSparseTensorType() const {
-  return IsSparseTensorType() ? static_cast<const SparseTensorTypeBase*>(this) : nullptr;
-}
-#endif
-
-#if !defined(DISABLE_OPTIONAL_TYPE)
-inline const OptionalTypeBase* DataTypeImpl::AsOptionalType() const {
-  return IsOptionalType() ? static_cast<const OptionalTypeBase*>(this) : nullptr;
-}
-#endif
-
-inline const NonTensorTypeBase* DataTypeImpl::AsNonTensorType() const {
-  return IsNonTensorType() ? static_cast<const NonTensorTypeBase*>(this) : nullptr;
-}
-
-inline const PrimitiveDataTypeBase* DataTypeImpl::AsPrimitiveDataType() const {
-  return IsPrimitiveDataType() ? static_cast<const PrimitiveDataTypeBase*>(this) : nullptr;
-}
-
-// Explicit specialization of base class template function
-// is only possible within the enclosing namespace scope,
-// thus a simple way to pre-instantiate a given template
-// at a registration time does not currently work and the macro
-// is needed.
-#define ORT_REGISTER_TENSOR_TYPE(ELEM_TYPE)             \
-  template <>                                           \
-  MLDataType TensorType<ELEM_TYPE>::Type() {            \
-    static TensorType<ELEM_TYPE> tensor_type;           \
-    return &tensor_type;                                \
-  }                                                     \
-  template <>                                           \
-  MLDataType DataTypeImpl::GetTensorType<ELEM_TYPE>() { \
-    return TensorType<ELEM_TYPE>::Type();               \
-  }
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-#define ORT_REGISTER_SPARSE_TENSOR_TYPE(ELEM_TYPE)            \
-  template <>                                                 \
-  MLDataType SparseTensorType<ELEM_TYPE>::Type() {            \
-    static SparseTensorType<ELEM_TYPE> tensor_type;           \
-    return &tensor_type;                                      \
-  }                                                           \
-  template <>                                                 \
-  MLDataType DataTypeImpl::GetSparseTensorType<ELEM_TYPE>() { \
-    return SparseTensorType<ELEM_TYPE>::Type();               \
-  }
-#endif
-
-#define ORT_REGISTER_OPTIONAL_TYPE(ORT_TYPE, TYPE)             \
-  template <>                                                  \
-  MLDataType OptionalType<ORT_TYPE, TYPE>::Type() {            \
-    static OptionalType<ORT_TYPE, TYPE> optional_type;         \
-    return &optional_type;                                     \
-  }                                                            \
-  template <>                                                  \
-  MLDataType DataTypeImpl::GetOptionalType<ORT_TYPE, TYPE>() { \
-    return OptionalType<ORT_TYPE, TYPE>::Type();               \
-  }
-
-#if !defined(DISABLE_ML_OPS)
-#define ORT_REGISTER_MAP(TYPE)               \
-  template <>                                \
-  MLDataType MapType<TYPE>::Type() {         \
-    static MapType<TYPE> map_type;           \
-    return &map_type;                        \
-  }                                          \
-  template <>                                \
-  MLDataType DataTypeImpl::GetType<TYPE>() { \
-    return MapType<TYPE>::Type();            \
-  }
-#endif
-
-#define ORT_REGISTER_SEQ(TYPE)               \
-  template <>                                \
-  MLDataType SequenceType<TYPE>::Type() {    \
-    static SequenceType<TYPE> sequence_type; \
-    return &sequence_type;                   \
-  }                                          \
-  template <>                                \
-  MLDataType DataTypeImpl::GetType<TYPE>() { \
-    return SequenceType<TYPE>::Type();       \
-  }
-
-#define ORT_REGISTER_SEQ_TENSOR_TYPE(ELEM_TYPE)                 \
-  template <>                                                   \
-  MLDataType SequenceTensorType<ELEM_TYPE>::Type() {            \
-    static SequenceTensorType<ELEM_TYPE> sequence_tensor_type;  \
-    return &sequence_tensor_type;                               \
-  }                                                             \
-  template <>                                                   \
-  MLDataType DataTypeImpl::GetSequenceTensorType<ELEM_TYPE>() { \
-    return SequenceTensorType<ELEM_TYPE>::Type();               \
-  }
-
-#define ORT_REGISTER_PRIM_TYPE(TYPE)               \
-  template <>                                      \
-  MLDataType PrimitiveDataType<TYPE>::Type() {     \
-    static PrimitiveDataType<TYPE> prim_data_type; \
-    return &prim_data_type;                        \
-  }                                                \
-  template <>                                      \
-  MLDataType DataTypeImpl::GetType<TYPE>() {       \
-    return PrimitiveDataType<TYPE>::Type();        \
-  }
-
-#define ORT_REGISTER_OPAQUE_TYPE(CPPType, Domain, Name)   \
-  template <>                                             \
-  MLDataType OpaqueType<CPPType, Domain, Name>::Type() {  \
-    static OpaqueType<CPPType, Domain, Name> opaque_type; \
-    return &opaque_type;                                  \
-  }                                                       \
-  template <>                                             \
-  MLDataType DataTypeImpl::GetType<CPPType>() {           \
-    return OpaqueType<CPPType, Domain, Name>::Type();     \
-  }
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/data_types_internal.h

@@ -1,569 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <array>
-#include <cassert>
-#include <cstdint>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "boost/mp11.hpp"
-
-#include "core/common/common.h"
-#include "core/framework/to_tensor_proto_element_type.h"
-#ifndef SHARED_PROVIDER
-#include "core/common/type_list.h"
-#include "core/framework/data_types.h"
-#if !defined(ORT_MINIMAL_BUILD)
-#include "onnx/defs/schema.h"
-#else
-#include "onnx/defs/data_type_utils.h"
-#endif
-#include "onnx/onnx_pb.h"
-#include "onnx/onnx-operators_pb.h"
-#endif
-
-namespace onnxruntime {
-namespace utils {
-
-  // The following primitives are strongly recommended for switching on tensor input datatypes for
-  // kernel implementations.
-  //
-  //  1) If you need to handle all of the primitive tensor contained datatypes, the best choice would be macros
-  //     DispatchOnTensorType or DispatchOnTensorTypeWithReturn. Use inline wrappers so your function can be invoked as function<T>().
-  //  2) if you have a few types, use Tensor.IsDataType<T>()/IsDataTypeString() or use utils::IsPrimitiveDataType<T>()
-  //     if you have a standalone MLDatatType with a sequence of if/else statements.
-  //  3) For something in between, we suggest to use CallDispatcher pattern.
-  //
-  // Invoking DataTypeImpl::GetType<T>() for switching on input types is discouraged and should be avoided.
-  // Every primitive type carries with it an integer constant that can be used for quick switching on types.
-
-#define DispatchOnTensorType(tensor_type, function, ...)          \
-  switch (tensor_type->AsPrimitiveDataType()->GetDataType()) {    \
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT:              \
-      function<float>(__VA_ARGS__);                               \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_BOOL:               \
-      function<bool>(__VA_ARGS__);                                \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_DOUBLE:             \
-      function<double>(__VA_ARGS__);                              \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_STRING:             \
-      function<std::string>(__VA_ARGS__);                         \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT8:               \
-      function<int8_t>(__VA_ARGS__);                              \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT8:              \
-      function<uint8_t>(__VA_ARGS__);                             \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT16:              \
-      function<int16_t>(__VA_ARGS__);                             \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT16:             \
-      function<uint16_t>(__VA_ARGS__);                            \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT32:              \
-      function<int32_t>(__VA_ARGS__);                             \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT32:             \
-      function<uint32_t>(__VA_ARGS__);                            \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT64:              \
-      function<int64_t>(__VA_ARGS__);                             \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT64:             \
-      function<uint64_t>(__VA_ARGS__);                            \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:            \
-      function<MLFloat16>(__VA_ARGS__);                           \
-      break;                                                      \
-    case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:           \
-      function<BFloat16>(__VA_ARGS__);                            \
-      break;                                                      \
-    default:                                                      \
-      ORT_ENFORCE(false, "Unknown tensor type of ", tensor_type); \
-  }
-
-#define DispatchOnTensorTypeWithReturn(tensor_type, retval, function, ...) \
-  switch (tensor_type->AsPrimitiveDataType()->GetDataType()) {             \
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT:                       \
-      retval = function<float>(__VA_ARGS__);                               \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_BOOL:                        \
-      retval = function<bool>(__VA_ARGS__);                                \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_DOUBLE:                      \
-      retval = function<double>(__VA_ARGS__);                              \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_STRING:                      \
-      retval = function<std::string>(__VA_ARGS__);                         \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT8:                        \
-      retval = function<int8_t>(__VA_ARGS__);                              \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT8:                       \
-      retval = function<uint8_t>(__VA_ARGS__);                             \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT16:                      \
-      retval = function<uint16_t>(__VA_ARGS__);                            \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT16:                       \
-      retval = function<int16_t>(__VA_ARGS__);                             \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT32:                       \
-      retval = function<int32_t>(__VA_ARGS__);                             \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT32:                      \
-      retval = function<uint32_t>(__VA_ARGS__);                            \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_INT64:                       \
-      retval = function<int64_t>(__VA_ARGS__);                             \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT64:                      \
-      retval = function<uint64_t>(__VA_ARGS__);                            \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:                     \
-      retval = function<MLFloat16>(__VA_ARGS__);                           \
-      break;                                                               \
-    case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:                    \
-      retval = function<BFloat16>(__VA_ARGS__);                            \
-      break;                                                               \
-    default:                                                               \
-      ORT_ENFORCE(false, "Unknown tensor type of ", tensor_type);          \
-  }
-
-////////////////////////////////////////////////////////////////////////////////
-/// Use the following primitives if you have a few types to switch on so you
-//  can write a short sequence of if/else statements.
-
-// This is a frequently used check so we make a separate utility function.
-inline bool IsDataTypeString(MLDataType dt_type) {
-  auto prim_type = dt_type->AsPrimitiveDataType();
-  return (prim_type != nullptr && prim_type->GetDataType() == ONNX_NAMESPACE::TensorProto_DataType_STRING);
-}
-
-// Test if MLDataType is a concrete type of PrimitiveDataTypeBase
-// and it is T
-template <class T>
-inline bool IsPrimitiveDataType(MLDataType dt_type) {
-  auto prim_type = dt_type->AsPrimitiveDataType();
-  return (prim_type != nullptr && prim_type->GetDataType() == ToTensorProtoElementType<T>());
-}
-
-// Use after AsPrimitiveDataType() is successful
-// Check if PrimitiveDataTypeBase is of type T
-template <class T>
-inline bool IsPrimitiveDataType(const PrimitiveDataTypeBase* prim_type) {
-  assert(prim_type != nullptr);
-  return prim_type->GetDataType() == ToTensorProtoElementType<T>();
-}
-
-// This implementation contains a workaround for GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47226
-// GCC until very recently does not support template parameter pack expansion within lambda context.
-namespace mltype_dispatcher_internal {
-
-// T - type handled by this helper
-class CallableDispatchableHelper {
-  int32_t dt_type_;  // Type currently dispatched
-  size_t called_;
-
- public:
-  explicit CallableDispatchableHelper(int32_t dt_type) noexcept : dt_type_(dt_type), called_(0) {}
-
-  // Must return integer to be in a expandable context
-  template <class T, class Fn, class... Args>
-  int Invoke(Fn&& fn, Args&&... args) {
-    if (utils::ToTensorProtoElementType<T>() == dt_type_) {
-      std::forward<Fn>(fn)(std::forward<Args>(args)...);
-      ++called_;
-    }
-    return 0;
-  }
-
-  void CheckCalledOnce() {
-    ORT_ENFORCE(called_ == 1, "Unsupported data type: ", dt_type_);
-  }
-};
-
-// Default policy is to throw an exception.
-// Other policies may set the second result argument accordingly.
-template <class Ret>
-struct UnsupportedTypeDefaultPolicy {
-  void operator()(int32_t dt_type, Ret& /*result*/) const {
-    ORT_THROW("Unsupported data type: ", dt_type);
-  }
-};
-
-// Helper with the result type
-template <class Ret, class UnsupportedPolicy>
-class CallableDispatchableRetHelper {
-  int32_t dt_type_;  // Type currently dispatched
-  size_t called_;
-  Ret result_;
-
- public:
-  explicit CallableDispatchableRetHelper(int32_t dt_type) noexcept : dt_type_(dt_type), called_(0), result_() {}
-
-  Ret Get() {
-    // No type was invoked
-    if (called_ == 0) {
-      UnsupportedPolicy()(dt_type_, result_);
-    }
-    return result_;
-  }
-
-  // Must return integer to be in a expandable context
-  template <class T, class Fn, class... Args>
-  int Invoke(Fn&& fn, Args&&... args) {
-    if (utils::ToTensorProtoElementType<T>() == dt_type_) {
-      result_ = std::forward<Fn>(fn)(std::forward<Args>(args)...);
-      ++called_;
-    }
-    return 0;
-  }
-};
-
-template <typename T>
-using TensorProtoElementTypeConstant =
-    std::integral_constant<ONNX_NAMESPACE::TensorProto_DataType, ToTensorProtoElementType<T>()>;
-
-using UndefinedTensorProtoElementTypeConstant =
-    std::integral_constant<ONNX_NAMESPACE::TensorProto_DataType, ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED>;
-
-}  // namespace mltype_dispatcher_internal
-
-/**
- * This class helps to efficiently dispatch calls to implementation function
- * objects with a tensor element type template argument.
- *
- * The constructor accepts a value corresponding to a tensor element type.
- * For example, it can be obtained from:
- *   input_tensor->GetElementType()
- *
- * The Invoke member functions will instantiate and invoke the provided
- * function object template, Fn. Fn must be default constructible. Fn must also
- * have a tensor element type template argument. This type template argument
- * will be the type that corresponds to the value given in the constructor.
- * These functions accept and forward arbitrary function arguments. They ensure
- * that Fn is called once with the type specified in the constructor.
- *
- * @tparam Types The types supported by the implementation. This should be a
- *         set of ONNX tensor element types that are supported by ORT.
- */
-template <typename... Types>
-class MLTypeCallDispatcher {
-  using SupportedTypeList = TypeList<Types...>;
-  using SupportedTensorProtoElementTypeList =
-      boost::mp11::mp_transform<
-          mltype_dispatcher_internal::TensorProtoElementTypeConstant, SupportedTypeList>;
-
-  static_assert(
-      boost::mp11::mp_and<
-          boost::mp11::mp_is_set<SupportedTensorProtoElementTypeList>,
-          boost::mp11::mp_not<
-              boost::mp11::mp_set_contains<
-                  SupportedTensorProtoElementTypeList,
-                  mltype_dispatcher_internal::UndefinedTensorProtoElementTypeConstant>>>::value,
-      "Types must map to a unique set of ONNX tensor element data types supported by ORT.");
-
-  int32_t dt_type_;
-
- public:
-  /**
-   * Constructor.
-   * @param dt_type The value corresponding to the tensor element type to be
-   *        dispatched to. This can be obtained from
-   *        input_tensor->GetElementType() or
-   *        utils::ToTensorProtoElementType<T>().
-   */
-  explicit MLTypeCallDispatcher(int32_t dt_type) noexcept : dt_type_(dt_type) {}
-
-  /**
-   * Invokes Fn<T> with the specified arguments.
-   *
-   * @tparam Fn The function object template.
-   * @tparam Args The argument types.
-   */
-  template <template <typename...> class Fn, typename... Args>
-  void Invoke(Args&&... args) const {
-    InvokeWithLeadingTemplateArgs<Fn, TypeList<>>(std::forward<Args>(args)...);
-  }
-
-  /**
-   * Invokes Fn<..., T> with leading template arguments and the specified
-   * arguments.
-   *
-   * @tparam Fn The function object template.
-   * @tparam LeadingTemplateArgTypeList A type list of the leading template
-   *         arguments.
-   * @tparam Args The argument types.
-   */
-  template <template <typename...> class Fn, typename LeadingTemplateArgTypeList, typename... Args>
-  void InvokeWithLeadingTemplateArgs(Args&&... args) const {
-    static_assert(
-        boost::mp11::mp_is_list<LeadingTemplateArgTypeList>::value,
-        "LeadingTemplateArgTypeList must be a type list (e.g., onnxruntime::TypeList<T1, T2, ...>).");
-
-    mltype_dispatcher_internal::CallableDispatchableHelper helper(dt_type_);
-
-    // given LeadingTemplateArgTypeList is a type list L<U1, U2, ...>,
-    //   call helper.Invoke() with Fn<U1, U2, ..., T> for each T in Types
-    static_cast<void>(std::array<int, sizeof...(Types)>{
-        helper.template Invoke<Types>(
-            boost::mp11::mp_apply<Fn, boost::mp11::mp_push_back<LeadingTemplateArgTypeList, Types>>(),
-            std::forward<Args>(args)...)...});
-
-    // avoid "unused parameter" warning for the case where Types is empty
-    static_cast<void>(std::array<int, sizeof...(Args)>{(ORT_UNUSED_PARAMETER(args), 0)...});
-
-    helper.CheckCalledOnce();
-  }
-
-  /**
-   * Invokes Fn<T> with the specified arguments and returns the result.
-   *
-   * @tparam Ret The return type. Fn should return a type convertible to Ret.
-   * @tparam Fn The function object template.
-   * @tparam Args The argument types.
-   */
-  template <class Ret, template <typename...> class Fn, typename... Args>
-  Ret InvokeRet(Args&&... args) const {
-    return InvokeRetWithUnsupportedPolicy<
-        Ret, Fn, mltype_dispatcher_internal::UnsupportedTypeDefaultPolicy<Ret>>(
-        std::forward<Args>(args)...);
-  }
-
-  /**
-   * Invokes Fn<T> with the specified arguments and returns the result.
-   *
-   * @tparam Ret The return type. Fn should return a type convertible to Ret.
-   * @tparam Fn The function object template.
-   * @tparam UnsupportedPolicy The policy used to handle unsupported types.
-   *         See mltype_dispatcher_internal::UnsupportedTypeDefaultPolicy
-   *         for an example.
-   * @tparam Args The argument types.
-   */
-  template <class Ret, template <typename...> class Fn, class UnsupportedPolicy, typename... Args>
-  Ret InvokeRetWithUnsupportedPolicy(Args&&... args) const {
-    return InvokeRetWithUnsupportedPolicyAndLeadingTemplateArgs<
-        Ret, Fn, UnsupportedPolicy, TypeList<>>(
-        std::forward<Args>(args)...);
-  }
-
-  /**
-   * Invokes Fn<..., T> with leading template arguments and the specified
-   * arguments and returns the result.
-   *
-   * @tparam Ret The return type. Fn should return a type convertible to Ret.
-   * @tparam Fn The function object template.
-   * @tparam LeadingTemplateArgTypeList A type list of the leading template
-   *         arguments.
-   * @tparam Args The argument types.
-   */
-  template <class Ret, template <typename...> class Fn, typename LeadingTemplateArgTypeList, typename... Args>
-  Ret InvokeRetWithLeadingTemplateArgs(Args&&... args) const {
-    return InvokeRetWithUnsupportedPolicyAndLeadingTemplateArgs<
-        Ret, Fn, mltype_dispatcher_internal::UnsupportedTypeDefaultPolicy<Ret>, LeadingTemplateArgTypeList>(
-        std::forward<Args>(args)...);
-  }
-
-  /**
-   * Invokes Fn<..., T> with leading template arguments and the specified
-   * arguments and returns the result.
-   *
-   * @tparam Ret The return type. Fn should return a type convertible to Ret.
-   * @tparam Fn The function object template.
-   * @tparam UnsupportedPolicy The policy used to handle unsupported types.
-   *         See mltype_dispatcher_internal::UnsupportedTypeDefaultPolicy
-   *         for an example.
-   * @tparam LeadingTemplateArgTypeList A type list of the leading template
-   *         arguments.
-   * @tparam Args The argument types.
-   */
-  template <class Ret,
-            template <typename...> class Fn,
-            class UnsupportedPolicy,
-            typename LeadingTemplateArgTypeList,
-            typename... Args>
-  Ret InvokeRetWithUnsupportedPolicyAndLeadingTemplateArgs(Args&&... args) const {
-    mltype_dispatcher_internal::CallableDispatchableRetHelper<Ret, UnsupportedPolicy> helper(dt_type_);
-
-    // given LeadingTemplateArgTypeList is a type list L<U1, U2, ...>,
-    //   call helper.Invoke() with Fn<U1, U2, ..., T> for each T in Types
-    static_cast<void>(std::array<int, sizeof...(Types)>{
-        helper.template Invoke<Types>(
-            boost::mp11::mp_apply<Fn, boost::mp11::mp_push_back<LeadingTemplateArgTypeList, Types>>(),
-            std::forward<Args>(args)...)...});
-
-    // avoid "unused parameter" warning for the case where Types is empty
-    static_cast<void>(std::array<int, sizeof...(Args)>{(ORT_UNUSED_PARAMETER(args), 0)...});
-
-    return helper.Get();
-  }
-};
-
-// the type MLTypeCallDispatcher<T...> given a type list L<T...>
-template <typename L>
-using MLTypeCallDispatcherFromTypeList = boost::mp11::mp_apply<MLTypeCallDispatcher, L>;
-
-namespace data_types_internal {
-
-enum class ContainerType : uint16_t {
-  kUndefined = 0,
-  kTensor = 1,
-  kMap = 2,
-  kSequence = 3,
-  kOpaque = 4,
-  kOptional = 5
-};
-
-class TypeNode {
-  // type_ is a TypeProto value case enum
-  // that may be a kTypeTensor, kTypeMap, kTypeSequence
-  // prim_type_ is a TypeProto_DataType enum that has meaning
-  // - for Tensor then prim_type_ is the contained type
-  // - for Map prim_type is the key type. Next entry describes map value
-  // - For sequence prim_type_ is not used and has no meaning. Next entry
-  //   describes the value for the sequence
-  // Tensor is always the last entry as it describes a contained primitive type.
-  ContainerType type_;
-  uint16_t prim_type_;
-
- public:
-  TypeNode(ContainerType type, int32_t prim_type) noexcept {
-    type_ = type;
-    prim_type_ = static_cast<uint16_t>(prim_type);
-  }
-
-  bool IsType(ContainerType type) const noexcept {
-    return type_ == type;
-  }
-
-  bool IsPrimType(int32_t prim_type) const noexcept {
-    return prim_type_ == static_cast<uint16_t>(prim_type);
-  }
-};
-
-}  // namespace data_types_internal
-
-////////////////////////////////////////////////////////////////////
-/// Provides generic interface to test whether MLDataType is a Sequence,
-/// Map or an Opaque type including arbitrary recursive definitions
-/// without querying DataTypeImpl::GetType<T> for all known complex types
-
-// T is a sequence contained element type
-// If returns true then we know that the runtime
-// representation is std::vector<T>
-// T itself can be a runtime representation of another
-// sequence, map, opaque type or a tensor
-//
-// That is it can be std::vector or a std::map
-// If T is a primitive type sequence is tested whether it contains
-// tensors of that type
-//
-// If T is an opaque type, then it is only tested to be opaque but not exactly
-// a specific opaque type. To Test for a specific Opaque type use IsOpaqueType() below
-//
-// This class examines the supplied MLDataType and records
-// its information in a vector so any subsequent checks for Sequences and Maps
-// are quick.
-class ContainerChecker {
-  using Cont = std::vector<data_types_internal::TypeNode>;
-  Cont types_;
-
-  // Default IsContainerOfType is for Opaque type
-  template <class T>
-  struct IsContainerOfType {
-    static bool check(const Cont& c, size_t index) {
-      if (index >= c.size()) {
-        return false;
-      }
-      return c[index].IsType(data_types_internal::ContainerType::kOpaque);
-    }
-  };
-
-  // Handles the case where sequence element is also a sequence
-  template <class T>
-  struct IsContainerOfType<std::vector<T>> {
-    static bool check(const Cont& c, size_t index) {
-      if (index >= c.size()) {
-        return false;
-      }
-      if (c[index].IsType(data_types_internal::ContainerType::kSequence)) {
-        ORT_ENFORCE(++index < c.size(), "Sequence is missing type entry for its element");
-        constexpr int32_t prim_type = ToTensorProtoElementType<T>();
-        // Check if this is a primitive type and it matches
-        if constexpr(prim_type != ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED) {
-          return c[index].IsType(data_types_internal::ContainerType::kTensor) &&
-                 c[index].IsPrimType(prim_type);
-        }
-        else {
-          // T is not primitive, check next entry for non-primitive proto
-          return IsContainerOfType<T>::check(c, index);
-        }
-      }
-      return false;
-    }
-  };
-
-  template <class K, class V>
-  struct IsContainerOfType<std::map<K, V>> {
-    static bool check(const Cont& c, size_t index) {
-      static_assert(ToTensorProtoElementType<K>() != ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED,
-                    "Map Key can not be a non-primitive type");
-      if (index >= c.size()) {
-        return false;
-      }
-      if (!c[index].IsType(data_types_internal::ContainerType::kMap)) {
-        return false;
-      }
-      constexpr int32_t key_type = ToTensorProtoElementType<K>();
-      if (!c[index].IsPrimType(key_type)) {
-        return false;
-      }
-      ORT_ENFORCE(++index < c.size(), "Map is missing type entry for its value");
-      constexpr int32_t val_type = ToTensorProtoElementType<V>();
-      if constexpr(val_type != ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED) {
-        return c[index].IsType(data_types_internal::ContainerType::kTensor) &&
-               c[index].IsPrimType(val_type);
-      }
-      else return IsContainerOfType<V>::check(c, index);
-    }
-  };
-
- public:
-  explicit ContainerChecker(MLDataType);
-  ~ContainerChecker() = default;
-
-  bool IsMap() const noexcept {
-    assert(!types_.empty());
-    return types_[0].IsType(data_types_internal::ContainerType::kMap);
-  }
-
-  bool IsSequence() const noexcept {
-    assert(!types_.empty());
-    return types_[0].IsType(data_types_internal::ContainerType::kSequence);
-  }
-
-  template <class T>
-  bool IsSequenceOf() const {
-    assert(!types_.empty());
-    return IsContainerOfType<std::vector<T>>::check(types_, 0);
-  }
-
-  template <class K, class V>
-  bool IsMapOf() const {
-    assert(!types_.empty());
-    return IsContainerOfType<std::map<K, V>>::check(types_, 0);
-  }
-};
-
-bool IsOpaqueType(MLDataType ml_type, const char* domain, const char* name);
-
-}  // namespace utils
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/endian.h

@@ -1,27 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-namespace onnxruntime {
-
-// the semantics of this enum should match std::endian from C++20
-enum class endian {
-#if defined(_WIN32)
-  little = 0,
-  big = 1,
-  native = little,
-#elif defined(__GNUC__) || defined(__clang__)
-  little = __ORDER_LITTLE_ENDIAN__,
-  big = __ORDER_BIG_ENDIAN__,
-  native = __BYTE_ORDER__,
-#else
-#error onnxruntime::endian is not implemented in this environment.
-#endif
-};
-
-static_assert(
-    endian::native == endian::little || endian::native == endian::big,
-    "Only little-endian or big-endian native byte orders are supported.");
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/execution_provider.h

@@ -1,340 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#ifndef SHARED_PROVIDER
-#include <memory>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "core/common/logging/logging.h"
-#include "core/common/status.h"
-#include "core/framework/data_transfer.h"
-#include "core/framework/tensor.h"
-
-namespace onnxruntime {
-class GraphViewer;
-struct ComputeCapability;
-class KernelRegistry;
-struct KernelCreateInfo;
-class Node;
-}  // namespace onnxruntime
-#else
-#include <memory>
-#endif
-
-#include "core/common/basic_types.h"
-#include "core/common/profiler_common.h"
-#include "core/framework/allocatormgr.h"
-#include "core/framework/func_api.h"
-#include "core/framework/provider_options.h"
-#include "core/framework/stream_handles.h"
-#include "core/framework/tuning_context.h"
-
-namespace onnxruntime {
-
-/**
-   Logical device representation.
-*/
-
-// if we are export the fused function to dll, the function will still in the same binary as onnxruntime
-// use std function to give execution provider some chance to capture some state.
-using CreateFunctionStateFunc = std::function<int(ComputeContext*, FunctionState*)>;
-using ComputeFunc = std::function<Status(FunctionState, const OrtApi*, OrtKernelContext*)>;
-using DestroyFunctionStateFunc = std::function<void(FunctionState)>;
-
-struct NodeComputeInfo {
-  CreateFunctionStateFunc create_state_func;
-  ComputeFunc compute_func;
-  DestroyFunctionStateFunc release_state_func;
-};
-
-enum class DataLayout {
-  NCHW,
-  NHWC,
-  NCHWC,
-};
-
-class IExecutionProvider {
- protected:
-  IExecutionProvider(const std::string& type, bool use_metadef_id_creator = false)
-      : type_{type} {
-    if (use_metadef_id_creator) {
-      metadef_id_generator_ = std::make_unique<ModelMetadefIdGenerator>();
-    }
-  }
-
- public:
-  virtual ~IExecutionProvider() = default;
-
-  /**
-     Get all IAllocators for <*this> execution provider.
-  */
-  const std::vector<AllocatorPtr>& GetAllocators() const {
-    return allocator_list_;
-  }
-
-  /**
-   * Get an allocator with specified device id and MemType. Return nullptr if it doesn't exist
-   */
-  virtual AllocatorPtr GetAllocator(OrtMemType mem_type) const;
-
-  /**
-   * Returns a data transfer object that implements methods to copy to and
-   * from this device.
-   * If no copy is required for the successful operation of this provider,
-   * return a nullptr.
-   */
-  virtual std::unique_ptr<onnxruntime::IDataTransfer> GetDataTransfer() const {
-    return nullptr;
-  }
-
-  /**
-   * Interface for performing kernel lookup within kernel registries.
-   * Abstracts away lower-level details about kernel registries and kernel matching.
-   */
-  class IKernelLookup {
-   public:
-    /**
-     * Given `node`, try to find a matching kernel for this EP.
-     * The return value is non-null if and only if a matching kernel was found.
-     */
-    virtual const KernelCreateInfo* LookUpKernel(const Node& node) const = 0;
-
-   protected:
-    ~IKernelLookup() = default;
-  };
-
-  /**
-     Get execution provider's capability for the specified <graph>.
-     Return a bunch of IndexedSubGraphs <*this> execution provider can run if
-     the sub-graph contains only one node or can fuse to run if the sub-graph
-     contains more than one node. The node indexes contained in sub-graphs may
-     have overlap, and it's ONNXRuntime's responsibility to do the partition
-     and decide whether a node will be assigned to <*this> execution provider.
-     For kernels registered in a kernel registry, `kernel_lookup` must be used
-     to find a matching kernel for this EP.
-  */
-  virtual std::vector<std::unique_ptr<ComputeCapability>>
-  GetCapability(const onnxruntime::GraphViewer& graph_viewer,
-                const IKernelLookup& kernel_lookup) const;
-
-  /**
-     Get kernel registry per execution provider type.
-     The KernelRegistry share pointer returned is shared across sessions.
-
-     NOTE: this approach was taken to achieve the following goals,
-     1. The execution provider type based kernel registry should be shared
-     across sessions.
-     Only one copy of this kind of kernel registry exists in ONNXRuntime
-     with multiple sessions/models.
-     2. Adding an execution provider into ONNXRuntime does not need to touch ONNXRuntime
-     framework/session code.
-     3. onnxruntime (framework/session) does not depend on any specific
-     execution provider lib.
-  */
-  virtual std::shared_ptr<KernelRegistry> GetKernelRegistry() const { return nullptr; }
-
-  /**
-     Get the device id of current execution provider
-  */
-  virtual int GetDeviceId() const { return 0; };
-
-  /**
-     Get execution provider's configuration options.
-   */
-  virtual ProviderOptions GetProviderOptions() const { return {}; }
-
-  /**
-     Returns an opaque handle whose exact type varies based on the provider
-     and is interpreted accordingly by the corresponding kernel implementation.
-     For Direct3D operator kernels, this may return an IUnknown supporting
-     QueryInterface to ID3D12GraphicsCommandList1.
-  */
-  virtual const void* GetExecutionHandle() const noexcept {
-    return nullptr;
-  }
-
-  /**
-     @return type of the execution provider; should match that set in the node
-     through the SetExecutionProvider API. Example valid return values are:
-     kCpuExecutionProvider, kCudaExecutionProvider
-  */
-  const std::string& Type() const { return type_; }
-
-  /**
-     Blocks until the device has completed all preceding requested tasks.
-     Currently this is primarily used by the IOBinding object to ensure that all
-     inputs have been copied to the device before execution begins.
-  */
-  virtual common::Status Sync() const { return Status::OK(); }
-
-  /**
-     Called when InferenceSession::Run started
-     NOTE that due to async execution in provider, the actual work of previous
-     Run may not be finished on device This function should be regarded as the
-     point after which a new Run would start to submit commands from CPU
-  */
-  virtual common::Status OnRunStart() { return Status::OK(); }
-
-  /**
-     Called when InferenceSession::Run ended
-     NOTE that due to async execution in provider, the actual work of this Run
-     may not be finished on device This function should be regarded as the point
-     that all commands of current Run has been submmited by CPU
-  */
-  virtual common::Status OnRunEnd(bool /*sync_stream*/) { return Status::OK(); }
-
-  /**
-     Indicate whether the graph capturing mode (e.g., cuda graph) is enabled for
-     the provider. Currently only CUDA execution provider supports it.
-   */
-  virtual bool IsGraphCaptureEnabled() const { return false; }
-
-  /**
-     Indicate whether the graph has been captured and instantiated. Currently
-     only CUDA execution provider supports it.
-   */
-  virtual bool IsGraphCaptured() const { return false; }
-
-  /**
-     Run the instantiated graph. Currently only CUDA execution provider supports
-     it.
-   */
-  virtual common::Status ReplayGraph() { return Status::OK(); }
-
-  /**
-     Called when session creation is complete
-     This provides an opportunity for execution providers to optionally synchronize and
-     clean up its temporary resources to reduce memory and ensure the first run is fast.
-  */
-  virtual common::Status OnSessionInitializationEnd() { return Status::OK(); }
-
-  void InsertAllocator(AllocatorPtr allocator);
-  void ReplaceAllocator(AllocatorPtr allocator);
-
-  struct FusedNodeAndGraph {
-    const std::reference_wrapper<onnxruntime::Node> fused_node;
-    // GraphViewer that filters the full graph to the nodes that are covered by 'node'
-    const std::reference_wrapper<GraphViewer> filtered_graph;
-  };
-
-  // Fusion approach that is suppported
-  // !!! The "Function" FusionStyle is deprecated.
-  // !!! If your EP is using this fusion style, please migrate it to "FilteredGraphViewer" style.
-  enum class FusionStyle {
-    // The node fusion will create an onnxruntime::Function based Node that contains a completely new Graph instance
-    // in the Node body. The original nodes and initializers are copied to the new Graph instance in Function::Body().
-    // A GraphProto can be produced from the Node body.
-    Function,
-
-    // The node fusion will create a new Node that defines the inputs and outputs using the IndexedSubGraph
-    // that GetCapability returned. The Node will not be onnxruntime::Function based so will have no Body().
-    // Instead a GraphViewer that filters the full Graph to the fused Nodes will be created.
-    // This is significantly cheaper as it doesn't incur the cost of creating a new Graph instance,
-    // and can be supported in a minimal build.
-    FilteredGraphViewer
-  };
-
-  virtual FusionStyle GetFusionStyle() const {
-    // All the ORT build in EP has migrate to FilteredGraphViewer style.
-    // For newer EPs, please avoid use Function style as it is deprecated.
-    return FusionStyle::FilteredGraphViewer;
-  }
-
-#if !defined(ORT_MINIMAL_BUILD) || defined(ORT_EXTENDED_MINIMAL_BUILD)
-  /**
-  Given a collection of fused Nodes and the respective GraphViewer instance for the nodes that were fused,
-  return create_state/compute/release_state func for each node.
-  @remarks This is now the default interface when execution provider wants to compile nodes
-           for both minimal build and complete ort build.
-
-           Do NOT cache the GraphViewer in FusedNodeAndGraph.filtered_graph in any of the NodeComputeInfo functions
-           as it is only valid for the duration of the call to Compile.
-  */
-  virtual common::Status Compile(const std::vector<FusedNodeAndGraph>& fused_nodes_and_graphs,
-                                 std::vector<NodeComputeInfo>& node_compute_funcs);
-
-#endif
-
-  void SetLogger(const logging::Logger* logger) {
-    logger_ = logger;
-  }
-
-  const logging::Logger* GetLogger() const {
-    return logger_;
-  }
-
-  /** Generate a unique id that can be used in a MetaDef name. Values are unique for a model instance.
-   The model hash is also returned if you wish to include that in the MetaDef name to ensure uniqueness across models.
-   @param graph_viewer[in] Graph viewer that GetCapability was called with. Can be for the main graph or nested graph.
-   @param model_hash[out] Returns the hash for the main (i.e. top level) graph in the model.
-                          This is created using the model path if available,
-                          or the model input names and the output names from all nodes in the main graph.
-   @remarks e.g. the TensorRT Execution Provider is used in multiple sessions and the underlying infrastructure caches
-            compiled kernels, so the name must be unique and deterministic across models and sessions.
-            NOTE: Ideally this would be a protected method, but to work across the EP bridge it has to be public and
-                  virtual, and ModelMetadefIdGenerator but be defined in the header as well.
-   */
-  virtual int GenerateMetaDefId(const onnxruntime::GraphViewer& graph_viewer, HashValue& model_hash) const;
-
-  /**
-     Register allocators for EP, potentially re-using existing allocators for a device from allocator_manager.
-     If the EP implements this it should generally delay creating any allocators until this is called.
-  */
-  virtual void RegisterAllocator(AllocatorManager& /*allocator_manager*/);
-
-  virtual std::unique_ptr<profiling::EpProfiler> GetProfiler() {
-    return {};
-  }
-
-  virtual DataLayout GetPreferredLayout() const {
-    // NCHW is the default ONNX standard data layout. So default to it.
-    // EPs which prefer a different layout should override to return their preferred layout.
-    return DataLayout::NCHW;
-  }
-
-  virtual void RegisterStreamHandlers(IStreamCommandHandleRegistry& /*stream_handle_registry*/) const {}
-
-  /** Does the EP support concurrent calls to InferenceSession::Run to execute the model.
-   */
-  virtual bool ConcurrentRunSupported() const { return true; }
-
-  /**
-   * Return the tuning context which holds all TunableOp state.
-   */
-  virtual ITuningContext* GetTuningContext() const {
-    return nullptr;
-  }
-
- private:
-  const std::string type_;
-
-  // allocator lookup is done by combining the device id and OrtMemType.
-  // there's also an implicit connection to the underlying OrtDevice involved that is dependent on the EP.
-  // e.g. for a CPU based EP, 'default' memory is a CPU device, and for a GPU based EP 'default' memory is a
-  // GPU device.
-  using AllocatorMap = std::unordered_map<int, AllocatorPtr>;
-  AllocatorMap allocators_;
-
-  // It will be set when this object is registered to a session
-  const logging::Logger* logger_ = nullptr;
-  // convenience list of the allocators so GetAllocatorList doesn't have to build a new vector each time
-  // contains the same instances as allocators_
-  std::vector<AllocatorPtr> allocator_list_;
-
-  // helper to generate ids that are unique to model and deterministic, even if the execution provider is shared across
-  // multiple sessions.
-  class ModelMetadefIdGenerator {
-   public:
-    int GenerateId(const onnxruntime::GraphViewer& graph_viewer, HashValue& model_hash);
-
-   private:
-    std::unordered_map<HashValue, HashValue> main_graph_hash_;  // map graph instance hash to model contents hash
-    std::unordered_map<HashValue, int> model_metadef_id_;       // current unique id for model
-  };
-
-  std::unique_ptr<ModelMetadefIdGenerator> metadef_id_generator_;
-};
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/float16.h

@@ -1,159 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-#pragma once
-
-#include "endian.h"
-#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
-#include "cuda_bf16.h"
-#endif
-
-#if !defined(__CUDACC__) && !defined(__HIPCC__)
-#include "core/common/narrow.h"
-#endif
-
-#include "core/common/common.h"
-
-namespace onnxruntime {
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-#define ORT_HOST_DEVICE __host__ __device__
-#else
-#define ORT_HOST_DEVICE
-#endif
-
-// MLFloat16
-struct MLFloat16 {
-  uint16_t val{0};
-
-  MLFloat16() = default;
-  explicit constexpr MLFloat16(uint16_t x) : val(x) {}
-  explicit MLFloat16(float f);
-
-  float ToFloat() const;
-
-  operator float() const { return ToFloat(); }
-};
-
-inline bool operator==(const MLFloat16& left, const MLFloat16& right) { return left.val == right.val; }
-inline bool operator!=(const MLFloat16& left, const MLFloat16& right) { return left.val != right.val; }
-inline bool operator<(const MLFloat16& left, const MLFloat16& right) { return left.val < right.val; }
-
-// BFloat16
-struct BFloat16 {
-  uint16_t val{0};
-#if defined(__HIP__)
-  ORT_HOST_DEVICE BFloat16() = default;
-#else
-  BFloat16() = default;
-#endif
-
-  struct FromBitsT {};
-  static constexpr ORT_HOST_DEVICE FromBitsT FromBits() { return FromBitsT(); }
-  constexpr ORT_HOST_DEVICE BFloat16(unsigned short bits, FromBitsT) : val(bits) {}
-
-  inline ORT_HOST_DEVICE BFloat16(float v) {
-#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000 && defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 800
-    val = __bfloat16_as_ushort(__float2bfloat16(v));
-#elif defined(__HIP__)
-    // We should be using memcpy in order to respect the strict aliasing rule but it fails in the HIP environment.
-    if (v != v) {  // isnan
-      val = UINT16_C(0x7FC0);
-    } else {
-      union {
-        uint32_t U32;
-        float F32;
-      };
-
-      F32 = v;
-      uint32_t rounding_bias = ((U32 >> 16) & 1) + UINT32_C(0x7FFF);
-      val = static_cast<uint16_t>((U32 + rounding_bias) >> 16);
-    }
-#else
-    if constexpr(endian::native == endian::little) {
-      std::memcpy(&val, reinterpret_cast<char*>(&v) + sizeof(uint16_t), sizeof(uint16_t));
-    }
-    else {
-      std::memcpy(&val, &v, sizeof(uint16_t));
-    }
-#endif
-  }
-
-  inline ORT_HOST_DEVICE float ToFloat() const {
-#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
-    return __bfloat162float(*reinterpret_cast<const __nv_bfloat16*>(&val));
-#elif defined(__HIP__)
-    // We should be using memcpy in order to respect the strict aliasing rule but it fails in the HIP environment.
-    float result = 0;
-    uint32_t tmp = val;
-    tmp <<= 16;
-    float* tempRes = reinterpret_cast<float*>(&tmp);
-    result = *tempRes;
-    return result;
-#else
-    float result;
-    char* const first = reinterpret_cast<char*>(&result);
-    char* const second = first + sizeof(uint16_t);
-    if constexpr(endian::native == endian::little) {
-      std::memset(first, 0, sizeof(uint16_t));
-      std::memcpy(second, &val, sizeof(uint16_t));
-    }
-    else {
-      std::memcpy(first, &val, sizeof(uint16_t));
-      std::memset(second, 0, sizeof(uint16_t));
-    }
-    return result;
-#endif
-  }
-
-  inline ORT_HOST_DEVICE operator float() const { return ToFloat(); }
-
-#if defined(CUDA_VERSION) && CUDA_VERSION >= 11000
-  ORT_HOST_DEVICE BFloat16(const __nv_bfloat16& value) { val = *reinterpret_cast<const unsigned short*>(&value); }
-  explicit ORT_HOST_DEVICE operator __nv_bfloat16() const { return *reinterpret_cast<const __nv_bfloat16*>(&val); }
-#endif
-};
-
-inline ORT_HOST_DEVICE bool operator==(const BFloat16& left, const BFloat16& right) { return left.val == right.val; }
-inline ORT_HOST_DEVICE bool operator!=(const BFloat16& left, const BFloat16& right) { return left.val != right.val; }
-inline ORT_HOST_DEVICE bool operator<(const BFloat16& left, const BFloat16& right) { return left.val < right.val; }
-
-
-// User defined suffixes to make it easier to declare
-// initializers with MLFloat16 and BFloat16 from unsigned short
-// E.g 10_f16 or 10_b16
-#if !defined(__CUDACC__) && !defined(__HIPCC__)
-inline MLFloat16 operator"" _f16(unsigned long long int v) {
-  return MLFloat16(narrow<uint16_t>(v));
-}
-
-inline MLFloat16 operator"" _fp16(long double v) {
-  return MLFloat16(static_cast<float>(v));
-}
-
-inline BFloat16 operator"" _b16(unsigned long long int v) {
-  return BFloat16(narrow<uint16_t>(v), BFloat16::FromBits());
-}
-
-inline BFloat16 operator"" _bfp16(long double v) {
-  return BFloat16(static_cast<float>(v));
-}
-
-#endif
-
-inline void BFloat16ToFloat(const BFloat16* blf, float* flt, size_t size) {
-  auto src = blf;
-  auto d = flt;
-  for (; size != 0; ++src, ++d, --size) {
-    *d = src->ToFloat();
-  }
-}
-
-inline void FloatToBFloat16(const float* flt, BFloat16* blf, size_t size) {
-  auto src = flt;
-  auto d = blf;
-  for (; size != 0; ++src, ++d, --size) {
-    new (d) BFloat16(*src);
-  }
-}
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/framework_common.h

@@ -1,22 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include "run_options.h"
-
-namespace onnxruntime {  // forward declarations
-class Model;
-class GraphTransformer;
-class NodeArg;
-}  // namespace onnxruntime
-
-namespace onnxruntime {
-using InputDefList = std::vector<const onnxruntime::NodeArg*>;
-using OutputDefList = std::vector<const onnxruntime::NodeArg*>;
-
-using NameMLValMap = std::unordered_map<std::string, OrtValue>;
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/func_api.h

@@ -1,27 +0,0 @@
-#pragma once
-#include "core/common/status.h"
-using onnxruntime::common::Status;  // TODO: Needed by WinML, but shouldn't be put into the global namespace like this
-
-namespace onnxruntime {
-
-// AllocateFunc(void* handle, size_t alignment, size_t size)
-using AllocateFunc = void* (*)(void*, size_t, size_t);
-using DestroyFunc = void (*)(void*, void*);
-using AllocatorHandle = void*;
-
-typedef struct {
-  //right now we only include allocation for host memory
-  AllocateFunc allocate_func;
-  DestroyFunc release_func;
-  AllocatorHandle allocator_handle;
-  const char* node_name;
-} ComputeContext;
-
-using FunctionState = void*;
-// take the ComputeContext, and create a function state.
-using CreateFunctionStateC = int (*)(ComputeContext*, FunctionState*);
-// pass in the function state and input/output tensors, perform compute and return status
-using ComputeFuncC = common::Status (*)(FunctionState, const OrtApi*, OrtKernelContext*);
-// release the function state.
-using DestroyFunctionStateC = void (*)(FunctionState);
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/kernel_def_builder.h

@@ -1,353 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <limits.h>
-#include <memory>
-#include <optional>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "core/common/common.h"
-#include "core/framework/allocator.h"
-#include "core/framework/data_types.h"
-#include "core/graph/basic_types.h"
-
-namespace onnxruntime {
-class KernelDefBuilder;
-
-typedef std::map<size_t, OrtMemType> MemTypeMap;
-
-class KernelDef {
- private:
-  // note that input/output might be on CPU implicitly when the node is from CPU execution provider
-  constexpr static inline bool MemTypeOnCpuExplicitly(OrtMemType mem_type) {
-    return mem_type == OrtMemTypeCPUInput || mem_type == OrtMemTypeCPUOutput;
-  }
-
- public:
-  explicit KernelDef() = default;
-
-  const std::string& OpName() const {
-    return op_name_;
-  }
-
-  const std::string& Domain() const {
-    return op_domain_;
-  }
-
-  void SinceVersion(/*out*/ int* start, /*out*/ int* end) const {
-    *start = op_since_version_start_;
-    *end = op_since_version_end_;
-  }
-
-#ifdef onnxruntime_PYBIND_EXPORT_OPSCHEMA
-  const std::pair<int, int> SinceVersion() const {
-    return std::pair<int, int>(op_since_version_start_, op_since_version_end_);
-  }
-#endif
-
-  onnxruntime::ProviderType Provider() const {
-    return provider_type_;
-  }
-
-  // type constraints with types supported in this build
-  const std::unordered_map<std::string, std::vector<MLDataType>>& TypeConstraints() const {
-    return type_constraints_;
-  }
-
-  const std::vector<std::pair<int, int>>& MayInplace() const {
-    return inplace_map_;
-  }
-
-  const std::vector<std::pair<int, int>>& Alias() const {
-    return alias_map_;
-  }
-
-  const std::optional<std::pair<int, int>>& VariadicAlias() const {
-    return variadic_alias_offsets_;
-  }
-
-  OrtMemType InputMemoryType(size_t input_index) const {
-    auto it = input_memory_type_args_.find(input_index);
-    if (it == input_memory_type_args_.end())
-      return default_inputs_mem_type_;
-    return it->second;
-  }
-
-  bool IsInputOnCpu(size_t input_index) const { return MemTypeOnCpuExplicitly(InputMemoryType(input_index)); }
-
-  bool IsOutputOnCpu(size_t output_index) const { return MemTypeOnCpuExplicitly(OutputMemoryType(output_index)); }
-
-  bool AllocateInputsContiguously() const { return allocate_inputs_contiguously_; }
-
-  bool HasExternalOutputs() const { return external_outputs_; }
-
-#ifdef ENABLE_STRIDED_TENSORS
-  const std::vector<int>& MayStridedInput() const { return may_strided_inputs_; }
-  const std::vector<std::pair<int, int>>& MayStridedOutput() const { return may_strided_output_map_; }
-#endif
-
-  OrtMemType OutputMemoryType(size_t output_index) const {
-    auto it = output_memory_type_args_.find(output_index);
-    if (it == output_memory_type_args_.end())
-      return default_outputs_mem_type_;
-    return it->second;
-  }
-
-  int ExecQueueId() const {
-    return exec_queue_id_;
-  }
-
-  bool IsConflict(const KernelDef& other) const;
-
- private:
-  friend class KernelDefBuilder;
-
-  // The operator name supported by <*this> kernel..
-  std::string op_name_;
-
-  // The operator since_version range supported by <*this> kernel.
-  // A kernel could support an operator definition between <op_since_version_start>
-  // and <op_since_version_end> (inclusive).
-  int op_since_version_start_ = 1;
-  int op_since_version_end_ = INT_MAX;
-
-  // The operator domain supported by <*this> kernel.
-  // Default to 'onnxruntime::kOnnxDomain'.
-  // Please note the behavior of std::string("") and std::string() are different
-  std::string op_domain_;
-
-  // The type of the execution provider.
-  std::string provider_type_;
-
-  // The data types that are supported in this build (enabled) for inputs/outputs.
-  // Key is input/output/type constraint name defined in op schema, Value is supported types.
-  std::unordered_map<std::string, std::vector<MLDataType>> type_constraints_;
-
-  // An element <i, j> means that output j reuses the memory of input i.
-  std::vector<std::pair<int, int>> inplace_map_;
-
-  // An element <i, j> means that output j is an alias of input i.
-  std::vector<std::pair<int, int>> alias_map_;
-
-  // This variable stores <input_offset, output_offset> for the variadic alias mapping
-  // output 'i + output_offset' is an alias of input 'i + input_offset' for all i >= 0
-  std::optional<std::pair<int, int>> variadic_alias_offsets_;
-
-  // Require input tensors to be allocated contiguously.
-  bool allocate_inputs_contiguously_ = false;
-
-  // Whether the outputs are from external.
-  bool external_outputs_ = false;
-
-#ifdef ENABLE_STRIDED_TENSORS
-  // An element i means i-th input can be strided tensor.
-  std::vector<int> may_strided_inputs_;
-
-  // An element <i, j> means j-th output can be a strided tensor, which share the data from i-th input.
-  std::vector<std::pair<int, int>> may_strided_output_map_;
-#endif
-
-  // The memory types of inputs/outputs of this kernel
-  MemTypeMap input_memory_type_args_;
-  MemTypeMap output_memory_type_args_;
-
-  // execution command queue id, 0 for default queue in execution provider
-  int exec_queue_id_ = 0;
-  // Default memory type for all inputs
-  OrtMemType default_inputs_mem_type_{OrtMemTypeDefault};
-  // Default memory type for all outputs
-  OrtMemType default_outputs_mem_type_{OrtMemTypeDefault};
-};
-
-class KernelDefBuilder {
- public:
-  static std::unique_ptr<KernelDefBuilder> Create() { return std::make_unique<KernelDefBuilder>(); }
-
-  explicit KernelDefBuilder()
-      : kernel_def_(std::make_unique<KernelDef>()) {}
-
-  KernelDefBuilder& SetName(const std::string& op_name);
-  KernelDefBuilder& SetName(const char* op_name);
-
-  KernelDefBuilder& SetDomain(const std::string& domain);
-  KernelDefBuilder& SetDomain(const char* domain);
-
-  /**
-     This kernel supports operator definition since <since_version> (to latest).
-  */
-  KernelDefBuilder& SinceVersion(int since_version) {
-    kernel_def_->op_since_version_start_ = since_version;
-    return *this;
-  }
-
-  /**
-     The start and end version should be set accordingly per version range for
-     each domain registered in OpSchemaRegistry::DomainToVersionRange in
-     \onnxruntime\onnxruntime\core\graph\op.h as below.
-     Key: domain. Value: <lowest version, highest version> pair.
-     std::unordered_map<std::string, std::pair<int, int>> map_;
-  */
-  KernelDefBuilder& SinceVersion(int since_version_start, int since_version_end) {
-    kernel_def_->op_since_version_start_ = since_version_start;
-    kernel_def_->op_since_version_end_ = since_version_end;
-    return *this;
-  }
-
-  /**
-     The execution provider type of the kernel.
-  */
-  KernelDefBuilder& Provider(ProviderType provider_type);
-  KernelDefBuilder& Provider(const char* provider_type);
-
-  /**
-     Specify the set of types that this kernel supports. A further restriction
-     of the set of types specified in the op schema.
-
-     @param arg_name The arg name can be either op formal parameter name, say "X", or type
-                     argument name specified in op schema, say "T".
-     @param types The types that are supported in this build.
-  */
-  KernelDefBuilder& TypeConstraint(const std::string& arg_name, std::vector<MLDataType> types);
-  KernelDefBuilder& TypeConstraint(const char* arg_name, std::vector<MLDataType> types);
-
-  /**
-     Like TypeConstraint but supports just a single type.
-  */
-  KernelDefBuilder& TypeConstraint(const std::string& arg_name, MLDataType type);
-  KernelDefBuilder& TypeConstraint(const char* arg_name, MLDataType type);
-
-  /**
-     Inplace mapping from inputs to outputs allowed.
-     It means that uplayer runtime could do memory in-place optimization
-     as it will not impact the correctness of this kernel.
-  */
-  KernelDefBuilder& MayInplace(const std::vector<std::pair<int, int>>& inplaces);
-  KernelDefBuilder& MayInplace(int input_index, int output_index);
-
-  /**
-     Alias mapping from inputs to outputs. Different from Inplace that the
-     content of the tensor is not changed. This is to take care of operators
-     such as Identity and Reshape.
-  */
-  KernelDefBuilder& Alias(const std::vector<std::pair<int, int>>& aliases);
-  KernelDefBuilder& Alias(int input_index, int output_index);
-
-  /**
-     Apply variadic number of alias mapping from inputs to outputs.
-     This is effectively applying Alias(i + input_offset, i + output_offset) for i >= 0
-  */
-  KernelDefBuilder& VariadicAlias(int input_offset, int output_offset);
-
-  /**
-     Specify that this kernel requires input tensors to be allocated
-     contiguously. This allows kernels to execute as a single large
-     computation, rather than numerous smaller computations.
-  */
-  KernelDefBuilder& AllocateInputsContiguously() {
-    kernel_def_->allocate_inputs_contiguously_ = true;
-    return *this;
-  }
-
-  /**
-     Specify that this kernel's output buffers are passed from external,
-     i.e. not created or managed by ORT's memory allocator.
-  */
-  KernelDefBuilder& ExternalOutputs() {
-    kernel_def_->external_outputs_ = true;
-    return *this;
-  }
-
-#ifdef ENABLE_STRIDED_TENSORS
-  /**
-     Specify that the input_index-th input can be strided tensor.
-   */
-  KernelDefBuilder& MayStridedInput(int input_index);
-
-  /**
-     Specify that the output_index-th output can be strided tensor, and share the data
-     from input_index-th input.
-   */
-  KernelDefBuilder& MayStridedOutput(int input_index, int output_index);
-#endif
-
-  /**
-     Specify that this kernel requires an input arg
-     in certain memory type (instead of the default, device memory).
-  */
-  KernelDefBuilder& InputMemoryType(OrtMemType type, int input_index) {
-    kernel_def_->input_memory_type_args_.insert(std::make_pair(input_index, type));
-    return *this;
-  }
-
-  /**
-     Specify that this kernel requires input arguments
-     in certain memory type (instead of the default, device memory).
-  */
-  KernelDefBuilder& InputMemoryType(OrtMemType type, const std::vector<int>& input_indexes) {
-    for (auto input_index : input_indexes) {
-      kernel_def_->input_memory_type_args_.insert(std::make_pair(input_index, type));
-    }
-    return *this;
-  }
-
-  /**
-     Specify that this kernel provides an output arg
-     in certain memory type (instead of the default, device memory).
-  */
-  KernelDefBuilder& OutputMemoryType(OrtMemType type, int output_index) {
-    kernel_def_->output_memory_type_args_.insert(std::make_pair(output_index, type));
-    return *this;
-  }
-
-  /**
-     Specify that this kernel provides an output arguments
-     in certain memory type (instead of the default, device memory).
-  */
-  KernelDefBuilder& OutputMemoryType(OrtMemType type, const std::vector<int>& output_indexes) {
-    for (auto output_index : output_indexes) {
-      kernel_def_->output_memory_type_args_.insert(std::make_pair(output_index, type));
-    }
-    return *this;
-  }
-
-  /**
-     Specify that this kernel runs on which execution queue in the provider
-  */
-  KernelDefBuilder& ExecQueueId(int queue_id) {
-    kernel_def_->exec_queue_id_ = queue_id;
-    return *this;
-  }
-
-  /**
-  Specify the default inputs memory type, if not specified, it is DefaultMemory
-  */
-  KernelDefBuilder& SetDefaultInputsMemoryType(OrtMemType mem_type) {
-    kernel_def_->default_inputs_mem_type_ = mem_type;
-    return *this;
-  }
-
-  /**
-  Specify the default outputs memory type, if not specified, it is DefaultMemory
-  */
-  KernelDefBuilder& SetDefaultOutputMemoryType(OrtMemType mem_type) {
-    kernel_def_->default_outputs_mem_type_ = mem_type;
-    return *this;
-  }
-
-  /**
-     Return the kernel definition, passing ownership of the KernelDef to the caller
-  */
-  std::unique_ptr<KernelDef> Build() {
-    return std::move(kernel_def_);
-  }
-
- private:
-  // we own the KernelDef until Build() is called.
-  std::unique_ptr<KernelDef> kernel_def_;
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/kernel_registry.h

@@ -1,91 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string_view>
-
-#include "core/framework/op_kernel.h"
-
-namespace onnxruntime {
-
-using KernelCreateMap = std::multimap<std::string, KernelCreateInfo>;
-using KernelDefHashes = std::vector<std::pair<std::string, HashValue>>;
-
-class IKernelTypeStrResolver;
-
-/**
- * Each provider has a KernelRegistry. Often, the KernelRegistry only belongs to that specific provider.
- */
-class KernelRegistry {
- public:
-  KernelRegistry() = default;
-
-  // Register a kernel with kernel definition and function to create the kernel.
-  Status Register(KernelDefBuilder& kernel_def_builder, const KernelCreateFn& kernel_creator);
-
-  Status Register(KernelCreateInfo&& create_info);
-
-  // TODO(edgchen1) for TryFindKernel(), consider using `out` != nullptr as indicator of whether kernel was found and
-  // Status as an indication of failure
-
-  // Check if an execution provider can create kernel for a node and return the kernel if so
-  Status TryFindKernel(const Node& node, ProviderType exec_provider,
-                       const IKernelTypeStrResolver& kernel_type_str_resolver,
-                       const KernelCreateInfo** out) const;
-
-  static bool HasImplementationOf(const KernelRegistry& r, const Node& node,
-                                  ProviderType exec_provider,
-                                  const IKernelTypeStrResolver& kernel_type_str_resolver) {
-    const KernelCreateInfo* info;
-    Status st = r.TryFindKernel(node, exec_provider, kernel_type_str_resolver, &info);
-    return st.IsOK();
-  }
-
-#if !defined(ORT_MINIMAL_BUILD)
-  // Find KernelCreateInfo in instant mode
-  Status TryFindKernel(const std::string& op_name, const std::string& domain, const int& version,
-                       const std::unordered_map<std::string, MLDataType>& type_constraints,
-                       ProviderType exec_provider, const KernelCreateInfo** out) const;
-#endif  // !defined(ORT_MINIMAL_BUILD)
-
-  bool IsEmpty() const { return kernel_creator_fn_map_.empty(); }
-
-#ifdef onnxruntime_PYBIND_EXPORT_OPSCHEMA
-  // This is used by the opkernel doc generator to enlist all registered operators for a given provider's opkernel
-  const KernelCreateMap& GetKernelCreateMap() const {
-    return kernel_creator_fn_map_;
-  }
-#endif
-
- private:
-  // Check whether the types of inputs/outputs of the given node match the extra
-  // type-constraints of the given kernel. This serves two purposes: first, to
-  // select the right kernel implementation based on the types of the arguments
-  // when we have multiple kernels, e.g., Clip<float> and Clip<int>; second, to
-  // accommodate (and check) mapping of ONNX (specification) type to the onnxruntime
-  // implementation type (e.g., if we want to implement ONNX's float16 as a regular
-  // float in onnxruntime). (The second, however, requires a globally uniform mapping.)
-  //
-  // Note that this is not intended for type-checking the node against the ONNX
-  // type specification of the corresponding op, which is done before this check.
-  static bool VerifyKernelDef(const Node& node,
-                              const KernelDef& kernel_def,
-                              const IKernelTypeStrResolver& kernel_type_str_resolver,
-                              std::string& error_str);
-
-  static std::string GetMapKey(std::string_view op_name, std::string_view domain, std::string_view provider) {
-    std::string key(op_name);
-    // use the kOnnxDomainAlias of 'ai.onnx' instead of kOnnxDomain's empty string
-    key.append(1, ' ').append(domain.empty() ? kOnnxDomainAlias : domain).append(1, ' ').append(provider);
-    return key;
-  }
-
-  static std::string GetMapKey(const KernelDef& kernel_def) {
-    return GetMapKey(kernel_def.OpName(), kernel_def.Domain(), kernel_def.Provider());
-  }
-  // Kernel create function map from op name to kernel creation info.
-  // key is opname+domain_name+provider_name
-  KernelCreateMap kernel_creator_fn_map_;
-};
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/op_kernel.h

@@ -1,387 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "boost/mp11.hpp"
-
-// It is safe to include the below header even if SHARED_PROVIDER macro is enabled
-// as it doesn't include any pb headers.
-#include "core/framework/prepacked_weights_container.h"
-
-#ifndef SHARED_PROVIDER
-#include <functional>
-#include "core/common/exceptions.h"
-#include "core/common/logging/logging.h"
-#include "core/common/status.h"
-#include "core/framework/execution_provider.h"
-#include "core/framework/kernel_def_builder.h"
-#include "core/framework/ort_value.h"
-#include "core/framework/op_kernel_info.h"
-#include "core/framework/op_node_proto_helper.h"
-#include "core/framework/tensor.h"
-#include "core/framework/sparse_tensor.h"
-#include "core/graph/constants.h"
-#include "core/graph/graph_viewer.h"
-#if !defined(ORT_MINIMAL_BUILD)
-#include "onnx/defs/schema.h"
-#else
-#include "onnx/defs/data_type_utils.h"
-#endif
-#include "onnx/onnx_pb.h"
-#include "onnx/onnx-operators_pb.h"
-#include "core/common/gsl.h"
-namespace onnxruntime {
-class OpKernelContext;
-}
-#endif
-
-namespace onnxruntime {
-
-std::unique_ptr<OpKernelInfo> CopyOpKernelInfo(const OpKernelInfo& info);
-
-class OpKernel {
- public:
-  using DoneCallback = std::function<void()>;
-
-  explicit OpKernel(const OpKernelInfo& info) : op_kernel_info_(CopyOpKernelInfo(info)) {}
-  virtual ~OpKernel() = default;
-
-  const onnxruntime::Node& Node() const;
-  const onnxruntime::KernelDef& KernelDef() const;
-
-  [[nodiscard]] virtual Status Compute(_Inout_ OpKernelContext* context) const = 0;
-
-  [[nodiscard]] virtual bool IsAsync() const {
-    // by default all kernels are sync version.
-    return false;
-  }
-
-  [[nodiscard]] virtual Status ComputeAsync(_Inout_ OpKernelContext*, DoneCallback) const {
-    ORT_NOT_IMPLEMENTED(__FUNCTION__, " is not implemented");
-  }
-
-  // Override this function to PrePack initialized constant tensor to the format as needed.
-  // For example, MatMul kernel can pack the input B if it is constant like code below.
-  //   Status PrePack(const Tensor& tensor, int input_idx, /*out*/ bool& is_packed,
-  //                  /*out*/ PrePackedWeights* prepacked_weight_for_caching,
-  //                  AllocatorPtr alloc) override {
-  //     is_packed = false;
-  //     if (input_idx == 1) {
-  //       is_packed = true;
-  //       this.Pack(tensor, this.buffer_, alloc);
-  //       if (prepacked_weight_for_caching) {
-  //           // LOGIC TO CACHE `this.buffer_` SINCE THE KERNEL DOESN"T OWN THE PACKED WEIGHT
-  //       }
-  //     }
-  //     return Status::OK();
-  //   }
-  // Please refer to MatMulIntegerToFloatBase for a complete example
-  // @param tensor: The initialized constant tensor
-  // @param input_idx: The input index of the tensor in this kernel
-  // @param alloc: The kernel's PrePack() method MUST use this allocator for allocating the pre-packed
-  //               weights' buffers. The alloc that the PrePack() method will receive will be either
-  //               the allocator tied to the session if the kernel owns the pre-packed buffer or an
-  //               allocator shared between sessions if the pre-packed buffer is to be shared across sessions
-  //               (i.e.) the kernel does not own the buffer.
-  // @param is_packed: Set it to true if the kernel packed the tensor or to false
-  //                   The kernel is responsible for keeping the packed data and related metadata if is_packed is true,
-  //                   and the original initialized constant tensor will be released and not accessible anymore in
-  //                   the Compute function.
-  // @param prepacked_weights: A PrePackedWeights instance will be provided to the kernel IF the pre-packed weights
-  //                          are meant to be stored in a shared container.
-
-  virtual Status
-  PrePack(const Tensor& /*tensor*/, int /*input_idx*/, AllocatorPtr /*alloc*/,
-          /*out*/ bool& is_packed, /*out*/ PrePackedWeights* /*prepacked_weights*/) {
-    is_packed = false;
-    return Status::OK();
-  }
-
-  // Override this function to use provided pre-packed weight.
-  // Status UseSharedPrePackedBuffers(std::vector<BufferUniquePtr>& prepacked_buffers,
-  //                                 int input_idx,
-  //                                 /*out*/ bool& used_shared_buffers) {
-  //     used_shared_buffers = true;
-  //     this.buffer_ = std::move(prepacked_buffers[0]);
-  //     return Status::OK();
-  //   }
-  // Please refer to MatMulIntegerToFloatBase for a complete example
-  // @param prepacked_buffers: The pre-packed buffers to be used by this kernel for the provided input index
-  //                           (Sometimes a single constant initializer may have multiple pre-packed buffers associated
-  //                            with it and it upto the kernel developer to store it in any order of their choice in PrePack()
-  //                            and must use the same order for retrieval in UseSharedPrePackedBuffers().
-  // @param input_idx: The input index of the tensor in this kernel
-  // @param used_shared_buffers: Boolean flag set by the kernel implementation indicating
-  // that the provided weight has been used by the kernel.
-  virtual Status UseSharedPrePackedBuffers(std::vector<BufferUniquePtr>& /*prepacked_buffers*/,
-                                           int /*input_idx*/,
-                                           /*out*/ bool& used_shared_buffers) {
-    used_shared_buffers = false;
-    return Status::OK();
-  }
-
-  const OrtMemoryInfo& Allocator(OrtMemType mem_type) const;
-  const OpKernelInfo& Info() const {
-    return *op_kernel_info_;
-  }
-
- private:
-  ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(OpKernel);
-  std::unique_ptr<OpKernelInfo> op_kernel_info_;
-};
-class FuncManager;
-using KernelCreateFn = std::function<Status(FuncManager& func_mgr, const OpKernelInfo& info, std::unique_ptr<OpKernel>& out)>;
-using KernelCreatePtrFn = std::add_pointer<Status(FuncManager& func_mgr, const OpKernelInfo& info, std::unique_ptr<OpKernel>& out)>::type;
-
-struct KernelCreateInfo {
-  std::unique_ptr<KernelDef> kernel_def;  // Owned and stored in the global kernel registry.
-  KernelCreateFn kernel_create_func;
-  Status status;
-
-  KernelCreateInfo(std::unique_ptr<KernelDef> definition,
-                   KernelCreateFn create_func)
-      : kernel_def(std::move(definition)),
-        kernel_create_func(create_func) {}
-
-  KernelCreateInfo(KernelCreateInfo&& other) noexcept
-      : kernel_def(std::move(other.kernel_def)),
-        kernel_create_func(std::move(other.kernel_create_func)) {}
-
-  KernelCreateInfo() = default;
-};
-
-// Forward declarations for the non-specialized BuildKernelCreateInfo method.
-template <typename T>
-KernelCreateInfo BuildKernelCreateInfo();
-
-namespace ml {
-template <typename T>
-KernelCreateInfo BuildKernelCreateInfo();
-}  // namespace ml
-
-namespace contrib {
-template <typename T>
-KernelCreateInfo BuildKernelCreateInfo();
-}  // namespace contrib
-
-namespace contrib {
-namespace cuda {
-template <typename T>
-KernelCreateInfo BuildKernelCreateInfo();
-}  // namespace cuda
-}  // namespace contrib
-
-namespace contrib {
-namespace rocm {
-template <typename T>
-KernelCreateInfo BuildKernelCreateInfo();
-}  // namespace rocm
-}  // namespace contrib
-
-namespace contrib {
-namespace snpe {
-template <typename T>
-KernelCreateInfo BuildKernelCreateInfo();
-}  // namespace snpe
-}  // namespace contrib
-
-using BuildKernelCreateInfoFn = KernelCreateInfo (*)();
-
-// Naming convention for operator kernel classes
-#define ONNX_OPERATOR_KERNEL_CLASS_NAME(provider, domain, ver, name) \
-  provider##_##name##_##domain##_ver##ver
-
-#define ONNX_CPU_OPERATOR_KERNEL(name, ver, builder, ...) \
-  ONNX_OPERATOR_KERNEL_EX(name, kOnnxDomain, ver, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_CPU_OPERATOR_ML_KERNEL(name, ver, builder, ...) \
-  ONNX_OPERATOR_KERNEL_EX(name, kMLDomain, ver, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_CPU_OPERATOR_MS_KERNEL(name, ver, builder, ...) \
-  ONNX_OPERATOR_KERNEL_EX(name, kMSDomain, ver, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_OPERATOR_KERNEL_EX(name, domain, ver, provider, builder, ...)                \
-  class ONNX_OPERATOR_KERNEL_CLASS_NAME(provider, domain, ver, name);                     \
-  template <>                                                                             \
-  KernelCreateInfo                                                                        \
-  BuildKernelCreateInfo<ONNX_OPERATOR_KERNEL_CLASS_NAME(provider, domain, ver, name)>() { \
-    return KernelCreateInfo(                                                              \
-        builder.SetName(#name)                                                            \
-            .SetDomain(domain)                                                            \
-            .SinceVersion(ver)                                                            \
-            .Provider(provider)                                                           \
-            .Build(),                                                                     \
-        static_cast<KernelCreatePtrFn>(                                                   \
-            [](FuncManager&,                                                              \
-               const OpKernelInfo& info,                                                  \
-               std::unique_ptr<OpKernel>& out) -> Status {                                \
-              out = std::make_unique<__VA_ARGS__>(info);                                  \
-              return Status::OK();                                                        \
-            }));                                                                          \
-  }
-
-#define ONNX_OPERATOR_VERSIONED_KERNEL_CLASS_NAME(provider, domain, startver, endver, name) \
-  provider##_##name##_##domain##_ver##startver##_##endver
-
-#define ONNX_CPU_OPERATOR_VERSIONED_KERNEL(name, startver, endver, builder, ...) \
-  ONNX_OPERATOR_VERSIONED_KERNEL_EX(name, kOnnxDomain, startver, endver, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_CPU_OPERATOR_VERSIONED_ML_KERNEL(name, startver, endver, builder, ...) \
-  ONNX_OPERATOR_VERSIONED_KERNEL_EX(name, kMLDomain, startver, endver, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_OPERATOR_VERSIONED_KERNEL_EX(name, domain, startver, endver, provider, builder, ...)                                  \
-  class ONNX_OPERATOR_VERSIONED_KERNEL_CLASS_NAME(provider, domain, startver, endver, name);                                       \
-  template <>                                                                                                                      \
-  KernelCreateInfo                                                                                                                 \
-  BuildKernelCreateInfo<ONNX_OPERATOR_VERSIONED_KERNEL_CLASS_NAME(provider, domain, startver, endver, name)>() {                   \
-    return KernelCreateInfo(                                                                                                       \
-        builder.SetName(#name)                                                                                                     \
-            .SetDomain(domain)                                                                                                     \
-            .SinceVersion(startver, endver)                                                                                        \
-            .Provider(provider)                                                                                                    \
-            .Build(),                                                                                                              \
-        static_cast<KernelCreatePtrFn>([](FuncManager&, const OpKernelInfo& info, std::unique_ptr<OpKernel>& out) -> Status { out = std::make_unique<__VA_ARGS__>(info); return Status::OK(); })); \
-  }
-
-#define ONNX_OPERATOR_TYPED_KERNEL_CLASS_NAME(provider, domain, ver, type, name) \
-  provider##_##name##_##domain##_ver##ver##_##type
-
-#define ONNX_CPU_OPERATOR_TYPED_KERNEL(name, ver, type, builder, ...) \
-  ONNX_OPERATOR_TYPED_KERNEL_EX(name, kOnnxDomain, ver, type, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_CPU_OPERATOR_TYPED_ML_KERNEL(name, ver, type, builder, ...) \
-  ONNX_OPERATOR_TYPED_KERNEL_EX(name, kMLDomain, ver, type, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_CPU_OPERATOR_TYPED_MS_KERNEL(name, ver, type, builder, ...) \
-  ONNX_OPERATOR_TYPED_KERNEL_EX(name, kMSDomain, ver, type, kCpuExecutionProvider, builder, __VA_ARGS__)
-
-#define ONNX_OPERATOR_TYPED_KERNEL_EX(name, domain, ver, type, provider, builder, ...)                                             \
-  class ONNX_OPERATOR_TYPED_KERNEL_CLASS_NAME(provider, domain, ver, type, name);                                                  \
-  template <>                                                                                                                      \
-  KernelCreateInfo                                                                                                                 \
-  BuildKernelCreateInfo<ONNX_OPERATOR_TYPED_KERNEL_CLASS_NAME(provider, domain, ver, type, name)>() {                              \
-    return KernelCreateInfo(                                                                                                       \
-        builder.SetName(#name)                                                                                                     \
-            .SetDomain(domain)                                                                                                     \
-            .SinceVersion(ver)                                                                                                     \
-            .Provider(provider)                                                                                                    \
-            .Build(),                                                                                                              \
-        static_cast<KernelCreatePtrFn>([](FuncManager&, const OpKernelInfo& info, std::unique_ptr<OpKernel>& out) -> Status { out = std::make_unique<__VA_ARGS__>(info); return Status::OK(); })); \
-  }
-
-#define ONNX_OPERATOR_TWO_TYPED_KERNEL_CLASS_NAME(provider, domain, ver, type1, type2, name) \
-  provider##_##name##_##domain##_ver##ver##_##type1##_##type2
-
-#define ONNX_OPERATOR_TWO_TYPED_KERNEL_EX(name, domain, ver, type1, type2, provider, builder, ...)                                 \
-  class ONNX_OPERATOR_TWO_TYPED_KERNEL_CLASS_NAME(provider, domain, ver, type1, type2, name);                                      \
-  template <>                                                                                                                      \
-  KernelCreateInfo                                                                                                                 \
-  BuildKernelCreateInfo<ONNX_OPERATOR_TWO_TYPED_KERNEL_CLASS_NAME(provider, domain, ver, type1, type2, name)>() {                  \
-    return KernelCreateInfo(                                                                                                       \
-        builder.SetName(#name)                                                                                                     \
-            .SetDomain(domain)                                                                                                     \
-            .SinceVersion(ver)                                                                                                     \
-            .Provider(provider)                                                                                                    \
-            .Build(),                                                                                                              \
-        static_cast<KernelCreatePtrFn>([](FuncManager&, const OpKernelInfo& info, std::unique_ptr<OpKernel>& out) -> Status { out = std::make_unique<__VA_ARGS__>(info); return Status::OK(); })); \
-  }
-
-#define ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_CLASS_NAME(provider, domain, startver, endver, type, name) \
-  provider##_##name##_##domain##_ver##startver##_##endver##_##type
-
-#define ONNX_CPU_OPERATOR_VERSIONED_TYPED_KERNEL(name, startver, endver, type, builder, ...)                         \
-  ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_EX(name, kOnnxDomain, startver, endver, type, kCpuExecutionProvider, builder, \
-                                          __VA_ARGS__)
-
-#define ONNX_CPU_OPERATOR_VERSIONED_TYPED_ML_KERNEL(name, startver, endver, type, builder, ...)                    \
-  ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_EX(name, kMLDomain, startver, endver, type, kCpuExecutionProvider, builder, \
-                                          __VA_ARGS__)
-
-#define ONNX_CPU_OPERATOR_VERSIONED_TYPED_MS_KERNEL(name, startver, endver, type, builder, ...)                    \
-  ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_EX(name, kMSDomain, startver, endver, type, kCpuExecutionProvider, builder, \
-                                          __VA_ARGS__)
-
-#define ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_EX(name, domain, startver, endver, type, provider, builder, ...)                      \
-  class ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_CLASS_NAME(provider, domain, startver, endver, type, name);                           \
-  template <>                                                                                                                      \
-  KernelCreateInfo                                                                                                                 \
-  BuildKernelCreateInfo<ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_CLASS_NAME(provider, domain, startver, endver,                        \
-                                                                        type, name)>() {                                           \
-    return KernelCreateInfo(                                                                                                       \
-        builder.SetName(#name)                                                                                                     \
-            .SetDomain(domain)                                                                                                     \
-            .SinceVersion(startver, endver)                                                                                        \
-            .Provider(provider)                                                                                                    \
-            .Build(),                                                                                                              \
-        static_cast<KernelCreatePtrFn>([](FuncManager&, const OpKernelInfo& info, std::unique_ptr<OpKernel>& out) -> Status { out = std::make_unique<__VA_ARGS__>(info); return Status::OK(); })); \
-  }
-
-#define ONNX_OPERATOR_VERSIONED_TWO_TYPED_KERNEL_CLASS_NAME(provider, domain, startver, endver, type1, type2, name) \
-  provider##_##name##_##domain##_ver##startver##_##endver##_##type1##_##type2
-
-#define ONNX_OPERATOR_VERSIONED_TWO_TYPED_KERNEL_EX(name, domain, startver, endver, type1, type2,                                  \
-                                                    provider, builder, ...)                                                        \
-  class ONNX_OPERATOR_VERSIONED_TWO_TYPED_KERNEL_CLASS_NAME(provider, domain, startver, endver, type1, type2, name);               \
-  template <>                                                                                                                      \
-  KernelCreateInfo                                                                                                                 \
-  BuildKernelCreateInfo<ONNX_OPERATOR_VERSIONED_TWO_TYPED_KERNEL_CLASS_NAME(provider, domain, startver, endver,                    \
-                                                                            type1, type2, name)>() {                               \
-    return KernelCreateInfo(                                                                                                       \
-        builder.SetName(#name)                                                                                                     \
-            .SetDomain(domain)                                                                                                     \
-            .SinceVersion(startver, endver)                                                                                        \
-            .Provider(provider)                                                                                                    \
-            .Build(),                                                                                                              \
-        static_cast<KernelCreatePtrFn>([](FuncManager&, const OpKernelInfo& info, std::unique_ptr<OpKernel>& out) -> Status { out = std::make_unique<__VA_ARGS__>(info); return Status::OK(); })); \
-  }
-
-template <typename... Types>
-struct BuildKernelDefConstraintsImpl {
-  std::vector<MLDataType> operator()() const {
-    return {DataTypeImpl::GetTensorType<Types>()...};
-  }
-};
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-template <typename... Types>
-struct BuildKernelDefSparseConstraintsImpl {
-  std::vector<MLDataType> operator()() const {
-    return {DataTypeImpl::GetSparseTensorType<Types>()...};
-  }
-};
-#endif
-
-// Use within macro definitions to create a custom vector of constraints.
-// Example: #define REG_KERNEL(OP, VERSION, KERNEL_CLASS, Type, ...)
-//  .TypeConstraint("T", BuildKernelDefConstraints<Type, __VA_ARGS_>())
-template <typename... Types>
-inline std::vector<MLDataType> BuildKernelDefConstraints() {
-  return BuildKernelDefConstraintsImpl<Types...>{}();
-}
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-template <typename... Types>
-inline std::vector<MLDataType> BuildKernelDefSparseConstraints() {
-  return BuildKernelDefSparseConstraintsImpl<Types...>{}();
-}
-#endif
-
-// version of BuildKernelDefConstraints() which takes a type list
-template <typename L>
-inline std::vector<MLDataType> BuildKernelDefConstraintsFromTypeList() {
-  return boost::mp11::mp_apply<BuildKernelDefConstraintsImpl, L>{}();
-}
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-template <typename L>
-inline std::vector<MLDataType> BuildKernelDefSparseConstraintsFromTypeList() {
-  return boost::mp11::mp_apply<BuildKernelDefSparseConstraintsImpl, L>{}();
-}
-#endif
-
-}  // namespace onnxruntime
-
-#ifndef SHARED_PROVIDER
-#include "core/framework/op_kernel_context.h"
-#endif

arm64-v8a/include/onnxruntime/core/framework/op_kernel_context.h

@@ -1,237 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-namespace onnxruntime {
-class IExecutionFrame;
-class Stream;
-namespace concurrency {
-class ThreadPool;
-}
-
-class OpKernelContext {
- public:
-  using ArgMap = std::unordered_map<std::string, size_t>;
-
-  OpKernelContext(_Inout_ IExecutionFrame* frame, _In_ const OpKernel* kernel,
-                  _In_ Stream* stream,
-                  _In_opt_ concurrency::ThreadPool* threadpool, _In_ const logging::Logger& logger);
-
-  virtual ~OpKernelContext() = default;
-
-  /**
-  Return the number of inputs for a variadic argument.
-  @param arg_num The operator argument number.
-  @returns Number of inputs the argument has.
-  */
-  virtual int NumVariadicInputs(size_t arg_num) const;
-
-  virtual MLDataType InputType(int index) const;
-  virtual MLDataType OutputType(int index) const;
-
-  const OrtValue* GetInputOrtValue(int index) const {
-    return GetInputMLValue(index);
-  }
-
-  template <typename T>
-  const T* Input(int index) const {
-    const OrtValue* p_ml_value = GetInputMLValue(index);
-    ORT_TRY {
-      return p_ml_value ? &(p_ml_value->Get<T>()) : nullptr;
-    }
-    ORT_CATCH(const std::exception& /*e*/) {
-      ORT_THROW("Missing Input: " + kernel_->Node().InputDefs()[index]->Name());
-    }
-  }
-
-  // Fetch a required input, enforcing that it is present.
-  template <typename T>
-  const T& RequiredInput(int index) const {
-    const T* input_ptr = Input<T>(index);
-    ORT_ENFORCE(input_ptr, "Required input at index ", index, " is not present.");
-    return *input_ptr;
-  }
-
-  // Fetch output (non-tensor) with specified index.
-  template <typename T>
-  T* Output(int index) {
-    if (index < 0 || index >= OutputCount())
-      return nullptr;
-
-    OrtValue* p_ml_value = GetOrCreateOutputMLValue(index);
-    return p_ml_value ? p_ml_value->GetMutable<T>() : nullptr;
-  }
-
-  // In the case that memory allocation has not been done for an output tensor,
-  // The memory allocation will be done on-the-fly with given tensor shape.
-  // Return nullptr if the output is an unused optional output.
-  Tensor* Output(int index, const TensorShape& shape);
-  Tensor* Output(int index, const std::vector<int64_t>& shape);
-  Tensor* Output(int index, const std::initializer_list<int64_t>& shape);
-
-  // Fetch a required tensor output, enforcing that it is present.
-  Tensor& RequiredOutput(int index, const TensorShape& shape) {
-    Tensor* output_ptr = Output(index, shape);
-    ORT_ENFORCE(output_ptr, "Required output at index ", index, " is not present.");
-    return *output_ptr;
-  }
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-  // Fetch a sparse-tensor output corresponding to the specified index.
-  // shape must specify the shape of the underlying dense-tensor.
-  // Memory allocation for the output may happen when this method is invoked,
-  // unless static optimization pre-allocates it.
-  SparseTensor* OutputSparse(int index, const TensorShape& shape);
-#endif
-
-#if !defined(DISABLE_OPTIONAL_TYPE)
-  // Use this API to output a "None" of a specific type (e.g. Tensor) at specified index
-  template <typename T>
-  void OutputOptionalWithoutData(int index) {
-    auto* output_ort_value = GetOutputMLValue(index);
-
-    auto type = DataTypeImpl::GetType<T>();
-
-    output_ort_value->Init(nullptr,  // This OrtValue is "None" and has no data
-                           type,
-                           type->GetDeleteFunc());
-  }
-#endif
-
-  // Retrieve indexed shape obtained from memory planning before actual
-  // computation. If the indexed shape cannot be inferred, this function returns
-  // false.
-  virtual bool TryGetInferredInputShape(int index, TensorShape& shape) const;
-
-  // Retrieve indexed shape obtained from memory planning before actual
-  // computation. If the indexed shape cannot be inferred, this function returns
-  // false.
-  virtual bool TryGetInferredOutputShape(int index, TensorShape& shape) const;
-
-  const logging::Logger& Logger() const {
-    return *logger_;
-  }
-
-  // always >= 0
-  virtual int InputCount() const {
-    return static_cast<int>(kernel_->Node().InputDefs().size());
-  }
-
-  // always >= 0
-  virtual int ImplicitInputCount() const {
-    return static_cast<int>(kernel_->Node().ImplicitInputDefs().size());
-  }
-
-  // always >= 0
-  virtual int OutputCount() const {
-    return static_cast<int>(kernel_->Node().OutputDefs().size());
-  }
-
-  /**
-   Return an allocator on device 0, with memtype of OrtMemTypeDefault.
-   @remarks Use SafeInt when calculating the size of memory to allocate using AllocatorPtr->Alloc.
-   */
-  [[nodiscard]] virtual Status GetTempSpaceAllocator(AllocatorPtr* output) const;
-
-  /**
-   Return the allocator associated with the CPU EP with memtype of OrtMemTypeDefault.
-   @remarks Use SafeInt when calculating the size of memory to allocate using AllocatorPtr->Alloc.
-   */
-  [[nodiscard]] Status GetTempSpaceCPUAllocator(AllocatorPtr* output) const;
-
-  /**
-  Return the device id that current kernel runs on.
-  */
-  virtual int GetDeviceId() const {
-    return kernel_->Info().GetExecutionProvider()->GetDeviceId();
-  }
-
-  /**
-  Return the compute stream associated with the EP that the kernel is partitioned to.
-  For EPs that do not have a compute stream (e.g. CPU EP), a nullptr is returned.
-  */
-  [[nodiscard]] virtual Stream* GetComputeStream() const {
-    return stream_;
-  }
-
-  /**
-  Returns the opset domain of the underlying kernel
-  **/
-  const std::string& GetOpDomain() const;
-
-  /**
-  Returns the optype of the underlying kernel
-  **/
-  const std::string& GetOpType() const;
-
-  /**
-  Returns the node name of the underlying kernel
-  **/
-  const std::string& GetNodeName() const;
-
-  /**
-  Returns the intra-op threadpool, if available.
-  */
-  _Ret_maybenull_ onnxruntime::concurrency::ThreadPool* GetOperatorThreadPool() const { return threadpool_; }
-
-  /**
-  Returns whether deterministic computation is preferred.
-  */
-  virtual bool GetUseDeterministicCompute() const {
-    return true;
-  }
-
- protected:
-  OpKernelContext(concurrency::ThreadPool* threadpool, const logging::Logger& logger, Stream* stream);
-
-  onnxruntime::NodeIndex GetNodeIndex() const;
-
-  virtual const OrtValue* GetInputMLValue(int index) const;
-  const OrtValue* GetImplicitInputMLValue(int index) const;
-  OrtValue* GetOutputMLValue(int index);
-
-#ifdef ENABLE_ATEN
-  Status SetOutputMLValue(int index, const OrtValue& ort_value);
-#endif
-
-  // Creates the OrtValue* based on the shape, if it does not exist
-  virtual OrtValue* OutputMLValue(int index, const TensorShape& shape);
-
-  virtual OrtValue* GetOrCreateOutputMLValue(int index);
-
- private:
-  ORT_DISALLOW_COPY_AND_ASSIGNMENT(OpKernelContext);
-  int GetInputArgIndex(int index) const;
-  int GetImplicitInputArgIndex(int index) const;
-  int GetOutputArgIndex(int index) const;
-
-  IExecutionFrame* const execution_frame_{};
-  const OpKernel* const kernel_{};
-  concurrency::ThreadPool* const threadpool_{};
-  const logging::Logger* const logger_{};
-
-  // The argument starting index in ExecutionFrame.
-  int node_input_start_index_{-1};
-  int node_implicit_input_start_index_{-1};
-  int node_output_start_index_{-1};
-
-  Stream* stream_;
-};
-
-// Fetching output tensor without shape is not allowed except when it already exists
-template <>
-inline Tensor* OpKernelContext::Output<Tensor>(int index) {
-  OrtValue* p_ml_value = GetOutputMLValue(index);
-  ORT_ENFORCE(p_ml_value, "Please fetch output tensor with specified shape.");
-  return p_ml_value->GetMutable<Tensor>();
-}
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-template <>
-inline SparseTensor* OpKernelContext::Output<SparseTensor>(int index) {
-  OrtValue* p_ml_value = GetOutputMLValue(index);
-  ORT_ENFORCE(p_ml_value, "Please fetch output sparse tensor with specified shape.");
-  return p_ml_value->GetMutable<SparseTensor>();
-}
-#endif
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/op_kernel_info.h

@@ -1,63 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "core/framework/execution_provider.h"
-#include "core/framework/kernel_def_builder.h"
-#include "core/framework/ort_value.h"
-#include "core/framework/op_node_proto_helper.h"
-#include "core/graph/graph_viewer.h"
-#include "core/common/gsl.h"
-
-namespace onnxruntime {
-
-class OrtValueNameIdxMap;
-class FuncManager;
-class DataTransferManager;
-struct AllocPlanPerValue;
-
-// A very light-weight class, which works as an aggregated
-// view of all data needed for constructing a Kernel instance.
-// NOTE: it does not own/hold any objects.
-class OpKernelInfo : public OpNodeProtoHelper<ProtoHelperNodeContext> {
- public:
-  explicit OpKernelInfo(const onnxruntime::Node& node,
-                        const KernelDef& kernel_def,
-                        const IExecutionProvider& execution_provider,
-                        const std::unordered_map<int, OrtValue>& constant_initialized_tensors,
-                        const OrtValueNameIdxMap& mlvalue_name_idx_map,
-                        const DataTransferManager& data_transfer_mgr);
-
-  OpKernelInfo(const OpKernelInfo& other);
-
-  const OrtMemoryInfo& GetMemoryInfo(OrtMemType mem_type) const;
-
-  AllocatorPtr GetAllocator(OrtMemType mem_type) const;
-
-  const KernelDef& GetKernelDef() const;
-
-  const IExecutionProvider* GetExecutionProvider() const noexcept;
-
-  const DataTransferManager& GetDataTransferManager() const noexcept;
-
-  const onnxruntime::Node& node() const noexcept;
-
-  bool TryGetConstantInput(int input_index, const Tensor** constant_input_value) const;
-
- private:
-  ORT_DISALLOW_MOVE(OpKernelInfo);
-  ORT_DISALLOW_ASSIGNMENT(OpKernelInfo);
-
-  const onnxruntime::Node& node_;
-  const KernelDef& kernel_def_;
-  // For non cpu/cuda case, this pointer should be set so that function kernel
-  // will delegate kernel compute call to <execution_provider> compute call.
-  gsl::not_null<const ::onnxruntime::IExecutionProvider*> execution_provider_;
-  const std::unordered_map<int, OrtValue>& constant_initialized_tensors_;
-  const OrtValueNameIdxMap& ort_value_name_idx_map_;
-  const DataTransferManager& data_transfer_mgr_;
-  ProtoHelperNodeContext proto_helper_context_;
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/op_node_proto_helper.h

@@ -1,167 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#ifndef SHARED_PROVIDER
-#include "core/common/status.h"
-#include "core/framework/tensor_shape.h"
-#include "core/graph/graph_viewer.h"
-#include "core/common/gsl.h"
-#endif
-
-#ifdef __has_attribute
-#define ORT_HAVE_ATTRIBUTE(x) __has_attribute(x)
-#else
-#define ORT_HAVE_ATTRIBUTE(x) 0
-#endif
-
-#if ORT_HAVE_ATTRIBUTE(nodiscard)
-#define MUST_USE_RESULT [[nodiscard]]
-#elif defined(__clang__) && ORT_HAVE_ATTRIBUTE(warn_unused_result)
-#define MUST_USE_RESULT __attribute__((warn_unused_result))
-#else
-#define MUST_USE_RESULT
-#endif
-
-class IMLOpKernel;
-
-namespace onnxruntime {
-
-/**
-   A set of wrappers with common signatures for use with both OpKernelInfo
-   (as its base class) and InferenceContext.  Used by ABI kernels for both
-   shape / type inference and kernel construction
-*/
-template <class Impl_t>
-class OpNodeProtoHelper {
- public:
-  explicit OpNodeProtoHelper(const Impl_t* impl) : impl_(impl) {}
-
-  /**
-     Get a single attribute
-     Call this function for a required attribute or when a default value for an optional attribute is specified in the op schema
-  */
-  template <typename T>
-  MUST_USE_RESULT Status GetAttr(const std::string& name, T* value) const;
-
-  /**
-     Get a single attribute
-     Call this function only when a default value for an optional attribute isn't specified in the op schema
-  */
-  template <typename T>
-  T GetAttrOrDefault(const std::string& name, const T& default_value) const {
-    T tmp;
-    return GetAttr<T>(name, &tmp).IsOK() ? tmp : default_value;
-  }
-
-  /**
-     Get a single attribute
-     Call this function only when a default value for an optional attribute isn't specified in the op schema
-  */
-  template <typename T>
-  void GetAttrOrDefault(const std::string& name, T* value, const T& default_value) const {
-    if (!GetAttr<T>(name, value).IsOK())
-      *value = default_value;
-  }
-
-  /**
-     Get repeated attributes
-     Call this function only when a default value for an optional attribute isn't specified in the op schema
-  */
-  template <typename T>
-  MUST_USE_RESULT std::vector<T> GetAttrsOrDefault(const std::string& name, const std::vector<T>& default_value = std::vector<T>{}) const {
-    std::vector<T> tmp;
-    return GetAttrs<T>(name, tmp).IsOK() ? tmp : default_value;
-  }
-
-  /// <summary>
-  /// Return a gsl::span that points to an array of primitive types held by AttributeProto
-  /// This function allows to avoid copying big attributes locally into a kernel and operate on
-  /// AttributeProto data directly.
-  ///
-  ///  Does not apply to strings, Tensors and Sparse Tensors that require special treatment.
-  /// </summary>
-  /// <typeparam name="T">Primitive type contained in the array</typeparam>
-  /// <param name="name">Attribute name</param>
-  /// <param name="values">Attribute data in a span, out parameter</param>
-  /// <returns>Status</returns>
-  template <typename T>
-  MUST_USE_RESULT Status GetAttrsAsSpan(const std::string& name, gsl::span<const T>& values) const;
-
-  MUST_USE_RESULT Status GetAttrs(const std::string& name, TensorShapeVector& out) const;
-
-  MUST_USE_RESULT TensorShapeVector GetAttrsOrDefault(const std::string& name, const TensorShapeVector& default_value = TensorShapeVector{}) const {
-    TensorShapeVector tmp;
-    return GetAttrs(name, tmp).IsOK() ? tmp : default_value;
-  }
-
-  /**
-     Get repeated attributes
-  */
-  template <typename T>
-  MUST_USE_RESULT Status GetAttrs(const std::string& name, std::vector<T>& values) const;
-
-  template <typename T>
-  MUST_USE_RESULT Status GetAttrs(const std::string& name, gsl::span<T> values) const;
-
-  MUST_USE_RESULT Status GetAttrsStringRefs(const std::string& name,
-                                            std::vector<std::reference_wrapper<const std::string>>& refs) const;
-
-  uint32_t GetPrimitiveAttrElementCount(ONNX_NAMESPACE::AttributeProto_AttributeType type,
-                                        const std::string& name) const noexcept;
-
-  bool HasPrimitiveAttribute(ONNX_NAMESPACE::AttributeProto_AttributeType type,
-                             const std::string& name) const noexcept;
-
-  uint32_t GetInputCount() const {
-    return gsl::narrow_cast<uint32_t>(impl_->getNumInputs());
-  }
-
-  uint32_t GetOutputCount() const {
-    return gsl::narrow_cast<uint32_t>(impl_->getNumOutputs());
-  }
-
-  const ONNX_NAMESPACE::TypeProto* GetInputType(size_t index) const {
-    return impl_->getInputType(index);
-  }
-
-  const ONNX_NAMESPACE::TypeProto* GetOutputType(size_t index) const {
-    // Work around lack of a const method from the onnx InferenceContext interface
-    return const_cast<Impl_t*>(impl_)->getOutputType(index);
-  }
-
-  // Try to query an attribute, returning nullptr if it doesn't exist
-  const ONNX_NAMESPACE::AttributeProto* TryGetAttribute(const std::string& name) const {
-    return impl_->getAttribute(name);
-  }
-
-  const ONNX_NAMESPACE::AttributeProto* GetAttribute(const std::string& name) const {
-    const ONNX_NAMESPACE::AttributeProto* attr = TryGetAttribute(name);
-    ORT_ENFORCE(attr != nullptr);
-    return attr;
-  }
-
- private:
-  OpNodeProtoHelper() = delete;
-  const Impl_t* impl_ = nullptr;
-};
-
-// The methods on the following class are called by OpNodeProtoHelper, implementing
-// the same signatures as InferenceContext other than const-ness.
-class ProtoHelperNodeContext {
- public:
-  explicit ProtoHelperNodeContext(const onnxruntime::Node& node) : node_(node) {}
-  ProtoHelperNodeContext() = delete;
-
-  const ONNX_NAMESPACE::AttributeProto* getAttribute(const std::string& name) const;
-  size_t getNumInputs() const;
-  const ONNX_NAMESPACE::TypeProto* getInputType(size_t index) const;
-  size_t getNumOutputs() const;
-  const ONNX_NAMESPACE::TypeProto* getOutputType(size_t index) const;
-
- private:
-  const onnxruntime::Node& node_;
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/ort_value.h

@@ -1,123 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-#ifndef SHARED_PROVIDER
-#include "core/common/common.h"
-#include "core/common/exceptions.h"
-#include "core/framework/allocator.h"
-#include "core/framework/data_types.h"
-#include "core/framework/tensor.h"
-
-namespace onnxruntime {
-#if !defined(DISABLE_SPARSE_TENSORS)
-class SparseTensor;
-#endif
-class TensorSeq;
-}  // namespace onnxruntime
-
-#endif
-
-/**
-   Represents both tensors and non-tensors.
-*/
-struct OrtValue {
- public:
-  OrtValue() : data_(nullptr) {}
-  ~OrtValue() = default;
-
-  OrtValue(void* pData, onnxruntime::MLDataType type, onnxruntime::DeleteFunc deleter) {
-    Init(pData, type, deleter);
-  }
-
-  void Init(void* pData, onnxruntime::MLDataType type, onnxruntime::DeleteFunc deleter) {
-    data_.reset(pData, deleter);
-    type_ = type;
-  }
-
-  void Init(void* pData, onnxruntime::MLDataType type, const std::function<void(void*)>& deleter) {
-    data_.reset(pData, deleter);
-    type_ = type;
-  }
-
-  bool IsAllocated() const {
-    return data_ && type_;
-  }
-
-  template <typename T>
-  const T& Get() const {
-    ORT_ENFORCE(onnxruntime::DataTypeImpl::GetType<T>() == type_, onnxruntime::DataTypeImpl::GetType<T>(), " != ", type_);
-    return *static_cast<T*>(data_.get());
-  }
-
-  // May return nullptr, if this OrtValue is an optional type and it is "None".
-  template <typename T>
-  T* GetMutable() {
-    ORT_ENFORCE(onnxruntime::DataTypeImpl::GetType<T>() == type_, onnxruntime::DataTypeImpl::GetType<T>(), " != ", type_);
-    return static_cast<T*>(data_.get());
-  }
-
-  bool IsTensor() const noexcept {
-    return (type_ != nullptr && type_->IsTensorType());
-  }
-
-  bool IsTensorSequence() const noexcept {
-    return (type_ != nullptr && type_->IsTensorSequenceType());
-  }
-
-  bool IsSparseTensor() const {
-#if !defined(DISABLE_SPARSE_TENSORS)
-    return (type_ != nullptr && type_->IsSparseTensorType());
-#else
-    ORT_THROW("Sparse tensor is not supported in this build.");
-#endif
-  }
-
-  onnxruntime::MLDataType Type() const {
-    return type_;
-  }
-
- private:
-  std::shared_ptr<void> data_;
-  onnxruntime::MLDataType type_{nullptr};
-};
-
-template <>
-inline const onnxruntime::Tensor& OrtValue::Get<onnxruntime::Tensor>() const {
-  ORT_ENFORCE(IsTensor(), "Trying to get a Tensor, but got: ", onnxruntime::DataTypeImpl::ToString(type_));
-  return *static_cast<onnxruntime::Tensor*>(data_.get());
-}
-
-template <>
-inline onnxruntime::Tensor* OrtValue::GetMutable<onnxruntime::Tensor>() {
-  ORT_ENFORCE(IsTensor(), "Trying to get a Tensor, but got: ", onnxruntime::DataTypeImpl::ToString(type_));
-  return static_cast<onnxruntime::Tensor*>(data_.get());
-}
-
-template <>
-inline const onnxruntime::TensorSeq& OrtValue::Get<onnxruntime::TensorSeq>() const {
-  ORT_ENFORCE(IsTensorSequence(), "Trying to get a TensorSeq, but got: ", onnxruntime::DataTypeImpl::ToString(type_));
-  return *static_cast<onnxruntime::TensorSeq*>(data_.get());
-}
-
-template <>
-inline onnxruntime::TensorSeq* OrtValue::GetMutable<onnxruntime::TensorSeq>() {
-  ORT_ENFORCE(IsTensorSequence(), "Trying to get a TensorSeq, but got: ", onnxruntime::DataTypeImpl::ToString(type_));
-  return static_cast<onnxruntime::TensorSeq*>(data_.get());
-}
-
-#if !defined(DISABLE_SPARSE_TENSORS)
-template <>
-inline const onnxruntime::SparseTensor& OrtValue::Get<onnxruntime::SparseTensor>() const {
-  ORT_ENFORCE(IsSparseTensor(), "Trying to get a SparseTensor, but got: ", onnxruntime::DataTypeImpl::ToString(type_));
-  return *static_cast<onnxruntime::SparseTensor*>(data_.get());
-}
-
-template <>
-inline onnxruntime::SparseTensor* OrtValue::GetMutable<onnxruntime::SparseTensor>() {
-  ORT_ENFORCE(IsSparseTensor(), "Trying to get a SparseTensor, but got: ", onnxruntime::DataTypeImpl::ToString(type_));
-  return static_cast<onnxruntime::SparseTensor*>(data_.get());
-}
-#endif

arm64-v8a/include/onnxruntime/core/framework/ortdevice.h

@@ -1,74 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <sstream>
-
-// Struct to represent a physical device.
-struct OrtDevice {
-  using DeviceType = int8_t;
-  using MemoryType = int8_t;
-  using DeviceId = int16_t;
-
-  // Pre-defined device types.
-  static const DeviceType CPU = 0;
-  static const DeviceType GPU = 1;  // Nvidia or AMD
-  static const DeviceType FPGA = 2;
-  static const DeviceType NPU = 3;  // Ascend
-
-  struct MemType {
-    // Pre-defined memory types.
-    static const MemoryType DEFAULT = 0;
-    static const MemoryType CUDA_PINNED = 1;
-    static const MemoryType HIP_PINNED = 2;
-    static const MemoryType CANN_PINNED = 3;
-  };
-
-  constexpr OrtDevice(DeviceType device_type_, MemoryType memory_type_, DeviceId device_id_)
-      : device_type(device_type_),
-        memory_type(memory_type_),
-        device_id(device_id_) {}
-
-  constexpr OrtDevice() : OrtDevice(CPU, MemType::DEFAULT, 0) {}
-
-  DeviceType Type() const {
-    return device_type;
-  }
-
-  MemoryType MemType() const {
-    return memory_type;
-  }
-
-  DeviceId Id() const {
-    return device_id;
-  }
-
-  std::string ToString() const {
-    std::ostringstream ostr;
-    ostr << "Device:["
-         << "DeviceType:" << static_cast<int>(device_type)
-         << " MemoryType:" << static_cast<int>(memory_type)
-         << " DeviceId:" << device_id
-         << "]";
-    return ostr.str();
-  }
-
- private:
-  // Device type.
-  DeviceType device_type;
-
-  // Memory type.
-  MemoryType memory_type;
-
-  // Device index.
-  DeviceId device_id;
-};
-
-inline bool operator==(const OrtDevice& left, const OrtDevice& other) {
-  return left.Id() == other.Id() && left.MemType() == other.MemType() && left.Type() == other.Type();
-}
-
-inline bool operator!=(const OrtDevice& left, const OrtDevice& other) {
-  return !(left == other);
-}

arm64-v8a/include/onnxruntime/core/framework/ortmemoryinfo.h

@@ -1,87 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string_view>
-
-#include "core/common/hash_combine.h"
-
-struct OrtMemoryInfo {
-  OrtMemoryInfo() = default;  // to allow default construction of Tensor
-
-  // use string for name, so we could have customized allocator in execution provider.
-  const char* name = nullptr;
-  int id = -1;
-  OrtMemType mem_type = OrtMemTypeDefault;
-  OrtAllocatorType alloc_type = OrtInvalidAllocator;
-  OrtDevice device;
-
-  constexpr OrtMemoryInfo(const char* name_, OrtAllocatorType type_, OrtDevice device_ = OrtDevice(), int id_ = 0,
-                          OrtMemType mem_type_ = OrtMemTypeDefault)
-#if ((defined(__GNUC__) && __GNUC__ > 4) || defined(__clang__))
-      // this causes a spurious error in CentOS gcc 4.8 build so disable if GCC version < 5
-      __attribute__((nonnull))
-#endif
-      : name(name_),
-        id(id_),
-        mem_type(mem_type_),
-        alloc_type(type_),
-        device(device_) {
-  }
-
-  // To make OrtMemoryInfo become a valid key in std map
-  bool operator<(const OrtMemoryInfo& other) const {
-    if (alloc_type != other.alloc_type)
-      return alloc_type < other.alloc_type;
-    if (mem_type != other.mem_type)
-      return mem_type < other.mem_type;
-    if (id != other.id)
-      return id < other.id;
-
-    return strcmp(name, other.name) < 0;
-  }
-
-  // This is to make OrtMemoryInfo a valid key in hash tables
-  // we ignore device id
-  size_t Hash() const {
-    auto h = std::hash<int>()(alloc_type);
-    onnxruntime::HashCombine(mem_type, h);
-    onnxruntime::HashCombine(id, h);
-    onnxruntime::HashCombine<std::string_view>(name, h);
-    return h;
-  }
-
-  std::string ToString() const {
-    std::ostringstream ostr;
-    ostr << "OrtMemoryInfo:["
-         << "name:" << name
-         << " id:" << id
-         << " OrtMemType:" << mem_type
-         << " OrtAllocatorType:" << alloc_type
-         << " " << device.ToString()
-         << "]";
-    return ostr.str();
-  }
-};
-
-// Required by hash tables
-inline bool operator==(const OrtMemoryInfo& left, const OrtMemoryInfo& other) {
-  return left.mem_type == other.mem_type &&
-         left.alloc_type == other.alloc_type &&
-         left.id == other.id &&
-         strcmp(left.name, other.name) == 0;
-}
-
-inline bool operator!=(const OrtMemoryInfo& lhs, const OrtMemoryInfo& rhs) { return !(lhs == rhs); }
-
-std::ostream& operator<<(std::ostream& out, const OrtMemoryInfo& info);
-
-namespace std {
-template<>
-struct hash<OrtMemoryInfo> {
-  size_t operator()(const OrtMemoryInfo& i) const {
-    return i.Hash();
-  }
-};
-}

arm64-v8a/include/onnxruntime/core/framework/provider_options.h

@@ -1,18 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace onnxruntime {
-
-// data types for execution provider options
-
-using ProviderOptions = std::unordered_map<std::string, std::string>;
-using ProviderOptionsVector = std::vector<ProviderOptions>;
-using ProviderOptionsMap = std::unordered_map<std::string, ProviderOptions>;
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/provider_options_utils.h

@@ -1,164 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <algorithm>
-#include <functional>
-#include <type_traits>
-#include <unordered_map>
-#include <vector>
-
-#include "core/common/common.h"
-#include "core/common/parse_string.h"
-#include "core/framework/provider_options.h"
-
-namespace onnxruntime {
-
-template <typename TEnum>
-using EnumNameMapping = std::vector<std::pair<TEnum, std::string>>;
-
-/**
- * Given a mapping and an enumeration value, gets the corresponding name.
- */
-template <typename TEnum>
-Status EnumToName(const EnumNameMapping<TEnum>& mapping, TEnum value, std::string& name) {
-  const auto it = std::find_if(
-      mapping.begin(), mapping.end(),
-      [&value](const std::pair<TEnum, std::string>& entry) {
-        return entry.first == value;
-      });
-  ORT_RETURN_IF(
-      it == mapping.end(),
-      "Failed to map enum value to name: ", static_cast<typename std::underlying_type<TEnum>::type>(value));
-  name = it->second;
-  return Status::OK();
-}
-
-template <typename TEnum>
-std::string EnumToName(const EnumNameMapping<TEnum>& mapping, TEnum value) {
-  std::string name;
-  ORT_THROW_IF_ERROR(EnumToName(mapping, value, name));
-  return name;
-}
-
-/**
- * Given a mapping and a name, gets the corresponding enumeration value.
- */
-template <typename TEnum>
-Status NameToEnum(
-    const EnumNameMapping<TEnum>& mapping, const std::string& name, TEnum& value) {
-  const auto it = std::find_if(
-      mapping.begin(), mapping.end(),
-      [&name](const std::pair<TEnum, std::string>& entry) {
-        return entry.second == name;
-      });
-  ORT_RETURN_IF(
-      it == mapping.end(),
-      "Failed to map enum name to value: ", name);
-  value = it->first;
-  return Status::OK();
-}
-
-template <typename TEnum>
-TEnum NameToEnum(const EnumNameMapping<TEnum>& mapping, const std::string& name) {
-  TEnum value;
-  ORT_THROW_IF_ERROR(NameToEnum(mapping, name, value));
-  return value;
-}
-
-class ProviderOptionsParser {
- public:
-  /**
-   * Adds a parser for a particular provider option value.
-   *
-   * @param name The provider option name.
-   * @param value_parser An object that parses the option value.
-   *        It should be callable with the following signature and return
-   *        whether the parsing was successful:
-   *            Status value_parser(const std::string&)
-   *
-   * @return The current ProviderOptionsParser instance.
-   */
-  template <typename ValueParserType>
-  ProviderOptionsParser& AddValueParser(
-      const std::string& name, ValueParserType value_parser) {
-    ORT_ENFORCE(
-        value_parsers_.emplace(name, ValueParser{value_parser}).second,
-        "Provider option \"", name, "\" already has a value parser.");
-    return *this;
-  }
-
-  /**
-   * Adds a parser for a particular provider option value which converts a
-   * value to the right type and assigns it to the given reference.
-   *
-   * IMPORTANT: This function stores a reference to the destination variable.
-   * The caller must ensure that the reference is valid when Parse() is called!
-   *
-   * @param name The provider option name.
-   * @param dest The destination variable reference.
-   *
-   * @return The current ProviderOptionsParser instance.
-   */
-  template <typename ValueType>
-  ProviderOptionsParser& AddAssignmentToReference(
-      const std::string& name, ValueType& dest) {
-    return AddValueParser(
-        name,
-        [&dest](const std::string& value_str) -> Status {
-          return ParseStringWithClassicLocale(value_str, dest);
-        });
-  }
-
-  /**
-   * Adds a parser for a particular provider option value which maps an
-   * enumeration name to a value and assigns it to the given reference.
-   *
-   * IMPORTANT: This function stores references to the mapping and destination
-   * variables. The caller must ensure that the references are valid when
-   * Parse() is called!
-   *
-   * @param name The provider option name.
-   * @param mapping The enumeration value to name mapping.
-   * @param dest The destination variable reference.
-   *
-   * @return The current ProviderOptionsParser instance.
-   */
-  template <typename EnumType>
-  ProviderOptionsParser& AddAssignmentToEnumReference(
-      const std::string& name, const EnumNameMapping<EnumType>& mapping, EnumType& dest) {
-    return AddValueParser(
-        name,
-        [&mapping, &dest](const std::string& value_str) -> Status {
-          return NameToEnum(mapping, value_str, dest);
-        });
-  }
-
-  /**
-   * Parses the given provider options.
-   */
-  Status Parse(const ProviderOptions& options) const {
-    for (const auto& option : options) {
-      const auto& name = option.first;
-      const auto& value_str = option.second;
-      const auto value_parser_it = value_parsers_.find(name);
-      ORT_RETURN_IF(
-          value_parser_it == value_parsers_.end(),
-          "Unknown provider option: \"", name, "\".");
-
-      const auto parse_status = value_parser_it->second(value_str);
-      ORT_RETURN_IF_NOT(
-          parse_status.IsOK(),
-          "Failed to parse provider option \"", name, "\": ", parse_status.ErrorMessage());
-    }
-
-    return Status::OK();
-  }
-
- private:
-  using ValueParser = std::function<Status(const std::string&)>;
-  std::unordered_map<std::string, ValueParser> value_parsers_;
-};
-
-}  // namespace onnxruntime

arm64-v8a/include/onnxruntime/core/framework/provider_shutdown.h

@@ -1,8 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-namespace onnxruntime {
-void UnloadSharedProviders();
-}

arm64-v8a/include/onnxruntime/core/framework/run_options.h

@@ -1,49 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <string>
-#include <atomic>
-#include "core/session/onnxruntime_c_api.h"
-#include "core/framework/config_options.h"
-
-/**
- * Configuration information for a Run call.
- */
-struct OrtRunOptions {
-  /// Log severity.  See https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h
-  /// Default = -1 (use the log severity from the InferenceSession that the Run is for).
-  int run_log_severity_level = -1;
-  int run_log_verbosity_level = 0;  ///< VLOG level if debug build and run_log_severity_level is 0 (VERBOSE).
-  std::string run_tag;              ///< A tag for the Run() calls using this.
-
-  // Set to 'true' to ensure the termination of all the outstanding Run() calls
-  // that use this OrtRunOptions instance. Some of the outstanding Run() calls may
-  // be forced to terminate with an error status.
-  bool terminate = false;
-
-  // Set to 'true' to run only the nodes from feeds to required fetches.
-  // So it is possible that only some of the nodes are executed.
-  bool only_execute_path_to_fetches = false;
-
-#ifdef ENABLE_TRAINING
-  // Used by onnxruntime::training::TrainingSession. This class is now deprecated.
-  // Delete training_mode when TrainingSession is deleted.
-  // Set to 'true' to run in training mode.
-  bool training_mode = true;
-#endif
-
-  // Stores the configurations for this run
-  // To add an configuration to this specific run, call OrtApis::AddRunConfigEntry
-  // The configuration keys and value formats are defined in
-  // /include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h
-  onnxruntime::ConfigOptions config_options;
-
-  OrtRunOptions() = default;
-  ~OrtRunOptions() = default;
-};
-
-namespace onnxruntime {
-using RunOptions = OrtRunOptions;
-}  // namespace onnxruntime