Add some device discovery support for non-Windows platforms

cmake/onnxruntime_common.cmake

@@ -14,7 +14,7 @@ set(onnxruntime_common_src_patterns
     "${ONNXRUNTIME_ROOT}/core/platform/check_intel.h"
     "${ONNXRUNTIME_ROOT}/core/platform/check_intel.cc"
     "${ONNXRUNTIME_ROOT}/core/platform/device_discovery.h"
-    "${ONNXRUNTIME_ROOT}/core/platform/device_discovery.cc"
+    "${ONNXRUNTIME_ROOT}/core/platform/device_discovery_common.cc"
     "${ONNXRUNTIME_ROOT}/core/platform/env.h"
     "${ONNXRUNTIME_ROOT}/core/platform/env.cc"
     "${ONNXRUNTIME_ROOT}/core/platform/env_time.h"
@@ -32,26 +32,45 @@ set(onnxruntime_common_src_patterns
 
 if(WIN32)
     list(APPEND onnxruntime_common_src_patterns
-         "${ONNXRUNTIME_ROOT}/core/platform/windows/*.h"
-         "${ONNXRUNTIME_ROOT}/core/platform/windows/*.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/debug_alloc.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/debug_alloc.h"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/dll_load_error.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/dll_load_error.h"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/env_time.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/env.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/env.h"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/hardware_core_enumerator.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/hardware_core_enumerator.h"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/stacktrace.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/telemetry.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/telemetry.h"
          "${ONNXRUNTIME_ROOT}/core/platform/windows/logging/*.h"
          "${ONNXRUNTIME_ROOT}/core/platform/windows/logging/*.cc"
     )
 
 else()
     list(APPEND onnxruntime_common_src_patterns
-         "${ONNXRUNTIME_ROOT}/core/platform/posix/*.h"
-         "${ONNXRUNTIME_ROOT}/core/platform/posix/*.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/posix/env_time.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/posix/env.cc"
+         "${ONNXRUNTIME_ROOT}/core/platform/posix/stacktrace.cc"
     )
 
+    if(LINUX)
+        list(APPEND onnxruntime_common_src_patterns
+             "${ONNXRUNTIME_ROOT}/core/platform/linux/cpuinfo.h"
+             "${ONNXRUNTIME_ROOT}/core/platform/linux/cpuinfo.cc"
+        )
+    endif()
+
+    # logging files
     if (onnxruntime_USE_SYSLOG)
         list(APPEND onnxruntime_common_src_patterns
             "${ONNXRUNTIME_ROOT}/core/platform/posix/logging/*.h"
             "${ONNXRUNTIME_ROOT}/core/platform/posix/logging/*.cc"
         )
     endif()
 
-    if (CMAKE_SYSTEM_NAME STREQUAL "Android")
+    if (ANDROID)
         list(APPEND onnxruntime_common_src_patterns
             "${ONNXRUNTIME_ROOT}/core/platform/android/logging/*.h"
             "${ONNXRUNTIME_ROOT}/core/platform/android/logging/*.cc"
@@ -66,6 +85,21 @@ else()
     endif()
 endif()
 
+# platform-specific device discovery files
+if (WIN32)
+    list(APPEND onnxruntime_common_src_patterns
+         "${ONNXRUNTIME_ROOT}/core/platform/windows/device_discovery.cc")
+elseif (LINUX OR ANDROID)
+    list(APPEND onnxruntime_common_src_patterns
+         "${ONNXRUNTIME_ROOT}/core/platform/linux/device_discovery.cc")
+elseif (APPLE)
+    list(APPEND onnxruntime_common_src_patterns
+         "${ONNXRUNTIME_ROOT}/core/platform/apple/device_discovery.cc")
+else()
+    list(APPEND onnxruntime_common_src_patterns
+         "${ONNXRUNTIME_ROOT}/core/platform/device_discovery_default.cc")
+endif()
+
 if(onnxruntime_target_platform STREQUAL "ARM64EC")
     if (MSVC)
         link_directories("$ENV{VCINSTALLDIR}/Tools/MSVC/$ENV{VCToolsVersion}/lib/ARM64EC")

include/onnxruntime/core/common/parse_string.h

@@ -35,13 +35,30 @@
 std::enable_if_t<detail::ParseWithFromChars<T>, bool>
 TryParseStringWithClassicLocale(std::string_view str, T& value) {
   T parsed_value{};
-  const auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), parsed_value);
 
-  if (ec != std::errc{}) {
+  std::from_chars_result conversion_result{};
+  if constexpr (std::is_integral_v<T> && std::is_unsigned_v<T>) {
+    // For unsigned integral types, also handle hex values, i.e., those beginning with "0x".
+    // TODO We could also extend this to other types. For that, we would need to handle negative values.
+    const bool has_hex_prefix = str.size() >= 2 &&
+                                str[0] == '0' &&
+                                (str[1] == 'x' || str[1] == 'X');
+
+    if (has_hex_prefix) {
+      str = str.substr(2);
+    }
+
+    const int base = has_hex_prefix ? 16 : 10;
+    conversion_result = std::from_chars(str.data(), str.data() + str.size(), parsed_value, base);
+  } else {
+    conversion_result = std::from_chars(str.data(), str.data() + str.size(), parsed_value);
+  }
+
+  if (conversion_result.ec != std::errc{}) {
     return false;
   }
 
-  if (ptr != str.data() + str.size()) {
+  if (conversion_result.ptr != str.data() + str.size()) {
     return false;
   }
 

onnxruntime/core/common/cpuid_info.cc

@@ -1,6 +1,9 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 #include "core/common/cpuid_info.h"
+
+#include <optional>
+
 #include "core/common/logging/logging.h"
 #include "core/common/logging/severity.h"
 #include "core/platform/check_intel.h"
@@ -39,6 +42,8 @@
 
 #endif  // ARM
 
+#include "core/platform/linux/cpuinfo.h"
+
 #endif  // Linux
 
 #if _WIN32
@@ -51,6 +56,14 @@
 
 #endif  // _WIN32
 
+#if defined(__APPLE__)
+#if defined(CPUIDINFO_ARCH_ARM)
+
+#include <sys/sysctl.h>
+
+#endif  // defined(CPUIDINFO_ARCH_ARM)
+#endif  // defined(__APPLE__)
+
 #if defined(CPUINFO_SUPPORTED)
 #include <cpuinfo.h>
 #if defined(CPUIDINFO_ARCH_ARM)
@@ -170,9 +183,10 @@
 
 uint32_t CPUIDInfo::GetVendorId(const std::string& vendor) {
   if (vendor == "GenuineIntel") return 0x8086;
-  if (vendor == "GenuineAMD") return 0x1022;
+  if (vendor == "AuthenticAMD") return 0x1022;
   if (vendor.find("Qualcomm") == 0) return 'Q' | ('C' << 8) | ('O' << 16) | ('M' << 24);
   if (vendor.find("NV") == 0) return 0x10DE;
+  if (vendor == "Apple") return 0x106B;
   return 0;
 }
 
@@ -181,6 +195,9 @@
 #if defined(__linux__)
 
 void CPUIDInfo::ArmLinuxInit() {
+  vendor_ = GetArmLinuxVendor();
+  vendor_id_ = GetVendorId(vendor_);
+
   // Assuming no hyper-threading, no NUMA groups
 #if defined(CPUINFO_SUPPORTED)
   if (pytorch_cpuinfo_init_) {
@@ -224,6 +241,23 @@
   }
 }
 
+std::string CPUIDInfo::GetArmLinuxVendor() {
+  std::string vendor{};
+
+  CpuInfo cpu_info{};
+  Status parse_status = ParseCpuInfoFile(cpu_info);
+  if (!parse_status.IsOK()) {
+    LOGS_DEFAULT(WARNING) << "Failed to parse /proc/cpuinfo file. Error: " << parse_status;
+  }
+
+  if (cpu_info.size() > 0) {
+    // just use the vendor from the first processor's information
+    vendor = cpu_info[0].vendor_id;
+  }
+
+  return vendor;
+}
+
 #elif defined(_WIN32)  // ^ defined(__linux__)
 
 void CPUIDInfo::ArmWindowsInit() {
@@ -334,6 +368,9 @@
 #elif defined(__APPLE__)  // ^ defined(_WIN32)
 
 void CPUIDInfo::ArmAppleInit() {
+  vendor_ = GetArmAppleVendor();
+  vendor_id_ = GetVendorId(vendor_);
+
 #if defined(CPUINFO_SUPPORTED)
   if (pytorch_cpuinfo_init_) {
     is_hybrid_ = cpuinfo_get_uarchs_count() > 1;
@@ -354,6 +391,47 @@
   }
 }
 
+std::string CPUIDInfo::GetArmAppleVendor() {
+  auto get_sysctl_value = [](const char* key) -> std::optional<std::string> {
+    size_t value_length{};
+    if (sysctlbyname(key, nullptr, &value_length, nullptr, 0) != 0) {
+      const auto error = errno;
+      if (error == ENOENT) {
+        LOGS_DEFAULT(INFO) << "sysctlbyname() key not found: '" << key << "'";
+      } else {
+        LOGS_DEFAULT(WARNING) << "Failed to get '" << key << "' value length with sysctlbyname(). "
+                              << "Error: " << error;
+      }
+      return std::nullopt;
+    }
+
+    std::string value{};
+    value.resize(value_length);
+    if (sysctlbyname(key, value.data(), &value_length, nullptr, 0) != 0) {
+      const auto error = errno;
+      LOGS_DEFAULT(WARNING) << "Failed to get '" << key << "' value with sysctlbyname(). "
+                            << "Error: " << error;
+    }
+
+    return value;
+  };
+
+  constexpr auto vendor_key = "machdep.cpu.vendor";
+  if (auto vendor = get_sysctl_value(vendor_key); vendor.has_value()) {
+    return *vendor;
+  }
+
+  constexpr auto brand_string_key = "machdep.cpu.brand_string";
+  if (auto brand_string = get_sysctl_value(brand_string_key); brand_string.has_value()) {
+    if (brand_string->find("Apple") != std::string::npos) {
+      return "Apple";
+    }
+  }
+
+  LOGS_DEFAULT(WARNING) << "Unable to determine CPU vendor.";
+  return "";
+}
+
 #endif  // defined(__APPLE__)
 
 #endif  // defined(CPUIDINFO_ARCH_ARM)

onnxruntime/core/common/cpuid_info.h

@@ -148,6 +148,7 @@
 #if defined(__linux__)
 
   void ArmLinuxInit();
+  std::string GetArmLinuxVendor();
 
 #elif defined(_WIN32)
 
@@ -157,6 +158,7 @@
 #elif defined(__APPLE__)
 
   void ArmAppleInit();
+  std::string GetArmAppleVendor();
 
 #endif
 

onnxruntime/core/common/string_utils.h

@@ -61,10 +61,11 @@ inline void TrimStringFromRight(std::string& s) {
  * @param s The string to trim.
  * @return The trimmed string.
  */
-inline std::string TrimString(std::string s) {
-  TrimStringFromRight(s);
-  TrimStringFromLeft(s);
-  return s;
+inline std::string TrimString(std::string_view s) {
+  std::string s_trimmed{s};
+  TrimStringFromRight(s_trimmed);
+  TrimStringFromLeft(s_trimmed);
+  return s_trimmed;
 }
 
 /**

onnxruntime/core/platform/apple/device_discovery.cc

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "core/platform/device_discovery.h"
+
+#include "core/common/cpuid_info.h"
+
+namespace onnxruntime {
+
+namespace {
+
+OrtHardwareDevice GetCpuDevice() {
+  const auto& cpuid_info = CPUIDInfo::GetCPUIDInfo();
+
+  OrtHardwareDevice cpu_device{};
+  cpu_device.vendor = cpuid_info.GetCPUVendor();
+  cpu_device.vendor_id = cpuid_info.GetCPUVendorId();
+  cpu_device.device_id = 0;
+  cpu_device.type = OrtHardwareDeviceType_CPU;
+
+  return cpu_device;
+}
+
+}  // namespace
+
+std::unordered_set<OrtHardwareDevice> DeviceDiscovery::DiscoverDevicesForPlatform() {
+  std::unordered_set<OrtHardwareDevice> devices;
+
+  // get CPU devices
+  devices.insert(GetCpuDevice());
+
+  // TODO
+
+  // get GPU devices
+
+  // get NPU devices
+
+  return devices;
+}
+}  // namespace onnxruntime

onnxruntime/core/platform/device_discovery.h

@@ -3,24 +3,19 @@
 
 #pragma once
 
-#include <string>
 #include <unordered_set>
 
 #include "core/session/abi_devices.h"
+
 namespace onnxruntime {
 
 class DeviceDiscovery {
  public:
-  static std::unordered_set<OrtHardwareDevice>& GetDevices() {
-    // assumption: devices don't change. we assume the machine must be shutdown to change cpu/gpu/npu devices.
-    // technically someone could disable/enable a device in a running OS. we choose not to add complexity to support
-    // that scenario.
-    static std::unordered_set<OrtHardwareDevice> devices(DiscoverDevicesForPlatform());
-    return devices;
-  }
+  static const std::unordered_set<OrtHardwareDevice>& GetDevices();
 
  private:
   DeviceDiscovery() = default;
+
   // platform specific code implements this method
   static std::unordered_set<OrtHardwareDevice> DiscoverDevicesForPlatform();
 };

onnxruntime/core/platform/device_discovery_common.cc

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// This file contains platform-agnostic device discovery implementation.
+
+#include "core/platform/device_discovery.h"
+
+#include <sstream>
+
+#include "core/common/logging/logging.h"
+
+namespace onnxruntime {
+
+const std::unordered_set<OrtHardwareDevice>& DeviceDiscovery::GetDevices() {
+  // assumption: devices don't change. we assume the machine must be shutdown to change cpu/gpu/npu devices.
+  // technically someone could disable/enable a device in a running OS. we choose not to add complexity to support
+  // that scenario.
+  static std::unordered_set<OrtHardwareDevice> devices = []() {
+    auto discovered_devices = DiscoverDevicesForPlatform();
+
+    // log discovered devices
+    for (const auto& ortdevice : discovered_devices) {
+      std::ostringstream oss;
+      oss << "Discovered OrtHardwareDevice {vendor_id:0x" << std::hex << ortdevice.vendor_id
+          << ", device_id:0x" << ortdevice.device_id
+          << ", vendor:" << ortdevice.vendor
+          << ", type:" << std::dec << static_cast<int>(ortdevice.type)
+          << ", metadata: [";
+      for (auto& [key, value] : ortdevice.metadata.Entries()) {
+        oss << key << "=" << value << ", ";
+      }
+      oss << "]}";
+      LOGS_DEFAULT(INFO) << oss.str();
+    }
+
+    return discovered_devices;
+  }();
+
+  return devices;
+}
+
+}  // namespace onnxruntime