src/common/vulkan/vulkan_icd.cpp - third_party/angle - Git at Google

 //
 // 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.
 //

 // vulkan_icd.cpp : Helper for creating vulkan instances & selecting physical device.

 #include "common/vulkan/vulkan_icd.h"
 #include "common/unsafe_buffers.h"

 #include <functional>
 #include <vector>

 #include "common/Optional.h"
 #include "common/bitset_utils.h"
 #include "common/debug.h"
 #include "common/system_utils.h"

 namespace
 {
 void ResetEnvironmentVar(const char *variableName, const Optional<std::string> &value)
 {
     if (!value.valid())
     {
         return;
     }

     if (value.value().empty())
     {
         angle::UnsetEnvironmentVar(variableName);
     }
     else
     {
         angle::SetEnvironmentVar(variableName, value.value().c_str());
     }
 }
 }  // namespace

 namespace angle
 {

 namespace vk
 {

 namespace
 {

 [[maybe_unused]] const std::string WrapICDEnvironment(const char *icdEnvironment)
 {
     // The libraries are bundled into the module directory
     std::string moduleDir = angle::GetModuleDirectory();
     std::string ret       = ConcatenatePath(moduleDir, icdEnvironment);
 #if defined(ANGLE_PLATFORM_MACOS)
     std::string moduleDirWithLibraries = ConcatenatePath(moduleDir, "Libraries");
     ret += ":" + ConcatenatePath(moduleDirWithLibraries, icdEnvironment);
 #endif
     return ret;
 }

 [[maybe_unused]] constexpr char kLoaderLayersPathEnv[] = "VK_LAYER_PATH";
 [[maybe_unused]] constexpr char kLayerEnablesEnv[]     = "VK_LAYER_ENABLES";

 constexpr char kLoaderICDFilenamesEnv[]              = "VK_ICD_FILENAMES";
 constexpr char kANGLEPreferredDeviceEnv[]            = "ANGLE_PREFERRED_DEVICE";
 constexpr char kValidationLayersCustomSTypeListEnv[] = "VK_LAYER_CUSTOM_STYPE_LIST";
 constexpr char kNoDeviceSelect[]                     = "NODEVICE_SELECT";

 constexpr uint32_t kMockVendorID = 0xba5eba11;
 constexpr uint32_t kMockDeviceID = 0xf005ba11;
 constexpr char kMockDeviceName[] = "Vulkan Mock Device";

 constexpr uint32_t kGoogleVendorID      = 0x1AE0;
 constexpr uint32_t kSwiftShaderDeviceID = 0xC0DE;
 constexpr char kSwiftShaderDeviceName[] = "SwiftShader Device";

 using ICDFilterFunc = std::function<bool(const VkPhysicalDeviceProperties &)>;

 ICDFilterFunc GetFilterForICD(vk::ICD preferredICD)
 {
     switch (preferredICD)
     {
         case vk::ICD::Mock:
             return [](const VkPhysicalDeviceProperties &deviceProperties) {
                 return (
                     (deviceProperties.vendorID == kMockVendorID) &&
                     (deviceProperties.deviceID == kMockDeviceID) &&
                     (ANGLE_UNSAFE_TODO(strcmp(deviceProperties.deviceName, kMockDeviceName)) == 0));
             };
         case vk::ICD::SwiftShader:
             return [](const VkPhysicalDeviceProperties &deviceProperties) {
                 return (
                     (deviceProperties.vendorID == kGoogleVendorID) &&
                     (deviceProperties.deviceID == kSwiftShaderDeviceID) &&
                     (ANGLE_UNSAFE_TODO(strncmp(deviceProperties.deviceName, kSwiftShaderDeviceName,
                                                strlen(kSwiftShaderDeviceName))) == 0));
             };
         default:
             const std::string anglePreferredDevice =
                 angle::GetEnvironmentVar(kANGLEPreferredDeviceEnv);
             return [anglePreferredDevice](const VkPhysicalDeviceProperties &deviceProperties) {
                 return (anglePreferredDevice == deviceProperties.deviceName);
             };
     }
 }

 }  // namespace

 // If we're loading the vulkan layers, we could be running from any random directory.
 // Change to the executable directory so we can find the layers, then change back to the
 // previous directory to be safe we don't disrupt the application.
 ScopedVkLoaderEnvironment::ScopedVkLoaderEnvironment(bool enableDebugLayers, vk::ICD icd)
     : mEnableDebugLayers(enableDebugLayers),
       mICD(icd),
       mChangedCWD(false),
       mChangedICDEnv(false),
       mChangedNoDeviceSelect(false)
 {
 // Changing CWD and setting environment variables makes no sense on Android,
 // since this code is a part of Java application there.
 // Android Vulkan loader doesn't need this either.
 #if !defined(ANGLE_PLATFORM_ANDROID)
     if (icd == vk::ICD::Mock)
     {
         if (!setICDEnvironment(WrapICDEnvironment(ANGLE_VK_MOCK_ICD_JSON).c_str()))
         {
             ERR() << "Error setting environment for Mock/Null Driver.";
         }
     }
 #    if defined(ANGLE_VK_SWIFTSHADER_ICD_JSON)
     else if (icd == vk::ICD::SwiftShader)
     {
         if (!setICDEnvironment(WrapICDEnvironment(ANGLE_VK_SWIFTSHADER_ICD_JSON).c_str()))
         {
             ERR() << "Error setting environment for SwiftShader.";
         }
     }
 #    endif  // defined(ANGLE_VK_SWIFTSHADER_ICD_JSON)

 #    if !defined(ANGLE_PLATFORM_MACOS)
     if (mEnableDebugLayers || icd != vk::ICD::Default)
     {
         const auto &cwd = angle::GetCWD();
         if (!cwd.valid())
         {
             ERR() << "Error getting CWD for Vulkan layers init.";
             mEnableDebugLayers = false;
             mICD               = vk::ICD::Default;
         }
         else
         {
             mPreviousCWD          = cwd.value();
             std::string moduleDir = angle::GetModuleDirectory();
             mChangedCWD           = angle::SetCWD(moduleDir.c_str());
             if (!mChangedCWD)
             {
                 ERR() << "Error setting CWD for Vulkan layers init.";
                 mEnableDebugLayers = false;
                 mICD               = vk::ICD::Default;
             }
         }
     }
 #    endif  // defined(ANGLE_PLATFORM_MACOS)

     // Override environment variable to use the ANGLE layers.
     if (mEnableDebugLayers)
     {
 #    if defined(ANGLE_VK_LAYERS_DIR)
         if (!angle::PrependPathToEnvironmentVar(kLoaderLayersPathEnv, ANGLE_VK_LAYERS_DIR))
         {
             ERR() << "Error setting environment for Vulkan layers init.";
             mEnableDebugLayers = false;
         }
 #    endif  // defined(ANGLE_VK_LAYERS_DIR)
     }
 #endif  // !defined(ANGLE_PLATFORM_ANDROID)

     if (IsMSan() || IsASan())
     {
         // device select layer cause memory sanitizer false positive, so disable
         // it for msan build.
         mPreviousNoDeviceSelectEnv = angle::GetEnvironmentVar(kNoDeviceSelect);
         angle::SetEnvironmentVar(kNoDeviceSelect, "1");
         mChangedNoDeviceSelect = true;
     }
 }

 ScopedVkLoaderEnvironment::~ScopedVkLoaderEnvironment()
 {
     if (mChangedCWD)
     {
 #if !defined(ANGLE_PLATFORM_ANDROID)
         ASSERT(mPreviousCWD.valid());
         angle::SetCWD(mPreviousCWD.value().c_str());
 #endif  // !defined(ANGLE_PLATFORM_ANDROID)
     }
     if (mChangedICDEnv)
     {
         ResetEnvironmentVar(kLoaderICDFilenamesEnv, mPreviousICDEnv);
     }

     ResetEnvironmentVar(kValidationLayersCustomSTypeListEnv, mPreviousCustomExtensionsEnv);

     if (mChangedNoDeviceSelect)
     {
         ResetEnvironmentVar(kNoDeviceSelect, mPreviousNoDeviceSelectEnv);
     }
 }

 bool ScopedVkLoaderEnvironment::setICDEnvironment(const char *icd)
 {
     // Override environment variable to use built Mock ICD
     // ANGLE_VK_ICD_JSON gets set to the built mock ICD in BUILD.gn
     mPreviousICDEnv = angle::GetEnvironmentVar(kLoaderICDFilenamesEnv);
     mChangedICDEnv  = angle::SetEnvironmentVar(kLoaderICDFilenamesEnv, icd);

     if (!mChangedICDEnv)
     {
         mICD = vk::ICD::Default;
     }
     return mChangedICDEnv;
 }

 void ChoosePhysicalDevice(PFN_vkGetPhysicalDeviceProperties2 pGetPhysicalDeviceProperties2,
                           const std::vector<VkPhysicalDevice> &physicalDevices,
                           vk::ICD preferredICD,
                           uint32_t preferredVendorID,
                           uint32_t preferredDeviceID,
                           const uint8_t *preferredDeviceUUID,
                           const uint8_t *preferredDriverUUID,
                           VkDriverId preferredDriverID,
                           VkPhysicalDevice *physicalDeviceOut,
                           VkPhysicalDeviceProperties2 *physicalDeviceProperties2Out,
                           VkPhysicalDeviceIDProperties *physicalDeviceIDPropertiesOut,
                           VkPhysicalDeviceDriverProperties *physicalDeviceDriverPropertiesOut)
 {
     ASSERT(!physicalDevices.empty());

     const size_t deviceCount = physicalDevices.size();
     std::vector<VkPhysicalDeviceProperties2> allProps(deviceCount);
     std::vector<VkPhysicalDeviceIDProperties> allIDProps(deviceCount);
     std::vector<VkPhysicalDeviceDriverProperties> allDriverProps(deviceCount);

     for (size_t i = 0; i < deviceCount; ++i)
     {
         allProps[i]       = {};
         allProps[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
         allProps[i].pNext = &allIDProps[i];

         allIDProps[i]       = {};
         allIDProps[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
         allIDProps[i].pNext = &allDriverProps[i];

         allDriverProps[i]       = {};
         allDriverProps[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;

         pGetPhysicalDeviceProperties2(physicalDevices[i], &allProps[i]);
     }

     auto selectDevice = [&](size_t i) {
         *physicalDeviceOut                       = physicalDevices[i];
         *physicalDeviceProperties2Out            = allProps[i];
         *physicalDeviceIDPropertiesOut           = allIDProps[i];
         *physicalDeviceDriverPropertiesOut       = allDriverProps[i];
         physicalDeviceProperties2Out->pNext      = nullptr;
         physicalDeviceIDPropertiesOut->pNext     = nullptr;
         physicalDeviceDriverPropertiesOut->pNext = nullptr;
     };

     ICDFilterFunc filter = GetFilterForICD(preferredICD);

     const bool shouldChooseByPciId = (preferredVendorID != 0 || preferredDeviceID != 0);
     const bool shouldChooseByUUIDs = (preferredDeviceUUID != nullptr ||
                                       preferredDriverUUID != nullptr || preferredDriverID != 0);

     // Pass 1: exact matches (ICD filter or device/driver UUIDs).
     for (size_t i = 0; i < deviceCount; ++i)
     {
         const VkPhysicalDeviceProperties &props = allProps[i].properties;

         if (props.apiVersion < kMinimumVulkanAPIVersion)
         {
             // Skip any devices that don't support our minimum API version. This
             // takes precedence over all other considerations.
             continue;
         }

         if (filter(props))
         {
             selectDevice(i);
             return;
         }

         if (shouldChooseByUUIDs)
         {
             bool matched = true;

             if (preferredDriverID != 0 && preferredDriverID != allDriverProps[i].driverID)
             {
                 matched = false;
             }
             // SAFETY: preferredDeviceUUID and deviceUUID both have size VK_UUID_SIZE.
             else if (preferredDeviceUUID != nullptr &&
                      ANGLE_UNSAFE_BUFFERS(
                          memcmp(preferredDeviceUUID, allIDProps[i].deviceUUID, VK_UUID_SIZE)) != 0)
             {
                 matched = false;
             }
             // SAFETY: preferredDriverUUID and driverUUID both have size VK_UUID_SIZE.
             else if (preferredDriverUUID != nullptr &&
                      ANGLE_UNSAFE_BUFFERS(
                          memcmp(preferredDriverUUID, allIDProps[i].driverUUID, VK_UUID_SIZE)) != 0)
             {
                 matched = false;
             }

             if (matched)
             {
                 selectDevice(i);
                 return;
             }
         }
     }

     // Pass 2: PCI IDs (lowest-priority criterion; identifies a GPU model rather
     // than an individual GPU, so several devices in a system can share a pair).
     if (shouldChooseByPciId)
     {
         for (size_t i = 0; i < deviceCount; ++i)
         {
             const VkPhysicalDeviceProperties &props = allProps[i].properties;

             if (props.apiVersion < kMinimumVulkanAPIVersion)
             {
                 continue;
             }

             bool matchVendorID = true;
             bool matchDeviceID = true;

             if (preferredVendorID != 0 && preferredVendorID != props.vendorID)
             {
                 matchVendorID = false;
             }

             if (preferredDeviceID != 0 && preferredDeviceID != props.deviceID)
             {
                 matchDeviceID = false;
             }

             if (matchVendorID && matchDeviceID)
             {
                 selectDevice(i);
                 return;
             }
         }
     }

     // Pass 3: Fallbacks (discrete GPU, then integrated, then device 0).
     Optional<size_t> integratedDeviceIndex;

     for (size_t i = 0; i < deviceCount; ++i)
     {
         const VkPhysicalDeviceProperties &props = allProps[i].properties;

         if (props.apiVersion < kMinimumVulkanAPIVersion)
         {
             continue;
         }

         // If discrete GPU exists, uses it by default.
         if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
         {
             selectDevice(i);
             return;
         }
         if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU &&
             !integratedDeviceIndex.valid())
         {
             integratedDeviceIndex = i;
         }
     }

     // If only integrated GPU exists, use it by default.
     if (integratedDeviceIndex.valid())
     {
         selectDevice(integratedDeviceIndex.value());
         return;
     }

     WARN() << "Preferred device ICD not found. Using default physicalDevice instead.";
     // Fallback to the first device.
     selectDevice(0);
 }

 }  // namespace vk

 }  // namespace angle
	//
	// 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.
	//

	// vulkan_icd.cpp : Helper for creating vulkan instances & selecting physical device.

	#include "common/vulkan/vulkan_icd.h"
	#include "common/unsafe_buffers.h"

	#include <functional>
	#include <vector>

	#include "common/Optional.h"
	#include "common/bitset_utils.h"
	#include "common/debug.h"
	#include "common/system_utils.h"

	namespace
	{
	void ResetEnvironmentVar(const char *variableName, const Optional<std::string> &value)
	{
	if (!value.valid())
	{
	return;
	}

	if (value.value().empty())
	{
	angle::UnsetEnvironmentVar(variableName);
	}
	else
	{
	angle::SetEnvironmentVar(variableName, value.value().c_str());
	}
	}
	} // namespace

	namespace angle
	{

	namespace vk
	{

	namespace
	{

	[[maybe_unused]] const std::string WrapICDEnvironment(const char *icdEnvironment)
	{
	// The libraries are bundled into the module directory
	std::string moduleDir = angle::GetModuleDirectory();
	std::string ret = ConcatenatePath(moduleDir, icdEnvironment);
	#if defined(ANGLE_PLATFORM_MACOS)
	std::string moduleDirWithLibraries = ConcatenatePath(moduleDir, "Libraries");
	ret += ":" + ConcatenatePath(moduleDirWithLibraries, icdEnvironment);
	#endif
	return ret;
	}

	[[maybe_unused]] constexpr char kLoaderLayersPathEnv[] = "VK_LAYER_PATH";
	[[maybe_unused]] constexpr char kLayerEnablesEnv[] = "VK_LAYER_ENABLES";

	constexpr char kLoaderICDFilenamesEnv[] = "VK_ICD_FILENAMES";
	constexpr char kANGLEPreferredDeviceEnv[] = "ANGLE_PREFERRED_DEVICE";
	constexpr char kValidationLayersCustomSTypeListEnv[] = "VK_LAYER_CUSTOM_STYPE_LIST";
	constexpr char kNoDeviceSelect[] = "NODEVICE_SELECT";

	constexpr uint32_t kMockVendorID = 0xba5eba11;
	constexpr uint32_t kMockDeviceID = 0xf005ba11;
	constexpr char kMockDeviceName[] = "Vulkan Mock Device";

	constexpr uint32_t kGoogleVendorID = 0x1AE0;
	constexpr uint32_t kSwiftShaderDeviceID = 0xC0DE;
	constexpr char kSwiftShaderDeviceName[] = "SwiftShader Device";

	using ICDFilterFunc = std::function<bool(const VkPhysicalDeviceProperties &)>;

	ICDFilterFunc GetFilterForICD(vk::ICD preferredICD)
	{
	switch (preferredICD)
	{
	case vk::ICD::Mock:
	return [](const VkPhysicalDeviceProperties &deviceProperties) {
	return (
	(deviceProperties.vendorID == kMockVendorID) &&
	(deviceProperties.deviceID == kMockDeviceID) &&
	(ANGLE_UNSAFE_TODO(strcmp(deviceProperties.deviceName, kMockDeviceName)) == 0));
	};
	case vk::ICD::SwiftShader:
	return [](const VkPhysicalDeviceProperties &deviceProperties) {
	return (
	(deviceProperties.vendorID == kGoogleVendorID) &&
	(deviceProperties.deviceID == kSwiftShaderDeviceID) &&
	(ANGLE_UNSAFE_TODO(strncmp(deviceProperties.deviceName, kSwiftShaderDeviceName,
	strlen(kSwiftShaderDeviceName))) == 0));
	};
	default:
	const std::string anglePreferredDevice =
	angle::GetEnvironmentVar(kANGLEPreferredDeviceEnv);
	return [anglePreferredDevice](const VkPhysicalDeviceProperties &deviceProperties) {
	return (anglePreferredDevice == deviceProperties.deviceName);
	};
	}
	}

	} // namespace

	// If we're loading the vulkan layers, we could be running from any random directory.
	// Change to the executable directory so we can find the layers, then change back to the
	// previous directory to be safe we don't disrupt the application.
	ScopedVkLoaderEnvironment::ScopedVkLoaderEnvironment(bool enableDebugLayers, vk::ICD icd)
	: mEnableDebugLayers(enableDebugLayers),
	mICD(icd),
	mChangedCWD(false),
	mChangedICDEnv(false),
	mChangedNoDeviceSelect(false)
	{
	// Changing CWD and setting environment variables makes no sense on Android,
	// since this code is a part of Java application there.
	// Android Vulkan loader doesn't need this either.
	#if !defined(ANGLE_PLATFORM_ANDROID)
	if (icd == vk::ICD::Mock)
	{
	if (!setICDEnvironment(WrapICDEnvironment(ANGLE_VK_MOCK_ICD_JSON).c_str()))
	{
	ERR() << "Error setting environment for Mock/Null Driver.";
	}
	}
	# if defined(ANGLE_VK_SWIFTSHADER_ICD_JSON)
	else if (icd == vk::ICD::SwiftShader)
	{
	if (!setICDEnvironment(WrapICDEnvironment(ANGLE_VK_SWIFTSHADER_ICD_JSON).c_str()))
	{
	ERR() << "Error setting environment for SwiftShader.";
	}
	}
	# endif // defined(ANGLE_VK_SWIFTSHADER_ICD_JSON)

	# if !defined(ANGLE_PLATFORM_MACOS)
	if (mEnableDebugLayers \|\| icd != vk::ICD::Default)
	{
	const auto &cwd = angle::GetCWD();
	if (!cwd.valid())
	{
	ERR() << "Error getting CWD for Vulkan layers init.";
	mEnableDebugLayers = false;
	mICD = vk::ICD::Default;
	}
	else
	{
	mPreviousCWD = cwd.value();
	std::string moduleDir = angle::GetModuleDirectory();
	mChangedCWD = angle::SetCWD(moduleDir.c_str());
	if (!mChangedCWD)
	{
	ERR() << "Error setting CWD for Vulkan layers init.";
	mEnableDebugLayers = false;
	mICD = vk::ICD::Default;
	}
	}
	}
	# endif // defined(ANGLE_PLATFORM_MACOS)

	// Override environment variable to use the ANGLE layers.
	if (mEnableDebugLayers)
	{
	# if defined(ANGLE_VK_LAYERS_DIR)
	if (!angle::PrependPathToEnvironmentVar(kLoaderLayersPathEnv, ANGLE_VK_LAYERS_DIR))
	{
	ERR() << "Error setting environment for Vulkan layers init.";
	mEnableDebugLayers = false;
	}
	# endif // defined(ANGLE_VK_LAYERS_DIR)
	}
	#endif // !defined(ANGLE_PLATFORM_ANDROID)

	if (IsMSan() \|\| IsASan())
	{
	// device select layer cause memory sanitizer false positive, so disable
	// it for msan build.
	mPreviousNoDeviceSelectEnv = angle::GetEnvironmentVar(kNoDeviceSelect);
	angle::SetEnvironmentVar(kNoDeviceSelect, "1");
	mChangedNoDeviceSelect = true;
	}
	}

	ScopedVkLoaderEnvironment::~ScopedVkLoaderEnvironment()
	{
	if (mChangedCWD)
	{
	#if !defined(ANGLE_PLATFORM_ANDROID)
	ASSERT(mPreviousCWD.valid());
	angle::SetCWD(mPreviousCWD.value().c_str());
	#endif // !defined(ANGLE_PLATFORM_ANDROID)
	}
	if (mChangedICDEnv)
	{
	ResetEnvironmentVar(kLoaderICDFilenamesEnv, mPreviousICDEnv);
	}

	ResetEnvironmentVar(kValidationLayersCustomSTypeListEnv, mPreviousCustomExtensionsEnv);

	if (mChangedNoDeviceSelect)
	{
	ResetEnvironmentVar(kNoDeviceSelect, mPreviousNoDeviceSelectEnv);
	}
	}

	bool ScopedVkLoaderEnvironment::setICDEnvironment(const char *icd)
	{
	// Override environment variable to use built Mock ICD
	// ANGLE_VK_ICD_JSON gets set to the built mock ICD in BUILD.gn
	mPreviousICDEnv = angle::GetEnvironmentVar(kLoaderICDFilenamesEnv);
	mChangedICDEnv = angle::SetEnvironmentVar(kLoaderICDFilenamesEnv, icd);

	if (!mChangedICDEnv)
	{
	mICD = vk::ICD::Default;
	}
	return mChangedICDEnv;
	}

	void ChoosePhysicalDevice(PFN_vkGetPhysicalDeviceProperties2 pGetPhysicalDeviceProperties2,
	const std::vector<VkPhysicalDevice> &physicalDevices,
	vk::ICD preferredICD,
	uint32_t preferredVendorID,
	uint32_t preferredDeviceID,
	const uint8_t *preferredDeviceUUID,
	const uint8_t *preferredDriverUUID,
	VkDriverId preferredDriverID,
	VkPhysicalDevice *physicalDeviceOut,
	VkPhysicalDeviceProperties2 *physicalDeviceProperties2Out,
	VkPhysicalDeviceIDProperties *physicalDeviceIDPropertiesOut,
	VkPhysicalDeviceDriverProperties *physicalDeviceDriverPropertiesOut)
	{
	ASSERT(!physicalDevices.empty());

	const size_t deviceCount = physicalDevices.size();
	std::vector<VkPhysicalDeviceProperties2> allProps(deviceCount);
	std::vector<VkPhysicalDeviceIDProperties> allIDProps(deviceCount);
	std::vector<VkPhysicalDeviceDriverProperties> allDriverProps(deviceCount);

	for (size_t i = 0; i < deviceCount; ++i)
	{
	allProps[i] = {};
	allProps[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
	allProps[i].pNext = &allIDProps[i];

	allIDProps[i] = {};
	allIDProps[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
	allIDProps[i].pNext = &allDriverProps[i];

	allDriverProps[i] = {};
	allDriverProps[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;

	pGetPhysicalDeviceProperties2(physicalDevices[i], &allProps[i]);
	}

	auto selectDevice = [&](size_t i) {
	*physicalDeviceOut = physicalDevices[i];
	*physicalDeviceProperties2Out = allProps[i];
	*physicalDeviceIDPropertiesOut = allIDProps[i];
	*physicalDeviceDriverPropertiesOut = allDriverProps[i];
	physicalDeviceProperties2Out->pNext = nullptr;
	physicalDeviceIDPropertiesOut->pNext = nullptr;
	physicalDeviceDriverPropertiesOut->pNext = nullptr;
	};

	ICDFilterFunc filter = GetFilterForICD(preferredICD);

	const bool shouldChooseByPciId = (preferredVendorID != 0 \|\| preferredDeviceID != 0);
	const bool shouldChooseByUUIDs = (preferredDeviceUUID != nullptr \|\|
	preferredDriverUUID != nullptr \|\| preferredDriverID != 0);

	// Pass 1: exact matches (ICD filter or device/driver UUIDs).
	for (size_t i = 0; i < deviceCount; ++i)
	{
	const VkPhysicalDeviceProperties &props = allProps[i].properties;

	if (props.apiVersion < kMinimumVulkanAPIVersion)
	{
	// Skip any devices that don't support our minimum API version. This
	// takes precedence over all other considerations.
	continue;
	}

	if (filter(props))
	{
	selectDevice(i);
	return;
	}

	if (shouldChooseByUUIDs)
	{
	bool matched = true;

	if (preferredDriverID != 0 && preferredDriverID != allDriverProps[i].driverID)
	{
	matched = false;
	}
	// SAFETY: preferredDeviceUUID and deviceUUID both have size VK_UUID_SIZE.
	else if (preferredDeviceUUID != nullptr &&
	ANGLE_UNSAFE_BUFFERS(
	memcmp(preferredDeviceUUID, allIDProps[i].deviceUUID, VK_UUID_SIZE)) != 0)
	{
	matched = false;
	}
	// SAFETY: preferredDriverUUID and driverUUID both have size VK_UUID_SIZE.
	else if (preferredDriverUUID != nullptr &&
	ANGLE_UNSAFE_BUFFERS(
	memcmp(preferredDriverUUID, allIDProps[i].driverUUID, VK_UUID_SIZE)) != 0)
	{
	matched = false;
	}

	if (matched)
	{
	selectDevice(i);
	return;
	}
	}
	}

	// Pass 2: PCI IDs (lowest-priority criterion; identifies a GPU model rather
	// than an individual GPU, so several devices in a system can share a pair).
	if (shouldChooseByPciId)
	{
	for (size_t i = 0; i < deviceCount; ++i)
	{
	const VkPhysicalDeviceProperties &props = allProps[i].properties;

	if (props.apiVersion < kMinimumVulkanAPIVersion)
	{
	continue;
	}

	bool matchVendorID = true;
	bool matchDeviceID = true;

	if (preferredVendorID != 0 && preferredVendorID != props.vendorID)
	{
	matchVendorID = false;
	}

	if (preferredDeviceID != 0 && preferredDeviceID != props.deviceID)
	{
	matchDeviceID = false;
	}

	if (matchVendorID && matchDeviceID)
	{
	selectDevice(i);
	return;
	}
	}
	}

	// Pass 3: Fallbacks (discrete GPU, then integrated, then device 0).
	Optional<size_t> integratedDeviceIndex;

	for (size_t i = 0; i < deviceCount; ++i)
	{
	const VkPhysicalDeviceProperties &props = allProps[i].properties;

	if (props.apiVersion < kMinimumVulkanAPIVersion)
	{
	continue;
	}

	// If discrete GPU exists, uses it by default.
	if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
	{
	selectDevice(i);
	return;
	}
	if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU &&
	!integratedDeviceIndex.valid())
	{
	integratedDeviceIndex = i;
	}
	}

	// If only integrated GPU exists, use it by default.
	if (integratedDeviceIndex.valid())
	{
	selectDevice(integratedDeviceIndex.value());
	return;
	}

	WARN() << "Preferred device ICD not found. Using default physicalDevice instead.";
	// Fallback to the first device.
	selectDevice(0);
	}

	} // namespace vk

	} // namespace angle