Adapter selection for Renderer (shader-slang#923)

* * Make adapter used selectable on the command line
* Added 'adapter' to Renderer::Desc with dx11, dx12, vk honoring it
* GL will check that the renderer matches, but cannot select a specific device
* Share functionality on dx adapter selection in D3DUtil

Note - that on tests that use OpenGL and the adapter doesn't match it will ignore the test (and display a message that the appropriate device couldn't be started)

* Small function name improvement.

* Variable rename to match type.

* Fix typo in Dx12 device selection.

* * Add checking if an adapter is warp
* Improve some comments

Author: jsmall-zzz

tools/gfx/d3d-util.cpp

@@ -3,6 +3,8 @@
 
 #include <d3dcompiler.h>
 
+#include <dxgi1_4.h>
+
 // We will use the C standard library just for printing error messages.
 #include <stdio.h>
 
@@ -304,4 +306,149 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
     }
 }
 
+/* static */HMODULE D3DUtil::getDxgiModule()
+{
+    static HMODULE s_dxgiModule = LoadLibraryA("dxgi.dll");
+    if (!s_dxgiModule)
+    {
+        fprintf(stderr, "error: failed load 'dxgi.dll'\n");
+        return nullptr;
+    }
+
+    return s_dxgiModule;
+}
+
+/* static */SlangResult D3DUtil::createFactory(DeviceCheckFlags flags, ComPtr<IDXGIFactory>& outFactory)
+{
+    auto dxgiModule =  getDxgiModule();
+    if (!dxgiModule)
+    {
+        return SLANG_FAIL;
+    }
+
+    typedef HRESULT(WINAPI *PFN_DXGI_CREATE_FACTORY)(REFIID riid, void   **ppFactory);
+    typedef HRESULT(WINAPI *PFN_DXGI_CREATE_FACTORY_2)(UINT Flags, REFIID riid, _COM_Outptr_ void **ppFactory);
+
+    {
+        auto createFactory2 = (PFN_DXGI_CREATE_FACTORY_2)::GetProcAddress(dxgiModule, "CreateDXGIFactory2");
+        if (createFactory2)
+        {
+            UINT dxgiFlags = 0;
+
+            if (flags & DeviceCheckFlag::UseDebug)
+            {
+                dxgiFlags |= DXGI_CREATE_FACTORY_DEBUG;
+            }
+
+            ComPtr<IDXGIFactory4> factory;
+            SLANG_RETURN_ON_FAIL(createFactory2(dxgiFlags, IID_PPV_ARGS(factory.writeRef())));
+
+            outFactory = factory;
+            return SLANG_OK;
+        }
+    }
+
+    {
+        auto createFactory = (PFN_DXGI_CREATE_FACTORY)::GetProcAddress(dxgiModule, "CreateDXGIFactory");
+        if (!createFactory)
+        {
+            fprintf(stderr, "error: failed load symbol '%s'\n", "CreateDXGIFactory");
+            return SLANG_FAIL;
+        }
+        return createFactory(IID_PPV_ARGS(outFactory.writeRef()));
+    }
+}
+
+/* static */SlangResult D3DUtil::findAdapters(DeviceCheckFlags flags, const Slang::UnownedStringSlice& adapaterName, List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
+{
+    ComPtr<IDXGIFactory> factory;
+    SLANG_RETURN_ON_FAIL(createFactory(flags, factory));
+    return findAdapters(flags, adapaterName, factory, outDxgiAdapters);
+}
+
+static bool _isMatch(IDXGIAdapter* adapter, const Slang::UnownedStringSlice& lowerAdapaterName)
+{
+    if (lowerAdapaterName.size() == 0)
+    {
+        return true;
+    }
+
+    DXGI_ADAPTER_DESC desc;
+    adapter->GetDesc(&desc);
+
+    String descName = String::FromWString(desc.Description).ToLower();
+
+    return descName.IndexOf(lowerAdapaterName) != UInt(-1);
+}
+
+/* static */bool D3DUtil::isWarp(IDXGIFactory* dxgiFactory, IDXGIAdapter* adapterIn)
+{
+    ComPtr<IDXGIFactory4> dxgiFactory4;
+    if (SLANG_SUCCEEDED(dxgiFactory->QueryInterface(IID_PPV_ARGS(dxgiFactory4.writeRef()))))
+    {
+        ComPtr<IDXGIAdapter> warpAdapter;
+        dxgiFactory4->EnumWarpAdapter(IID_PPV_ARGS(warpAdapter.writeRef()));
+
+        return adapterIn == warpAdapter;
+    }
+
+    return false;
+}
+
+/* static */SlangResult D3DUtil::findAdapters(DeviceCheckFlags flags, const UnownedStringSlice& adapterName, IDXGIFactory* dxgiFactory, List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
+{
+    String lowerAdapterName = String(adapterName).ToLower();
+
+    outDxgiAdapters.Clear();
+
+    ComPtr<IDXGIAdapter> warpAdapter;
+    if ((flags & DeviceCheckFlag::UseHardwareDevice) == 0)
+    {
+        ComPtr<IDXGIFactory4> dxgiFactory4;
+        if (SLANG_SUCCEEDED(dxgiFactory->QueryInterface(IID_PPV_ARGS(dxgiFactory4.writeRef()))))
+        {
+            dxgiFactory4->EnumWarpAdapter(IID_PPV_ARGS(warpAdapter.writeRef()));
+            if (_isMatch(warpAdapter, lowerAdapterName.getUnownedSlice()))
+            {
+                outDxgiAdapters.Add(warpAdapter);
+            }
+        }
+    }
+
+    for (UINT adapterIndex = 0; true; adapterIndex++)
+    {
+        ComPtr<IDXGIAdapter> dxgiAdapter;
+        if (dxgiFactory->EnumAdapters(adapterIndex, dxgiAdapter.writeRef()) == DXGI_ERROR_NOT_FOUND)
+            break;
+
+        // Skip if warp (as we will have already added it)
+        if (dxgiAdapter == warpAdapter)
+        {
+            continue;
+        }
+        if (!_isMatch(dxgiAdapter, lowerAdapterName.getUnownedSlice()))
+        {
+            continue;
+        }
+
+        // Get if it's software
+        UINT deviceFlags = 0;
+        ComPtr<IDXGIAdapter1> dxgiAdapter1;
+        if (SLANG_SUCCEEDED(dxgiAdapter->QueryInterface(IID_PPV_ARGS(dxgiAdapter1.writeRef()))))
+        {
+            DXGI_ADAPTER_DESC1 desc;
+            dxgiAdapter1->GetDesc1(&desc);
+            deviceFlags = desc.Flags;
+        }
+
+        // If the right type then add it
+        if ((deviceFlags & DXGI_ADAPTER_FLAG_SOFTWARE) == 0 && (flags & DeviceCheckFlag::UseHardwareDevice) != 0)
+        {
+            outDxgiAdapters.Add(dxgiAdapter);
+        }
+    }
+
+    return SLANG_OK;
+}
+
 } // renderer_test

tools/gfx/d3d-util.h

@@ -8,10 +8,13 @@
 #include "../../slang-com-ptr.h"
 #include "../../source/core/list.h"
 
+#include "flag-combiner.h"
+
 #include "render.h"
 
 #include <D3Dcommon.h>
 #include <DXGIFormat.h>
+#include <dxgi.h>
 
 namespace gfx {
 
@@ -56,6 +59,21 @@ class D3DUtil
 
         /// Append text in in, into wide char array
     static void appendWideChars(const char* in, Slang::List<wchar_t>& out);
+
+    
+    static SlangResult createFactory(DeviceCheckFlags flags, Slang::ComPtr<IDXGIFactory>& outFactory);
+
+        /// Get the dxgiModule
+    static HMODULE getDxgiModule();
+
+        /// Find adapters
+    static SlangResult findAdapters(DeviceCheckFlags flags, const Slang::UnownedStringSlice& adapaterName, IDXGIFactory* dxgiFactory, Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
+        /// Find adapters
+    static SlangResult findAdapters(DeviceCheckFlags flags, const Slang::UnownedStringSlice& adapaterName, Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
+
+        /// True if the adapter is warp
+    static bool isWarp(IDXGIFactory* dxgiFactory, IDXGIAdapter* adapter);
+
 };
 
 } // renderer_test

tools/gfx/render-d3d11.cpp

@@ -472,12 +472,33 @@ SlangResult D3D11Renderer::initialize(const Desc& desc, void* inWindowHandle)
         for (int i = 0; i < numCombinations; ++i)
         {
             const auto deviceCheckFlags = combiner.getCombination(i);
-            const D3D_DRIVER_TYPE driverType = (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice) ? D3D_DRIVER_TYPE_HARDWARE : D3D_DRIVER_TYPE_REFERENCE;
+
+            // If we have an adapter set on the desc, look it up. We only need to do so for hardware
+            ComPtr<IDXGIAdapter> adapter;
+            if (desc.adapter.Length() &&  (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice))
+            {
+                List<ComPtr<IDXGIAdapter>> dxgiAdapters;
+                D3DUtil::findAdapters(deviceCheckFlags, desc.adapter.getUnownedSlice(), dxgiAdapters);
+                if (dxgiAdapters.Count() == 0)
+                {
+                    continue;
+                }
+                adapter = dxgiAdapters[0];
+            }
+
+            // The adapter can be nullptr - that just means 'default', but when so we need to select the driver type
+            D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_UNKNOWN;
+            if (adapter == nullptr)
+            {
+                // If we don't have an adapter, select directly
+                driverType = (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice) ? D3D_DRIVER_TYPE_HARDWARE : D3D_DRIVER_TYPE_REFERENCE;
+            }
+
             const int startFeatureIndex = (deviceCheckFlags & DeviceCheckFlag::UseFullFeatureLevel) ? 0 : 1; 
             const UINT deviceFlags = (deviceCheckFlags & DeviceCheckFlag::UseDebug) ? D3D11_CREATE_DEVICE_DEBUG : 0;
 
             res = D3D11CreateDeviceAndSwapChain_(
-                nullptr,                    // adapter (use default)
+                adapter,                   
                 driverType,
                 nullptr,                    // software
                 deviceFlags,