How do I filter GPUs by type in DXGI (integrated vs dedicated device)?

Question

How do I filter GPUs by type in DXGI (integrated vs dedicated device)?

Noah Thompson 5

Hello! I have written an extension for the Elgato Stream Deck using C++ and Microsoft DXGI (available here) that queries the utilization of the user's GPU and displays it on the Stream Deck. I need to be able to filter out integrated GPUs and only display dedicated GPU devices for the user to select. Is this possible in DXGI? Or via another Microsoft library?

0 comments

2 answers

Your answer

Answer 1

After doing some digging into Microsoft's documentation, I was able to find the DXCore library. This library allowed me to interop with DXGI and filter GPUs by type. This can be achieved like this:

IDXGIFactory1* factory = nullptr;
winrt::com_ptr<IDXCoreAdapterFactory> coreFactory;

HRESULT result = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&factory);

if (FAILED(result)) {
    Log("Failed to create factory object.");
    return;
}

if (FAILED(DXCoreCreateAdapterFactory(coreFactory.put()))) {
    Log("Failed to create core factory object.");
    return;
}

UINT index;
IDXGIAdapter1* adapter = nullptr;
winrt::com_ptr<IDXCoreAdapter> coreAdapter = nullptr;


while (factory->EnumAdapters1(index, &adapter) != DXGI_ERROR_NOT_FOUND) {
    DXGI_ADAPTER_DESC desc;
    adapter->GetDesc(&desc);

	if (FAILED(coreFactory->GetAdapterByLuid(desc.AdapterLuid, coreAdapter.put()))) {
	    Log("Failed to get core adapter.");
	    adapter->Release();
	    ++index;
	    continue;
	}
	
	if (!coreAdapter->IsPropertySupported(DXCoreAdapterProperty::IsIntegrated) || !coreAdapter->IsPropertySupported(DXCoreAdapterProperty::IsHardware)) {
	    Log("Adapter does not support required properties.");
	    adapter->Release();
	    ++index;
	    continue;
	}
	
	bool isIntegrated;
	bool isHardwareAdapter;
	
	if (FAILED(coreAdapter->GetProperty(DXCoreAdapterProperty::IsIntegrated, &isIntegrated))) {
	    Log("Failed to get integrated property.");
	    adapter->Release();
	    ++index;
	    continue;
	}
	
	if (FAILED(coreAdapter->GetProperty(DXCoreAdapterProperty::IsHardware, &isHardwareAdapter))) {
	    Log("Failed to get hardware property.");
	    adapter->Release();
	    ++index;
	    continue;
	}
	
	if (!isHardwareAdapter) {
	    Log("Adapter is not a hardware adapter.");
	    adapter->Release();
	    ++index;
	    continue;
	}
	
	if (isIntegrated) {
	    Log("Adapter is iGPU.");
	    adapter->Release();
	    ++index;
	    continue;
	}
}

Please let me know if there is any feedback on this approach! Worked for me with an AMD iGPU.

Noah Thompson 5 Reputation points

2024-12-24T04:09:30.4066667+00:00

@Castorix31 @Darran Rowe Please let me know if you guys have any feedback for me on this!
Castorix31 91,876 Reputation points

2024-12-24T06:47:35.2166667+00:00

It works for me with :

Intel(R) HD Graphics on Windows 10 22H2

Answer 2

Castorix31 91,876

A way is to test UMA (Unified Memory Architecture).

This works for me with my old "Intel(R) HD Graphics" integrated GPU :

IDXGIFactory1* pFactory = NULL;
HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory);
if (SUCCEEDED(hr))
{
				IDXGIAdapter1* pAdapter1 = NULL;
				UINT nAdapterIndex = 0;
				TCHAR wsText[255];
				while (pFactory->EnumAdapters1(nAdapterIndex, &pAdapter1) != DXGI_ERROR_NOT_FOUND)
				{
					DXGI_ADAPTER_DESC1 desc;
					pAdapter1->GetDesc1(&desc);		

					wsprintf(wsText, TEXT("GPU n°%d: %s\r\n"), nAdapterIndex, desc.Description);
					OutputDebugString(wsText);

					ID3D12Device* pD3D12Device = NULL;
					hr = D3D12CreateDevice(pAdapter1, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&pD3D12Device));
					if (SUCCEEDED(hr))
					{
						D3D12_FEATURE_DATA_ARCHITECTURE1 architecture1 = {};
						if (SUCCEEDED(pD3D12Device->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE1, &architecture1, sizeof(architecture1))))
						{
							wsprintf(wsText, TEXT("Type : %s\r\n"), architecture1.UMA ? L"Integrated" : L"Dedicated");
							OutputDebugString(wsText);						
						}
						pD3D12Device->Release();
					}
					pAdapter1->Release();
					nAdapterIndex++;
				}
				pFactory->Release();
}

