Add basic Adapter blocklist

Adds a basic adapter blocklist and adds two cases to it.

By default, the blocklist is disabled until Chromium can enable it
explicitly - perhaps based on --enable-unsafe-webgpu or some other
flag. It will be switched to default to true in the future.

about://gpu would disable the blocklist so all the adapters are
visible there, but WebGPU would enable it. Trusted users of Dawn
that are aware of potential bugs may also disable it.
One downside is that about://gpu won't surface directly that an
adapter is on the system, but blocklisted for WebGPU. Something
like that can be added in the future, if necessary.

In the future, this should probably be merged with Chromium's
software_rendering_list.json, but that list doesn't support
multi-adapter systems well (for blocklisting just one adapter),
and it doesn't understand all the information we need for the
current blocklist.

Bug: dawn:1254, dawn:1196, tint:1753
Change-Id: I992bcd10dd5d3f5b23319fc4ec699b06bb1117da
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/119061
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Austin Eng <enga@chromium.org>
Reviewed-by: Ben Clayton <bclayton@google.com>

include/dawn/native/DawnNative.h

@@ -181,6 +181,9 @@ class DAWN_NATIVE_EXPORT Instance {
     // Enable debug capture on Dawn startup
     void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup);
 
+    // Enable / disable the adapter blocklist.
+    void EnableAdapterBlocklist(bool enable);
+
     // TODO(dawn:1374) Deprecate this once it is passed via the descriptor.
     void SetPlatform(dawn::platform::Platform* platform);
 

src/dawn/native/DawnNative.cpp

@@ -235,6 +235,10 @@ void Instance::EnableBeginCaptureOnStartup(bool beginCaptureOnStartup) {
     mImpl->EnableBeginCaptureOnStartup(beginCaptureOnStartup);
 }
 
