diff options
Diffstat (limited to 'gfx/angle/checkout/src/gpu_info_util')
6 files changed, 1063 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/gpu_info_util/SystemInfo.cpp b/gfx/angle/checkout/src/gpu_info_util/SystemInfo.cpp new file mode 100644 index 0000000000..b2149c9f63 --- /dev/null +++ b/gfx/angle/checkout/src/gpu_info_util/SystemInfo.cpp @@ -0,0 +1,418 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SystemInfo.cpp: implementation of the system-agnostic parts of SystemInfo.h + +#include "gpu_info_util/SystemInfo.h" + +#include <cstring> +#include <iostream> +#include <sstream> + +#include "anglebase/no_destructor.h" +#include "common/debug.h" +#include "common/string_utils.h" +#include "common/system_utils.h" + +namespace angle +{ +namespace +{ +constexpr char kANGLEPreferredDeviceEnv[] = "ANGLE_PREFERRED_DEVICE"; +} + +std::string VendorName(VendorID vendor) +{ + switch (vendor) + { + case kVendorID_AMD: + return "AMD"; + case kVendorID_ARM: + return "ARM"; + case kVendorID_Broadcom: + return "Broadcom"; + case kVendorID_GOOGLE: + return "Google"; + case kVendorID_ImgTec: + return "ImgTec"; + case kVendorID_Intel: + return "Intel"; + case kVendorID_Kazan: + return "Kazan"; + case kVendorID_NVIDIA: + return "NVIDIA"; + case kVendorID_Qualcomm: + return "Qualcomm"; + case kVendorID_VeriSilicon: + return "VeriSilicon"; + case kVendorID_Vivante: + return "Vivante"; + case kVendorID_VMWare: + return "VMWare"; + case kVendorID_Apple: + return "Apple"; + case kVendorID_Microsoft: + return "Microsoft"; + default: + return "Unknown (" + std::to_string(vendor) + ")"; + } +} + +GPUDeviceInfo::GPUDeviceInfo() = default; + +GPUDeviceInfo::~GPUDeviceInfo() = default; + +GPUDeviceInfo::GPUDeviceInfo(const GPUDeviceInfo &other) = default; + +SystemInfo::SystemInfo() = default; + +SystemInfo::~SystemInfo() = default; + +SystemInfo::SystemInfo(const SystemInfo &other) = default; + +bool SystemInfo::hasNVIDIAGPU() const +{ + for (const GPUDeviceInfo &gpu : gpus) + { + if (IsNVIDIA(gpu.vendorId)) + { + return true; + } + } + return false; +} + +bool SystemInfo::hasIntelGPU() const +{ + for (const GPUDeviceInfo &gpu : gpus) + { + if (IsIntel(gpu.vendorId)) + { + return true; + } + } + return false; +} + +bool SystemInfo::hasAMDGPU() const +{ + for (const GPUDeviceInfo &gpu : gpus) + { + if (IsAMD(gpu.vendorId)) + { + return true; + } + } + return false; +} + +std::optional<size_t> SystemInfo::getPreferredGPUIndex() const +{ + std::string device = GetPreferredDeviceString(); + if (!device.empty()) + { + for (size_t i = 0; i < gpus.size(); ++i) + { + std::string vendor = VendorName(gpus[i].vendorId); + ToLower(&vendor); + if (vendor == device) + return i; + } + } + return std::nullopt; +} + +bool IsAMD(VendorID vendorId) +{ + return vendorId == kVendorID_AMD; +} + +bool IsARM(VendorID vendorId) +{ + return vendorId == kVendorID_ARM; +} + +bool IsBroadcom(VendorID vendorId) +{ + return vendorId == kVendorID_Broadcom; +} + +bool IsImgTec(VendorID vendorId) +{ + return vendorId == kVendorID_ImgTec; +} + +bool IsKazan(VendorID vendorId) +{ + return vendorId == kVendorID_Kazan; +} + +bool IsIntel(VendorID vendorId) +{ + return vendorId == kVendorID_Intel; +} + +bool IsNVIDIA(VendorID vendorId) +{ + return vendorId == kVendorID_NVIDIA; +} + +bool IsQualcomm(VendorID vendorId) +{ + return vendorId == kVendorID_Qualcomm; +} + +bool IsGoogle(VendorID vendorId) +{ + return vendorId == kVendorID_GOOGLE; +} + +bool IsVeriSilicon(VendorID vendorId) +{ + return vendorId == kVendorID_VeriSilicon; +} + +bool IsVMWare(VendorID vendorId) +{ + return vendorId == kVendorID_VMWare; +} + +bool IsVivante(VendorID vendorId) +{ + return vendorId == kVendorID_Vivante; +} + +bool IsApple(VendorID vendorId) +{ + return vendorId == kVendorID_Apple; +} + +bool IsMicrosoft(VendorID vendorId) +{ + return vendorId == kVendorID_Microsoft; +} + +bool ParseAMDBrahmaDriverVersion(const std::string &content, std::string *version) +{ + const size_t begin = content.find_first_of("0123456789"); + if (begin == std::string::npos) + { + return false; + } + + const size_t end = content.find_first_not_of("0123456789.", begin); + if (end == std::string::npos) + { + *version = content.substr(begin); + } + else + { + *version = content.substr(begin, end - begin); + } + return true; +} + +bool ParseAMDCatalystDriverVersion(const std::string &content, std::string *version) +{ + std::istringstream stream(content); + + std::string line; + while (std::getline(stream, line)) + { + static const char kReleaseVersion[] = "ReleaseVersion="; + if (line.compare(0, std::strlen(kReleaseVersion), kReleaseVersion) != 0) + { + continue; + } + + if (ParseAMDBrahmaDriverVersion(line, version)) + { + return true; + } + } + return false; +} + +bool ParseMacMachineModel(const std::string &identifier, + std::string *type, + int32_t *major, + int32_t *minor) +{ + size_t numberLoc = identifier.find_first_of("0123456789"); + if (numberLoc == std::string::npos) + { + return false; + } + + size_t commaLoc = identifier.find(',', numberLoc); + if (commaLoc == std::string::npos || commaLoc >= identifier.size()) + { + return false; + } + + const char *numberPtr = &identifier[numberLoc]; + const char *commaPtr = &identifier[commaLoc + 1]; + char *endPtr = nullptr; + + int32_t majorTmp = static_cast<int32_t>(std::strtol(numberPtr, &endPtr, 10)); + if (endPtr == numberPtr) + { + return false; + } + + int32_t minorTmp = static_cast<int32_t>(std::strtol(commaPtr, &endPtr, 10)); + if (endPtr == commaPtr) + { + return false; + } + + *major = majorTmp; + *minor = minorTmp; + *type = identifier.substr(0, numberLoc); + + return true; +} + +bool CMDeviceIDToDeviceAndVendorID(const std::string &id, uint32_t *vendorId, uint32_t *deviceId) +{ + unsigned int vendor = 0; + unsigned int device = 0; + + bool success = id.length() >= 21 && HexStringToUInt(id.substr(8, 4), &vendor) && + HexStringToUInt(id.substr(17, 4), &device); + + *vendorId = vendor; + *deviceId = device; + return success; +} + +void GetDualGPUInfo(SystemInfo *info) +{ + ASSERT(!info->gpus.empty()); + + // On dual-GPU systems we assume the non-Intel GPU is the graphics one. + // TODO: this is incorrect and problematic. activeGPUIndex must be removed if it cannot be + // determined correctly. A potential solution is to create an OpenGL context and parse + // GL_VENDOR. Currently, our test infrastructure is relying on this information and incorrectly + // applies test expectations on dual-GPU systems when the Intel GPU is active. + // http://anglebug.com/6174. + int active = 0; + bool hasIntel = false; + for (size_t i = 0; i < info->gpus.size(); ++i) + { + if (IsIntel(info->gpus[i].vendorId)) + { + hasIntel = true; + } + if (IsIntel(info->gpus[active].vendorId)) + { + active = static_cast<int>(i); + } + } + + // Assume that a combination of NVIDIA or AMD with Intel means Optimus or AMD Switchable + info->activeGPUIndex = active; + info->isOptimus = hasIntel && IsNVIDIA(info->gpus[active].vendorId); + info->isAMDSwitchable = hasIntel && IsAMD(info->gpus[active].vendorId); +} + +void PrintSystemInfo(const SystemInfo &info) +{ + std::cout << info.gpus.size() << " GPUs:\n"; + + for (size_t i = 0; i < info.gpus.size(); i++) + { + const auto &gpu = info.gpus[i]; + + std::cout << " " << i << " - " << VendorName(gpu.vendorId) << " device id: 0x" << std::hex + << std::uppercase << gpu.deviceId << std::dec << ", revision id: 0x" << std::hex + << std::uppercase << gpu.revisionId << std::dec << ", system device id: 0x" + << std::hex << std::uppercase << gpu.systemDeviceId << std::dec << "\n"; + if (!gpu.driverVendor.empty()) + { + std::cout << " Driver Vendor: " << gpu.driverVendor << "\n"; + } + if (!gpu.driverVersion.empty()) + { + std::cout << " Driver Version: " << gpu.driverVersion << "\n"; + } + if (!gpu.driverDate.empty()) + { + std::cout << " Driver Date: " << gpu.driverDate << "\n"; + } + if (gpu.detailedDriverVersion.major != 0 || gpu.detailedDriverVersion.minor != 0 || + gpu.detailedDriverVersion.subMinor != 0 || gpu.detailedDriverVersion.patch != 0) + { + std::cout << " Detailed Driver Version:\n" + << " major: " << gpu.detailedDriverVersion.major + << " minor: " << gpu.detailedDriverVersion.minor + << " subMinor: " << gpu.detailedDriverVersion.subMinor + << " patch: " << gpu.detailedDriverVersion.patch << "\n"; + } + } + + std::cout << "\n"; + std::cout << "Active GPU: " << info.activeGPUIndex << "\n"; + + std::cout << "\n"; + std::cout << "Optimus: " << (info.isOptimus ? "true" : "false") << "\n"; + std::cout << "AMD Switchable: " << (info.isAMDSwitchable ? "true" : "false") << "\n"; + std::cout << "Mac Switchable: " << (info.isMacSwitchable ? "true" : "false") << "\n"; + std::cout << "Needs EAGL on Mac: " << (info.needsEAGLOnMac ? "true" : "false") << "\n"; + + std::cout << "\n"; + if (!info.machineManufacturer.empty()) + { + std::cout << "Machine Manufacturer: " << info.machineManufacturer << "\n"; + } + if (info.androidSdkLevel != 0) + { + std::cout << "Android SDK Level: " << info.androidSdkLevel << "\n"; + } + if (!info.machineModelName.empty()) + { + std::cout << "Machine Model: " << info.machineModelName << "\n"; + } + if (!info.machineModelVersion.empty()) + { + std::cout << "Machine Model Version: " << info.machineModelVersion << "\n"; + } + std::cout << std::endl; +} + +VersionInfo ParseNvidiaDriverVersion(uint32_t version) +{ + return { + version >> 22, // major + version >> 14 & 0xff, // minor + version >> 6 & 0xff, // subMinor + version & 0x3f // patch + }; +} + +uint64_t GetSystemDeviceIdFromParts(uint32_t highPart, uint32_t lowPart) +{ + return (static_cast<uint64_t>(highPart) << 32) | lowPart; +} + +uint32_t GetSystemDeviceIdHighPart(uint64_t systemDeviceId) +{ + return (systemDeviceId >> 32) & 0xffffffff; +} + +uint32_t GetSystemDeviceIdLowPart(uint64_t systemDeviceId) +{ + return systemDeviceId & 0xffffffff; +} + +std::string GetPreferredDeviceString() +{ + std::string device = angle::GetEnvironmentVar(kANGLEPreferredDeviceEnv); + ToLower(&device); + return device; +} + +} // namespace angle diff --git a/gfx/angle/checkout/src/gpu_info_util/SystemInfo.h b/gfx/angle/checkout/src/gpu_info_util/SystemInfo.h new file mode 100644 index 0000000000..7347404ae7 --- /dev/null +++ b/gfx/angle/checkout/src/gpu_info_util/SystemInfo.h @@ -0,0 +1,179 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SystemInfo.h: gathers information available without starting a GPU driver. + +#ifndef GPU_INFO_UTIL_SYSTEM_INFO_H_ +#define GPU_INFO_UTIL_SYSTEM_INFO_H_ + +#include <cstdint> +#include <optional> +#include <string> +#include <vector> + +namespace angle +{ + +using VendorID = uint32_t; +using DeviceID = uint32_t; +using RevisionID = uint32_t; +using SystemDeviceID = uint64_t; +using DriverID = uint32_t; + +struct VersionInfo +{ + uint32_t major = 0; + uint32_t minor = 0; + uint32_t subMinor = 0; + uint32_t patch = 0; +}; + +struct GPUDeviceInfo +{ + GPUDeviceInfo(); + ~GPUDeviceInfo(); + + GPUDeviceInfo(const GPUDeviceInfo &other); + + VendorID vendorId = 0; + DeviceID deviceId = 0; + RevisionID revisionId = 0; + SystemDeviceID systemDeviceId = 0; + + std::string driverVendor; + std::string driverVersion; + std::string driverDate; + + // Fields only available via GetSystemInfoVulkan: + VersionInfo detailedDriverVersion; + DriverID driverId = 0; + uint32_t driverApiVersion = 0; +}; + +struct SystemInfo +{ + SystemInfo(); + ~SystemInfo(); + + SystemInfo(const SystemInfo &other); + + bool hasNVIDIAGPU() const; + bool hasIntelGPU() const; + bool hasAMDGPU() const; + + // Returns the index to `gpus` if the entry matches the preferred device string. + std::optional<size_t> getPreferredGPUIndex() const; + + std::vector<GPUDeviceInfo> gpus; + + // Index of the GPU expected to be used for 3D graphics. Based on a best-guess heuristic on + // some platforms. On Windows, this is accurate. Note `gpus` must be checked for empty before + // indexing. + int activeGPUIndex = 0; + + bool isOptimus = false; + bool isAMDSwitchable = false; + // Only true on dual-GPU Mac laptops. + bool isMacSwitchable = false; + // Only true on Apple Silicon Macs when running in macCatalyst. + bool needsEAGLOnMac = false; + + // Only available on Android + std::string machineManufacturer; + int androidSdkLevel = 0; + + // Only available on macOS and Android + std::string machineModelName; + + // Only available on macOS + std::string machineModelVersion; +}; + +// Gathers information about the system without starting a GPU driver and returns them in `info`. +// Returns true if all info was gathered, false otherwise. Even when false is returned, `info` will +// be filled with partial information. +bool GetSystemInfo(SystemInfo *info); + +// Vulkan-specific info collection. +bool GetSystemInfoVulkan(SystemInfo *info); + +// Known PCI vendor IDs +constexpr VendorID kVendorID_AMD = 0x1002; +constexpr VendorID kVendorID_ARM = 0x13B5; +constexpr VendorID kVendorID_Broadcom = 0x14E4; +constexpr VendorID kVendorID_GOOGLE = 0x1AE0; +constexpr VendorID kVendorID_ImgTec = 0x1010; +constexpr VendorID kVendorID_Intel = 0x8086; +constexpr VendorID kVendorID_NVIDIA = 0x10DE; +constexpr VendorID kVendorID_Qualcomm = 0x5143; +constexpr VendorID kVendorID_VMWare = 0x15ad; +constexpr VendorID kVendorID_Apple = 0x106B; +constexpr VendorID kVendorID_Microsoft = 0x1414; + +// Known non-PCI (i.e. Khronos-registered) vendor IDs +constexpr VendorID kVendorID_Vivante = 0x10001; +constexpr VendorID kVendorID_VeriSilicon = 0x10002; +constexpr VendorID kVendorID_Kazan = 0x10003; +constexpr VendorID kVendorID_CodePlay = 0x10004; +constexpr VendorID kVendorID_Mesa = 0x10005; +constexpr VendorID kVendorID_PoCL = 0x10006; + +// Known device IDs +constexpr DeviceID kDeviceID_Swiftshader = 0xC0DE; +constexpr DeviceID kDeviceID_Adreno540 = 0x5040001; +constexpr DeviceID kDeviceID_UHD630Mobile = 0x3E9B; + +// Predicates on vendor IDs +bool IsAMD(VendorID vendorId); +bool IsARM(VendorID vendorId); +bool IsBroadcom(VendorID vendorId); +bool IsImgTec(VendorID vendorId); +bool IsIntel(VendorID vendorId); +bool IsKazan(VendorID vendorId); +bool IsNVIDIA(VendorID vendorId); +bool IsQualcomm(VendorID vendorId); +bool IsGoogle(VendorID vendorId); +bool IsSwiftshader(VendorID vendorId); +bool IsVeriSilicon(VendorID vendorId); +bool IsVMWare(VendorID vendorId); +bool IsVivante(VendorID vendorId); +bool IsApple(VendorID vendorId); +bool IsMicrosoft(VendorID vendorId); + +// Returns a readable vendor name given the VendorID +std::string VendorName(VendorID vendor); + +// Use a heuristic to attempt to find the GPU used for 3D graphics. Sets activeGPUIndex, +// isOptimus, and isAMDSwitchable. +// Always assumes the non-Intel GPU is active on dual-GPU machines. +void GetDualGPUInfo(SystemInfo *info); + +// Dumps the system info to stdout. +void PrintSystemInfo(const SystemInfo &info); + +VersionInfo ParseNvidiaDriverVersion(uint32_t version); + +#if defined(ANGLE_PLATFORM_MACOS) || defined(ANGLE_PLATFORM_MACCATALYST) +// Helper to get the active GPU ID from a given Core Graphics display ID. +uint64_t GetGpuIDFromDisplayID(uint32_t displayID); + +// Helper to get the active GPU ID from an OpenGL display mask. +uint64_t GetGpuIDFromOpenGLDisplayMask(uint32_t displayMask); + +// Get VendorID from metal device's registry ID +VendorID GetVendorIDFromMetalDeviceRegistryID(uint64_t registryID); +#endif + +uint64_t GetSystemDeviceIdFromParts(uint32_t highPart, uint32_t lowPart); +uint32_t GetSystemDeviceIdHighPart(uint64_t systemDeviceId); +uint32_t GetSystemDeviceIdLowPart(uint64_t systemDeviceId); + +// Returns lower-case of ANGLE_PREFERRED_DEVICE environment variable contents. +std::string GetPreferredDeviceString(); + +} // namespace angle + +#endif // GPU_INFO_UTIL_SYSTEM_INFO_H_ diff --git a/gfx/angle/checkout/src/gpu_info_util/SystemInfo_internal.h b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_internal.h new file mode 100644 index 0000000000..d300bd81a9 --- /dev/null +++ b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_internal.h @@ -0,0 +1,42 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SystemInfo_internal.h: Functions used by the SystemInfo_* files and unittests + +#ifndef GPU_INFO_UTIL_SYSTEM_INFO_INTERNAL_H_ +#define GPU_INFO_UTIL_SYSTEM_INFO_INTERNAL_H_ + +#include "gpu_info_util/SystemInfo.h" + +namespace angle +{ + +// Defined in SystemInfo_libpci when GPU_INFO_USE_LIBPCI is defined. +bool GetPCIDevicesWithLibPCI(std::vector<GPUDeviceInfo> *devices); +// Defined in SystemInfo_x11 when GPU_INFO_USE_X11 is defined. +bool GetNvidiaDriverVersionWithXNVCtrl(std::string *version); + +// Target specific helper functions that can be compiled on all targets +// Live in SystemInfo.cpp +bool ParseAMDBrahmaDriverVersion(const std::string &content, std::string *version); +bool ParseAMDCatalystDriverVersion(const std::string &content, std::string *version); +bool ParseMacMachineModel(const std::string &identifier, + std::string *type, + int32_t *major, + int32_t *minor); +bool CMDeviceIDToDeviceAndVendorID(const std::string &id, uint32_t *vendorId, uint32_t *deviceId); + +#if defined(ANGLE_PLATFORM_MACOS) || defined(ANGLE_PLATFORM_MACCATALYST) +bool GetSystemInfo_mac(SystemInfo *info); +#endif + +#if defined(ANGLE_PLATFORM_IOS) || (defined(ANGLE_PLATFORM_MACCATALYST) && defined(ANGLE_CPU_ARM64)) +bool GetSystemInfo_ios(SystemInfo *info); +#endif + +} // namespace angle + +#endif // GPU_INFO_UTIL_SYSTEM_INFO_INTERNAL_H_ diff --git a/gfx/angle/checkout/src/gpu_info_util/SystemInfo_vulkan.cpp b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_vulkan.cpp new file mode 100644 index 0000000000..96b6019fd3 --- /dev/null +++ b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_vulkan.cpp @@ -0,0 +1,284 @@ +// +// Copyright 2020 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SystemInfo_vulkan.cpp: Generic vulkan implementation of SystemInfo.h +// TODO: Use VK_KHR_driver_properties. http://anglebug.com/5103 + +#include "gpu_info_util/SystemInfo_vulkan.h" + +#include <vulkan/vulkan.h> +#include "gpu_info_util/SystemInfo_internal.h" + +#include <cstring> +#include <fstream> + +#include "common/angleutils.h" +#include "common/debug.h" +#include "common/system_utils.h" +#include "common/vulkan/libvulkan_loader.h" + +namespace angle +{ +class VulkanLibrary final : NonCopyable +{ + public: + VulkanLibrary() = default; + + ~VulkanLibrary() + { + if (mInstance != VK_NULL_HANDLE) + { + auto pfnDestroyInstance = getProc<PFN_vkDestroyInstance>("vkDestroyInstance"); + if (pfnDestroyInstance) + { + pfnDestroyInstance(mInstance, nullptr); + } + } + + CloseSystemLibrary(mLibVulkan); + } + + VkInstance getVulkanInstance() + { + mLibVulkan = vk::OpenLibVulkan(); + if (!mLibVulkan) + { + // If Vulkan doesn't exist, bail-out early: + return VK_NULL_HANDLE; + } + + // Determine the available Vulkan instance version: + uint32_t instanceVersion = VK_API_VERSION_1_0; +#if defined(VK_VERSION_1_1) + auto pfnEnumerateInstanceVersion = + getProc<PFN_vkEnumerateInstanceVersion>("vkEnumerateInstanceVersion"); + if (!pfnEnumerateInstanceVersion || + pfnEnumerateInstanceVersion(&instanceVersion) != VK_SUCCESS) + { + instanceVersion = VK_API_VERSION_1_0; + } +#endif // VK_VERSION_1_1 + + // Create a Vulkan instance: + VkApplicationInfo appInfo; + appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + appInfo.pNext = nullptr; + appInfo.pApplicationName = ""; + appInfo.applicationVersion = 1; + appInfo.pEngineName = ""; + appInfo.engineVersion = 1; + appInfo.apiVersion = instanceVersion; + + VkInstanceCreateInfo createInstanceInfo; + createInstanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + createInstanceInfo.pNext = nullptr; + createInstanceInfo.flags = 0; + createInstanceInfo.pApplicationInfo = &appInfo; + createInstanceInfo.enabledLayerCount = 0; + createInstanceInfo.ppEnabledLayerNames = nullptr; + createInstanceInfo.enabledExtensionCount = 0; + createInstanceInfo.ppEnabledExtensionNames = nullptr; + + auto pfnCreateInstance = getProc<PFN_vkCreateInstance>("vkCreateInstance"); + if (!pfnCreateInstance || + pfnCreateInstance(&createInstanceInfo, nullptr, &mInstance) != VK_SUCCESS) + { + return VK_NULL_HANDLE; + } + + return mInstance; + } + + template <typename Func> + Func getProc(const char *fn) const + { + return reinterpret_cast<Func>(angle::GetLibrarySymbol(mLibVulkan, fn)); + } + + private: + void *mLibVulkan = nullptr; + VkInstance mInstance = VK_NULL_HANDLE; +}; + +ANGLE_FORMAT_PRINTF(1, 2) +std::string FormatString(const char *fmt, ...) +{ + va_list vararg; + va_start(vararg, fmt); + + std::vector<char> buffer; + size_t len = FormatStringIntoVector(fmt, vararg, buffer); + va_end(vararg); + + return std::string(&buffer[0], len); +} + +bool GetSystemInfoVulkan(SystemInfo *info) +{ + return GetSystemInfoVulkanWithICD(info, vk::ICD::Default); +} + +bool GetSystemInfoVulkanWithICD(SystemInfo *info, vk::ICD preferredICD) +{ + const bool enableValidationLayers = false; + vk::ScopedVkLoaderEnvironment scopedEnvironment(enableValidationLayers, preferredICD); + + // This implementation builds on top of the Vulkan API, but cannot assume the existence of the + // Vulkan library. ANGLE can be installed on versions of Android as old as Ice Cream Sandwich. + // Therefore, we need to use dlopen()/dlsym() in order to see if Vulkan is installed on the + // system, and if so, to use it: + VulkanLibrary vkLibrary; + VkInstance instance = vkLibrary.getVulkanInstance(); + if (instance == VK_NULL_HANDLE) + { + // If Vulkan doesn't exist, bail-out early: + return false; + } + + // Enumerate the Vulkan physical devices, which are ANGLE gpus: + auto pfnEnumeratePhysicalDevices = + vkLibrary.getProc<PFN_vkEnumeratePhysicalDevices>("vkEnumeratePhysicalDevices"); + auto pfnGetPhysicalDeviceProperties = + vkLibrary.getProc<PFN_vkGetPhysicalDeviceProperties>("vkGetPhysicalDeviceProperties"); + auto pfnGetPhysicalDeviceProperties2 = + vkLibrary.getProc<PFN_vkGetPhysicalDeviceProperties2>("vkGetPhysicalDeviceProperties2"); + uint32_t physicalDeviceCount = 0; + if (!pfnEnumeratePhysicalDevices || !pfnGetPhysicalDeviceProperties || + pfnEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr) != VK_SUCCESS) + { + return false; + } + std::vector<VkPhysicalDevice> physicalDevices(physicalDeviceCount); + if (pfnEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices.data()) != + VK_SUCCESS) + { + return false; + } + + // If we get to here, we will likely provide a valid answer (unless an unknown vendorID): + info->gpus.resize(physicalDeviceCount); + + for (uint32_t i = 0; i < physicalDeviceCount; i++) + { + VkPhysicalDeviceDriverProperties driverProperties = {}; + driverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; + + VkPhysicalDeviceProperties2 properties2 = {}; + properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; + properties2.pNext = &driverProperties; + + VkPhysicalDeviceProperties &properties = properties2.properties; + pfnGetPhysicalDeviceProperties(physicalDevices[i], &properties); + + // vkGetPhysicalDeviceProperties2() is supported since 1.1 + // Use vkGetPhysicalDeviceProperties2() to get driver information. + if (properties.apiVersion >= VK_API_VERSION_1_1) + { + pfnGetPhysicalDeviceProperties2(physicalDevices[i], &properties2); + } + + // Fill in data for a given physical device (a.k.a. gpu): + GPUDeviceInfo &gpu = info->gpus[i]; + gpu.vendorId = properties.vendorID; + gpu.deviceId = properties.deviceID; + // Need to parse/re-format properties.driverVersion. + // + // TODO(ianelliott): Determine the formatting used for each vendor + // (http://anglebug.com/2677) + // TODO(http://anglebug.com/7677): Use driverID instead of the hardware vendorID to detect + // driveVendor, etc. + switch (properties.vendorID) + { + case kVendorID_AMD: + gpu.driverVendor = "Advanced Micro Devices, Inc"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_ARM: + gpu.driverVendor = "Arm Holdings"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_Broadcom: + gpu.driverVendor = "Broadcom"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_GOOGLE: + gpu.driverVendor = "Google"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_ImgTec: + gpu.driverVendor = "Imagination Technologies Limited"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_Intel: + gpu.driverVendor = "Intel Corporation"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_Kazan: + gpu.driverVendor = "Kazan Software"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_NVIDIA: + gpu.driverVendor = "NVIDIA Corporation"; + gpu.driverVersion = FormatString("%d.%d.%d.%d", properties.driverVersion >> 22, + (properties.driverVersion >> 14) & 0XFF, + (properties.driverVersion >> 6) & 0XFF, + properties.driverVersion & 0x3F); + gpu.detailedDriverVersion.major = properties.driverVersion >> 22; + gpu.detailedDriverVersion.minor = (properties.driverVersion >> 14) & 0xFF; + gpu.detailedDriverVersion.subMinor = (properties.driverVersion >> 6) & 0xFF; + gpu.detailedDriverVersion.patch = properties.driverVersion & 0x3F; + break; + case kVendorID_Qualcomm: + gpu.driverVendor = "Qualcomm Technologies, Inc"; + if (properties.driverVersion & 0x80000000) + { + gpu.driverVersion = FormatString("%d.%d.%d", properties.driverVersion >> 22, + (properties.driverVersion >> 12) & 0X3FF, + properties.driverVersion & 0xFFF); + gpu.detailedDriverVersion.major = properties.driverVersion >> 22; + gpu.detailedDriverVersion.minor = (properties.driverVersion >> 12) & 0x3FF; + gpu.detailedDriverVersion.subMinor = properties.driverVersion & 0xFFF; + } + else + { + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + } + break; + case kVendorID_VeriSilicon: + gpu.driverVendor = "VeriSilicon"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_Vivante: + gpu.driverVendor = "Vivante"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + case kVendorID_Mesa: + gpu.driverVendor = "Mesa"; + gpu.driverVersion = FormatString("0x%x", properties.driverVersion); + gpu.detailedDriverVersion.major = properties.driverVersion; + break; + default: + return false; + } + gpu.driverId = static_cast<DriverID>(driverProperties.driverID); + gpu.driverApiVersion = properties.apiVersion; + gpu.driverDate = ""; + } + + return true; +} + +} // namespace angle diff --git a/gfx/angle/checkout/src/gpu_info_util/SystemInfo_vulkan.h b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_vulkan.h new file mode 100644 index 0000000000..10c7d69295 --- /dev/null +++ b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_vulkan.h @@ -0,0 +1,23 @@ +// +// Copyright 2020 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SystemInfo_vulkan.h: Reusable Vulkan implementation for SystemInfo.h + +#ifndef GPU_INFO_UTIL_SYSTEM_INFO_VULKAN_H_ +#define GPU_INFO_UTIL_SYSTEM_INFO_VULKAN_H_ + +#include "common/vulkan/vulkan_icd.h" + +namespace angle +{ +struct SystemInfo; + +// Reusable vulkan implementation of GetSystemInfo(). See SystemInfo.h. +bool GetSystemInfoVulkan(SystemInfo *info); +bool GetSystemInfoVulkanWithICD(SystemInfo *info, vk::ICD preferredICD); +} // namespace angle + +#endif // GPU_INFO_UTIL_SYSTEM_INFO_VULKAN_H_ diff --git a/gfx/angle/checkout/src/gpu_info_util/SystemInfo_win.cpp b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_win.cpp new file mode 100644 index 0000000000..291acc1ef0 --- /dev/null +++ b/gfx/angle/checkout/src/gpu_info_util/SystemInfo_win.cpp @@ -0,0 +1,117 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// SystemInfo_win.cpp: implementation of the Windows-specific parts of SystemInfo.h + +#include "gpu_info_util/SystemInfo_internal.h" + +#include "common/debug.h" +#include "common/string_utils.h" + +// Windows.h needs to be included first +#include <windows.h> + +#include <dxgi.h> + +#include <array> +#include <sstream> + +namespace angle +{ + +namespace +{ + +bool GetDevicesFromDXGI(std::vector<GPUDeviceInfo> *devices) +{ +#if defined(ANGLE_ENABLE_WINDOWS_UWP) + IDXGIFactory1 *factory; + if (!SUCCEEDED( + CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void **>(&factory)))) + { + return false; + } +#else + IDXGIFactory *factory; + if (!SUCCEEDED(CreateDXGIFactory(__uuidof(IDXGIFactory), reinterpret_cast<void **>(&factory)))) + { + return false; + } +#endif + + UINT i = 0; + IDXGIAdapter *adapter = nullptr; + while (factory->EnumAdapters(i++, &adapter) != DXGI_ERROR_NOT_FOUND) + { + DXGI_ADAPTER_DESC desc; + adapter->GetDesc(&desc); + + LARGE_INTEGER umdVersion; + if (adapter->CheckInterfaceSupport(__uuidof(IDXGIDevice), &umdVersion) == + DXGI_ERROR_UNSUPPORTED) + { + adapter->Release(); + continue; + } + + // The UMD driver version here is the same as in the registry except for the last number. + uint64_t intVersion = umdVersion.QuadPart; + std::ostringstream o; + + constexpr uint64_t kMask16 = std::numeric_limits<uint16_t>::max(); + o << ((intVersion >> 48) & kMask16) << "."; + o << ((intVersion >> 32) & kMask16) << "."; + o << ((intVersion >> 16) & kMask16) << "."; + o << (intVersion & kMask16); + + GPUDeviceInfo device; + device.vendorId = desc.VendorId; + device.deviceId = desc.DeviceId; + device.driverVersion = o.str(); + device.systemDeviceId = + GetSystemDeviceIdFromParts(desc.AdapterLuid.HighPart, desc.AdapterLuid.LowPart); + + devices->push_back(device); + + adapter->Release(); + } + + factory->Release(); + + return (i > 0); +} + +} // anonymous namespace + +bool GetSystemInfo(SystemInfo *info) +{ + if (!GetDevicesFromDXGI(&info->gpus)) + { + return false; + } + + if (info->gpus.size() == 0) + { + return false; + } + + // Call GetDualGPUInfo to populate activeGPUIndex, isOptimus, and isAMDSwitchable. + GetDualGPUInfo(info); + + // Override activeGPUIndex. The first index returned by EnumAdapters is the active GPU. We + // can override the heuristic to find the active GPU + info->activeGPUIndex = 0; + +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) + // Override isOptimus. nvd3d9wrap.dll is loaded into all processes when Optimus is enabled. + HMODULE nvd3d9wrap = GetModuleHandleW(L"nvd3d9wrap.dll"); + info->isOptimus = nvd3d9wrap != nullptr; +#endif + + return true; +} + +} // namespace angle |