Darran Rowe 2,616 Reputation points

2024-12-21T20:29:09.63+00:00

Does this work with mobile GPUs? I know that some gaming laptops have GPUs that share system memory.
Noah Thompson 5 Reputation points

2024-12-22T00:13:07.3833333+00:00

Hi Castorix31 and Darran, unfortunately it does not. I tried this with a laptop using an AMD Ryzen 8945HS with a Radeon 780M iGPU, and it did not filter it out. Open to other solutions. Thank you for providing me with a fast response however!

Castorix31 91,876

Another idea with D3DKMT (still only tested on my Intel GPU...)

In the loop, to replace D3D12 test :

							D3DKMT_OPENADAPTERFROMLUID oa{};
							oa.AdapterLuid = desc.AdapterLuid;
							NTSTATUS nNTStatus = D3DKMTOpenAdapterFromLuid(&oa);
							if (nNTStatus == 0)
							{
								D3DKMT_QUERYADAPTERINFO qai;
								D3DKMT_WDDM_1_3_CAPS caps;
								qai.hAdapter = oa.hAdapter;
								qai.Type = KMTQAITYPE_WDDM_1_3_CAPS;
								qai.pPrivateDriverData = (void*)&caps;
								qai.PrivateDriverDataSize = sizeof(caps);
								nNTStatus = D3DKMTQueryAdapterInfo(&qai);
								// In case both are returned...
								if (caps.IsHybridIntegratedGPU)
								{
									wsprintf(wsText, TEXT("Type : Integrated\r\n"), caps.IsHybridIntegratedGPU);
									OutputDebugString(wsText);
								}
								if (caps.IsHybridDiscreteGPU)
								{
									wsprintf(wsText, TEXT("Type : Dedicated\r\n"), caps.IsHybridDiscreteGPU);
									OutputDebugString(wsText);
								}

								D3DKMT_CLOSEADAPTER ca;
								ca.hAdapter = oa.hAdapter;
								D3DKMTCloseAdapter(&ca);
							}

Darran Rowe 2,616 Reputation points

2024-12-22T23:44:50.7333333+00:00

@Castorix31

This seems better in general, but it now fails for a discrete GPU as is.

I'm wondering if the DXGI_ADAPTER_DESC1 will help here. This has to be queried for the LUID anyway, but the DedicatedVideoMemory field and the Flags field can be used.

My GPU, which is a discrete GPU, gives a non zero value for DedicatedVideoMemory. However, neither the IsHybridIntegratedGPU or IsHybridDiscreteGPU flags are set. So I am wondering if checking to see if the GPU has dedicated video memory will allow for the assumption that it is a plug in card.

The reason why I also mention the Flags is that EnumAdapters(1) will enumerate the WARP adapter. The DXGI_ADAPTER_DESC structure doesn't list any dedicated video memory so it does look like some of the hardware adapter types, but the Flags field in DXGI_ADAPTER_DESC1 contains a flag to indicate that it is a software adapter. So filtering out adapters if the Flags field isn't 0 seems to be a pretty safe bet too. Unless GetDesc3 is used. If DXGI_ADAPTER_DESC3 is used then checking if the bottom two bits are set seems to be the best option.
Castorix31 91,876 Reputation points

2024-12-23T08:00:50.53+00:00

So I am wondering if checking to see if the GPU has dedicated video memory will allow for the assumption that it is a plug in card.

I had tested DedicatedVideoMemory, but it is filled on my integrated Intel GPU ( in this test they compare it to a IGPU_MEM value : https://github.com/ploosh-alt/obs-studio/blob/edea059a0e4d081294cae9fd3ff3cc37119a2586/plugins/obs-qsv11/QSV_HevcEncoder.cpp#L153)

Share via

How do I filter GPUs by type in DXGI (integrated vs dedicated device)?

2 answers

Your answer