+void Instance::EnableAdapterBlocklist(bool enable) {
+    mImpl->EnableAdapterBlocklist(enable);
+}
+
 // TODO(dawn:1374) Deprecate this once it is passed via the descriptor.
 void Instance::SetPlatform(dawn::platform::Platform* platform) {
     mImpl->SetPlatform(platform);

src/dawn/native/Instance.cpp

@@ -439,6 +439,14 @@ bool InstanceBase::IsBeginCaptureOnStartupEnabled() const {
     return mBeginCaptureOnStartup;
 }
 
+void InstanceBase::EnableAdapterBlocklist(bool enable) {
+    mEnableAdapterBlocklist = enable;
+}
+
+bool InstanceBase::IsAdapterBlocklistEnabled() const {
+    return mEnableAdapterBlocklist;
+}
+
 void InstanceBase::SetPlatform(dawn::platform::Platform* platform) {
     if (platform == nullptr) {
         mPlatform = mDefaultPlatform.get();

src/dawn/native/Instance.h

@@ -88,6 +88,11 @@ class InstanceBase final : public RefCountedWithExternalCount {
     void EnableBeginCaptureOnStartup(bool beginCaptureOnStartup);
     bool IsBeginCaptureOnStartupEnabled() const;
 
+    // TODO(crbug.com/dawn/1495): Move this to a Toggle, perhaps on RequestAdapterOptions
+    // after Toggle refactor is complete.
+    void EnableAdapterBlocklist(bool enable);
+    bool IsAdapterBlocklistEnabled() const;
+
     // TODO(dawn:1374): SetPlatform should become a private helper, and SetPlatformForTesting
     // will become the NOT thread-safe testing version exposed for special testing cases.
     void SetPlatform(dawn::platform::Platform* platform);
@@ -134,6 +139,7 @@ class InstanceBase final : public RefCountedWithExternalCount {
     bool mDiscoveredDefaultAdapters = false;
 
     bool mBeginCaptureOnStartup = false;
+    bool mEnableAdapterBlocklist = false;
     BackendValidationLevel mBackendValidationLevel = BackendValidationLevel::Disabled;
 
     dawn::platform::Platform* mPlatform = nullptr;

src/dawn/native/d3d12/AdapterD3D12.cpp

@@ -17,6 +17,7 @@
 #include <string>
 
 #include "dawn/common/Constants.h"
+#include "dawn/common/Platform.h"
 #include "dawn/common/WindowsUtils.h"
 #include "dawn/native/Instance.h"
 #include "dawn/native/d3d12/BackendD3D12.h"
@@ -98,6 +99,16 @@ MaybeError Adapter::InitializeImpl() {
         mDriverDescription = std::string("D3D12 driver version ") + mDriverVersion.ToString();
     }
 
+    if (GetInstance()->IsAdapterBlocklistEnabled()) {
+#if DAWN_PLATFORM_IS(X86)
+        DAWN_INVALID_IF(mDeviceInfo.shaderModel >= 60,
+                        "D3D12 x86 adapter is blocklisted. See https://crbug.com/tint/1753.");
+
+        DAWN_INVALID_IF(
+            gpu_info::IsNvidia(mVendorId),
+            "D3D12 NVIDIA x86 adapter is blocklisted. See https://crbug.com/dawn/1196.");
+#endif
+    }
     return {};
 }
 

src/dawn/tests/DawnNativeTest.cpp

@@ -46,6 +46,7 @@ DawnNativeTest::~DawnNativeTest() {
 
 void DawnNativeTest::SetUp() {
     instance = std::make_unique<dawn::native::Instance>();
+    instance->EnableAdapterBlocklist(false);
     platform = CreateTestPlatform();
     dawn::native::FromAPI(instance->Get())->SetPlatformForTesting(platform.get());
 

src/dawn/tests/DawnTest.cpp

@@ -306,6 +306,7 @@ std::unique_ptr<dawn::native::Instance> DawnTestEnvironment::CreateInstanceAndDi
     auto instance = std::make_unique<dawn::native::Instance>();
     instance->EnableBeginCaptureOnStartup(mBeginCaptureOnStartup);
     instance->SetBackendValidationLevel(mBackendValidationLevel);
+    instance->EnableAdapterBlocklist(false);
 
 #ifdef DAWN_ENABLE_BACKEND_OPENGLES
     if (GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM").first.empty()) {

src/dawn/tests/end2end/DeviceInitializationTests.cpp

@@ -74,6 +74,7 @@ TEST_F(DeviceInitializationTest, DeviceOutlivesInstance) {
     std::vector<wgpu::AdapterProperties> availableAdapterProperties;
     {
         auto instance = std::make_unique<dawn::native::Instance>();
+        instance->EnableAdapterBlocklist(false);
         instance->DiscoverDefaultAdapters();
         for (const dawn::native::Adapter& adapter : instance->GetAdapters()) {
             wgpu::AdapterProperties properties;
@@ -90,6 +91,7 @@ TEST_F(DeviceInitializationTest, DeviceOutlivesInstance) {
         wgpu::Device device;
 
         auto instance = std::make_unique<dawn::native::Instance>();
+        instance->EnableAdapterBlocklist(false);
         instance->DiscoverDefaultAdapters();
         for (dawn::native::Adapter& adapter : instance->GetAdapters()) {
             wgpu::AdapterProperties properties;
@@ -120,6 +122,7 @@ TEST_F(DeviceInitializationTest, AdapterOutlivesInstance) {
     std::vector<wgpu::AdapterProperties> availableAdapterProperties;
     {
         auto instance = std::make_unique<dawn::native::Instance>();
+        instance->EnableAdapterBlocklist(false);
         instance->DiscoverDefaultAdapters();
         for (const dawn::native::Adapter& adapter : instance->GetAdapters()) {
             wgpu::AdapterProperties properties;
@@ -136,6 +139,7 @@ TEST_F(DeviceInitializationTest, AdapterOutlivesInstance) {
         wgpu::Adapter adapter;
 
         auto instance = std::make_unique<dawn::native::Instance>();
+        instance->EnableAdapterBlocklist(false);
         // Save a pointer to the instance.
         // It will only be valid as long as the instance is alive.
         WGPUInstance unsafeInstancePtr = instance->Get();