1 files changed, 349 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/common/vulkan/vulkan_icd.cpp b/gfx/angle/checkout/src/common/vulkan/vulkan_icd.cpp
new file mode 100644
index 0000000000..22502c0457
--- /dev/null
+++ b/gfx/angle/checkout/src/common/vulkan/vulkan_icd.cpp
@@ -0,0 +1,349 @@
+//
+// 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 <functional>
+#include <vector>
+
+#include "common/Optional.h"
+#include "common/bitset_utils.h"
+#include "common/debug.h"
+#include "common/system_utils.h"
+
+#include "common/vulkan/vk_google_filtering_precision.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 ret = ConcatenatePath(angle::GetModuleDirectory(), icdEnvironment);
+    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) &&
+                        (strcmp(deviceProperties.deviceName, kMockDeviceName) == 0));
+            };
+        case vk::ICD::SwiftShader:
+            return [](const VkPhysicalDeviceProperties &deviceProperties) {
+                return ((deviceProperties.vendorID == kGoogleVendorID) &&
+                        (deviceProperties.deviceID == kSwiftShaderDeviceID) &&
+                        (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 validation 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 enableValidationLayers, vk::ICD icd)
+    : mEnableValidationLayers(enableValidationLayers),
+      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) && !defined(ANGLE_PLATFORM_GGP)
+    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 (mEnableValidationLayers || icd != vk::ICD::Default)
+    {
+        const auto &cwd = angle::GetCWD();
+        if (!cwd.valid())
+        {
+            ERR() << "Error getting CWD for Vulkan layers init.";
+            mEnableValidationLayers = 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.";
+                mEnableValidationLayers = false;
+                mICD                    = vk::ICD::Default;
+            }
+        }
+    }
+#    endif  // defined(ANGLE_PLATFORM_MACOS)
+
+    // Override environment variable to use the ANGLE layers.
+    if (mEnableValidationLayers)
+    {
+#    if defined(ANGLE_VK_LAYERS_DIR)
+        if (!angle::PrependPathToEnvironmentVar(kLoaderLayersPathEnv, ANGLE_VK_LAYERS_DIR))
+        {
+            ERR() << "Error setting environment for Vulkan layers init.";
+            mEnableValidationLayers = false;
+        }
+#    endif  // defined(ANGLE_VK_LAYERS_DIR)
+
+        if (!angle::PrependPathToEnvironmentVar(
+                kLayerEnablesEnv, "VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION"))
+        {
+            ERR() << "Error setting synchronization validation environment for Vulkan validation "
+                     "layers init.";
+        }
+
+        if (!setCustomExtensionsEnvironment())
+        {
+            ERR() << "Error setting custom list for custom extensions for Vulkan layers init.";
+            mEnableValidationLayers = false;
+        }
+    }
+#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;
+}
+
+bool ScopedVkLoaderEnvironment::setCustomExtensionsEnvironment()
+{
+    struct CustomExtension
+    {
+        VkStructureType type;
+        size_t size;
+    };
+
+    CustomExtension customExtensions[] = {
+
+        {VK_STRUCTURE_TYPE_SAMPLER_FILTERING_PRECISION_GOOGLE,
+         sizeof(VkSamplerFilteringPrecisionGOOGLE)},
+
+    };
+
+    mPreviousCustomExtensionsEnv = angle::GetEnvironmentVar(kValidationLayersCustomSTypeListEnv);
+
+    std::stringstream strstr;
+    for (CustomExtension &extension : customExtensions)
+    {
+        if (strstr.tellp() != std::streampos(0))
+        {
+            strstr << angle::GetPathSeparatorForEnvironmentVar();
+        }
+
+        strstr << extension.type << angle::GetPathSeparatorForEnvironmentVar() << extension.size;
+    }
+
+    return angle::PrependPathToEnvironmentVar(kValidationLayersCustomSTypeListEnv,
+                                              strstr.str().c_str());
+}
+
+void ChoosePhysicalDevice(PFN_vkGetPhysicalDeviceProperties pGetPhysicalDeviceProperties,
+                          const std::vector<VkPhysicalDevice> &physicalDevices,
+                          vk::ICD preferredICD,
+                          uint32_t preferredVendorID,
+                          uint32_t preferredDeviceID,
+                          VkPhysicalDevice *physicalDeviceOut,
+                          VkPhysicalDeviceProperties *physicalDevicePropertiesOut)
+{
+    ASSERT(!physicalDevices.empty());
+
+    ICDFilterFunc filter = GetFilterForICD(preferredICD);
+
+    const bool shouldChooseByID = (preferredVendorID != 0 || preferredDeviceID != 0);
+
+    for (const VkPhysicalDevice &physicalDevice : physicalDevices)
+    {
+        pGetPhysicalDeviceProperties(physicalDevice, physicalDevicePropertiesOut);
+        if (filter(*physicalDevicePropertiesOut))
+        {
+            *physicalDeviceOut = physicalDevice;
+            return;
+        }
+
+        if (shouldChooseByID)
+        {
+            // NOTE: If the system has multiple GPUs with the same vendor and
+            // device IDs, this will arbitrarily select one of them.
+            bool matchVendorID = true;
+            bool matchDeviceID = true;
+
+            if (preferredVendorID != 0 &&
+                preferredVendorID != physicalDevicePropertiesOut->vendorID)
+            {
+                matchVendorID = false;
+            }
+
+            if (preferredDeviceID != 0 &&
+                preferredDeviceID != physicalDevicePropertiesOut->deviceID)
+            {
+                matchDeviceID = false;
+            }
+
+            if (matchVendorID && matchDeviceID)
+            {
+                *physicalDeviceOut = physicalDevice;
+                return;
+            }
+        }
+    }
+
+    Optional<VkPhysicalDevice> integratedDevice;
+    VkPhysicalDeviceProperties integratedDeviceProperties;
+    for (const VkPhysicalDevice &physicalDevice : physicalDevices)
+    {
+        pGetPhysicalDeviceProperties(physicalDevice, physicalDevicePropertiesOut);
+        // If discrete GPU exists, uses it by default.
+        if (physicalDevicePropertiesOut->deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+        {
+            *physicalDeviceOut = physicalDevice;
+            return;
+        }
+        if (physicalDevicePropertiesOut->deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU &&
+            !integratedDevice.valid())
+        {
+            integratedDevice           = physicalDevice;
+            integratedDeviceProperties = *physicalDevicePropertiesOut;
+            continue;
+        }
+    }
+
+    // If only integrated GPU exists, use it by default.
+    if (integratedDevice.valid())
+    {
+        *physicalDeviceOut           = integratedDevice.value();
+        *physicalDevicePropertiesOut = integratedDeviceProperties;
+        return;
+    }
+
+    WARN() << "Preferred device ICD not found. Using default physicalDevice instead.";
+    // Fallback to the first device.
+    *physicalDeviceOut = physicalDevices[0];
+    pGetPhysicalDeviceProperties(*physicalDeviceOut, physicalDevicePropertiesOut);
+}
+
+}  // namespace vk
+
+}  // namespace angle