Dawn: Promote DisallowUnsafeAPIs as instance toggle
This CL add Instance and Adapter toggle stage, and promote
DisallowUnsafeAPIs as an instance toggle, and can be required using
DawnTogglesDescriptor chained in instance descriptor when creating
instance. The instance's toggles state will get inherited to adapters
and devices it create. Related tests are implemented and updated.
Toggles inheritance can be overriden if not forced, so requiring
DisallowUnsafeAPIs when creating device is still available and working
like before.
Note that currently we don't have toggle of adapter stage, and can not
require toggles when creating adapter, until follow up CLs implement it.
Currently the toggles state of a adapter is simply inherited from
instance.
Bug: dawn:1495
Change-Id: I6bf7aa0f950a99451afcc2cab5322c924b7d9520
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/122021
Commit-Queue: Zhaoming Jiang <zhaoming.jiang@intel.com>
Reviewed-by: Austin Eng <enga@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
diff --git a/dawn.json b/dawn.json
index 49eb767..20be786 100644
--- a/dawn.json
+++ b/dawn.json
@@ -174,7 +174,7 @@
"tags": ["dawn", "native"],
"category": "structure",
"chained": "in",
- "chain roots": ["device descriptor"],
+ "chain roots": ["instance descriptor", "device descriptor"],
"members": [
{"name": "enabled toggles count", "type": "uint32_t", "default": 0},
{"name": "enabled toggles", "type": "char", "annotation": "const*const*", "length": "enabled toggles count"},
diff --git a/include/dawn/native/DawnNative.h b/include/dawn/native/DawnNative.h
index 033dee2..7e1315c 100644
--- a/include/dawn/native/DawnNative.h
+++ b/include/dawn/native/DawnNative.h
@@ -51,9 +51,7 @@
// Each toggle is assigned with a TogglesStage, indicating the validation and earliest usage
// time of the toggle.
-// TODO(dawn:1495): Currently all toggles are device toggles, i.e. of Device toggle stage. Add
-// instance and adapter stages after instance and adapter toggles implemented.
-enum class ToggleStage { Device };
+enum class ToggleStage { Instance, Adapter, Device };
// A struct to record the information of a toggle. A toggle is a code path in Dawn device that
// can be manually configured to run or not outside Dawn, including workarounds, special
diff --git a/src/dawn/native/Adapter.cpp b/src/dawn/native/Adapter.cpp
index a23b6e1..73286e0 100644
--- a/src/dawn/native/Adapter.cpp
+++ b/src/dawn/native/Adapter.cpp
@@ -27,10 +27,11 @@
namespace dawn::native {
-AdapterBase::AdapterBase(InstanceBase* instance, wgpu::BackendType backend)
- : mInstance(instance), mBackend(backend) {
- mSupportedFeatures.EnableFeature(Feature::DawnNative);
- mSupportedFeatures.EnableFeature(Feature::DawnInternalUsages);
+AdapterBase::AdapterBase(InstanceBase* instance,
+ wgpu::BackendType backend,
+ const TogglesState& adapterToggles)
+ : mInstance(instance), mBackend(backend), mTogglesState(adapterToggles) {
+ ASSERT(adapterToggles.GetStage() == ToggleStage::Adapter);
}
AdapterBase::~AdapterBase() = default;
@@ -39,6 +40,8 @@
DAWN_TRY_CONTEXT(InitializeImpl(), "initializing adapter (backend=%s)", mBackend);
InitializeVendorArchitectureImpl();
+ mSupportedFeatures.EnableFeature(Feature::DawnNative);
+ mSupportedFeatures.EnableFeature(Feature::DawnInternalUsages);
InitializeSupportedFeaturesImpl();
DAWN_TRY_CONTEXT(
@@ -206,6 +209,10 @@
return true;
}
+const TogglesState& AdapterBase::GetTogglesState() const {
+ return mTogglesState;
+}
+
MaybeError AdapterBase::ValidateFeatureSupportedWithDeviceToggles(
wgpu::FeatureName feature,
const TogglesState& deviceTogglesState) {
@@ -229,8 +236,8 @@
const DeviceDescriptor* descriptor) {
ASSERT(descriptor != nullptr);
- // Create device toggles state from required toggles descriptor.
- // TODO(dawn:1495): After implementing adapter toggles, also inherite adapter toggles state.
+ // Create device toggles state from required toggles descriptor and inherited adapter toggles
+ // state.
const DawnTogglesDescriptor* deviceTogglesDesc = nullptr;
FindInChain(descriptor->nextInChain, &deviceTogglesDesc);
@@ -261,21 +268,21 @@
deviceTogglesDesc = &convertedDeviceTogglesDesc;
}
- // Create device toggles state from user-given toggles descriptor, and set up forced and default
- // toggles.
- // TODO(dawn:1495): After implementing adapter toggles, device toggles state should also inherit
- // from adapter toggles state.
+ // Create device toggles state.
TogglesState deviceToggles =
TogglesState::CreateFromTogglesDescriptor(deviceTogglesDesc, ToggleStage::Device);
+ deviceToggles.InheritFrom(mTogglesState);
// Default toggles for all backend
deviceToggles.Default(Toggle::LazyClearResourceOnFirstUse, true);
- deviceToggles.Default(Toggle::DisallowUnsafeAPIs, true);
+
// Backend-specific forced and default device toggles
SetupBackendDeviceToggles(&deviceToggles);
// Validate all required features are supported by the adapter and suitable under given toggles.
- // TODO(dawn:1495): After implementing adapter toggles, validate supported features using
- // adapter toggles instead of device toggles.
+ // Note that certain toggles in device toggles state may be overriden by user and different from
+ // the adapter toggles state.
+ // TODO(dawn:1495): After implementing adapter toggles, decide whether we should validate
+ // supported features using adapter toggles or device toggles.
for (uint32_t i = 0; i < descriptor->requiredFeaturesCount; ++i) {
wgpu::FeatureName feature = descriptor->requiredFeatures[i];
DAWN_TRY(ValidateFeatureSupportedWithDeviceToggles(feature, deviceToggles));
diff --git a/src/dawn/native/Adapter.h b/src/dawn/native/Adapter.h
index 86f97e1..08e0f23 100644
--- a/src/dawn/native/Adapter.h
+++ b/src/dawn/native/Adapter.h
@@ -34,7 +34,9 @@
class AdapterBase : public RefCounted {
public:
- AdapterBase(InstanceBase* instance, wgpu::BackendType backend);
+ AdapterBase(InstanceBase* instance,
+ wgpu::BackendType backend,
+ const TogglesState& adapterToggles);
~AdapterBase() override;
MaybeError Initialize();
@@ -65,6 +67,9 @@
void SetUseTieredLimits(bool useTieredLimits);
+ // Get the actual toggles state of the adapter.
+ const TogglesState& GetTogglesState() const;
+
virtual bool SupportsExternalImages() const = 0;
protected:
@@ -113,6 +118,10 @@
virtual MaybeError ResetInternalDeviceForTestingImpl();
Ref<InstanceBase> mInstance;
wgpu::BackendType mBackend;
+
+ // Adapter toggles state, currently only inherited from instance toggles state.
+ TogglesState mTogglesState;
+
CombinedLimits mLimits;
bool mUseTieredLimits = false;
};
diff --git a/src/dawn/native/BackendConnection.cpp b/src/dawn/native/BackendConnection.cpp
index 8dcd19f..303b8b1 100644
--- a/src/dawn/native/BackendConnection.cpp
+++ b/src/dawn/native/BackendConnection.cpp
@@ -13,6 +13,7 @@
// limitations under the License.
#include "dawn/native/BackendConnection.h"
+#include "dawn/native/Instance.h"
namespace dawn::native {
@@ -28,7 +29,8 @@
}
ResultOrError<std::vector<Ref<AdapterBase>>> BackendConnection::DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* options) {
+ const AdapterDiscoveryOptionsBase* options,
+ const TogglesState& adapterToggles) {
return DAWN_VALIDATION_ERROR("DiscoverAdapters not implemented for this backend.");
}
diff --git a/src/dawn/native/BackendConnection.h b/src/dawn/native/BackendConnection.h
index 04fe35b..8d279df 100644
--- a/src/dawn/native/BackendConnection.h
+++ b/src/dawn/native/BackendConnection.h
@@ -20,6 +20,7 @@
#include "dawn/native/Adapter.h"
#include "dawn/native/DawnNative.h"
+#include "dawn/native/Toggles.h"
namespace dawn::native {
@@ -35,11 +36,13 @@
// Returns all the adapters for the system that can be created by the backend, without extra
// options (such as debug adapters, custom driver libraries, etc.)
- virtual std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() = 0;
+ virtual std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+ const TogglesState& adapterToggles) = 0;
// Returns new adapters created with the backend-specific options.
virtual ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* options);
+ const AdapterDiscoveryOptionsBase* options,
+ const TogglesState& adapterToggles);
private:
InstanceBase* mInstance = nullptr;
diff --git a/src/dawn/native/Instance.cpp b/src/dawn/native/Instance.cpp
index a2c490d..7035c6f 100644
--- a/src/dawn/native/Instance.cpp
+++ b/src/dawn/native/Instance.cpp
@@ -23,6 +23,7 @@
#include "dawn/native/ChainUtils_autogen.h"
#include "dawn/native/ErrorData.h"
#include "dawn/native/Surface.h"
+#include "dawn/native/Toggles.h"
#include "dawn/native/ValidationUtils_autogen.h"
#include "dawn/platform/DawnPlatform.h"
@@ -110,18 +111,30 @@
// static
Ref<InstanceBase> InstanceBase::Create(const InstanceDescriptor* descriptor) {
- Ref<InstanceBase> instance = AcquireRef(new InstanceBase);
static constexpr InstanceDescriptor kDefaultDesc = {};
if (descriptor == nullptr) {
descriptor = &kDefaultDesc;
}
+
+ const DawnTogglesDescriptor* instanceTogglesDesc = nullptr;
+ FindInChain(descriptor->nextInChain, &instanceTogglesDesc);
+
+ // Set up the instance toggle state from toggles descriptor
+ TogglesState instanceToggles =
+ TogglesState::CreateFromTogglesDescriptor(instanceTogglesDesc, ToggleStage::Instance);
+ // By default enable the DisallowUnsafeAPIs instance toggle, it will be inherited to adapters
+ // and devices created by this instance if not overriden.
+ // TODO(dawn:1685): Rename DisallowUnsafeAPIs to AllowUnsafeAPIs, and change relating logic.
+ instanceToggles.Default(Toggle::DisallowUnsafeAPIs, true);
+
+ Ref<InstanceBase> instance = AcquireRef(new InstanceBase(instanceToggles));
if (instance->ConsumedError(instance->Initialize(descriptor))) {
return nullptr;
}
return instance;
}
-InstanceBase::InstanceBase() = default;
+InstanceBase::InstanceBase(const TogglesState& instanceToggles) : mToggles(instanceToggles) {}
InstanceBase::~InstanceBase() = default;
@@ -138,7 +151,9 @@
// TODO(crbug.com/dawn/832): make the platform an initialization parameter of the instance.
MaybeError InstanceBase::Initialize(const InstanceDescriptor* descriptor) {
- DAWN_TRY(ValidateSingleSType(descriptor->nextInChain, wgpu::SType::DawnInstanceDescriptor));
+ DAWN_TRY(ValidateSTypes(descriptor->nextInChain, {{wgpu::SType::DawnInstanceDescriptor},
+ {wgpu::SType::DawnTogglesDescriptor}}));
+
const DawnInstanceDescriptor* dawnDesc = nullptr;
FindInChain(descriptor->nextInChain, &dawnDesc);
if (dawnDesc != nullptr) {
@@ -280,7 +295,14 @@
// Query and merge all default adapters for all backends
for (std::unique_ptr<BackendConnection>& backend : mBackends) {
- std::vector<Ref<AdapterBase>> backendAdapters = backend->DiscoverDefaultAdapters();
+ // Set up toggles state for default adapters, currently adapter don't have a toggles
+ // descriptor so just inherit from instance toggles.
+ // TODO(dawn:1495): Handle the adapter toggles descriptor after implemented.
+ TogglesState adapterToggles = TogglesState(ToggleStage::Adapter);
+ adapterToggles.InheritFrom(mToggles);
+
+ std::vector<Ref<AdapterBase>> backendAdapters =
+ backend->DiscoverDefaultAdapters(adapterToggles);
for (Ref<AdapterBase>& adapter : backendAdapters) {
ASSERT(adapter->GetBackendType() == backend->GetType());
@@ -306,6 +328,10 @@
return true;
}
+const TogglesState& InstanceBase::GetTogglesState() const {
+ return mToggles;
+}
+
const ToggleInfo* InstanceBase::GetToggleInfo(const char* toggleName) {
return mTogglesInfo.GetToggleInfo(toggleName);
}
@@ -397,8 +423,14 @@
}
foundBackend = true;
+ // Set up toggles state for default adapters, currently adapter don't have a toggles
+ // descriptor so just inherit from instance toggles.
+ // TODO(dawn:1495): Handle the adapter toggles descriptor after implemented.
+ TogglesState adapterToggles = TogglesState(ToggleStage::Adapter);
+ adapterToggles.InheritFrom(mToggles);
+
std::vector<Ref<AdapterBase>> newAdapters;
- DAWN_TRY_ASSIGN(newAdapters, backend->DiscoverAdapters(options));
+ DAWN_TRY_ASSIGN(newAdapters, backend->DiscoverAdapters(options, adapterToggles));
for (Ref<AdapterBase>& adapter : newAdapters) {
ASSERT(adapter->GetBackendType() == backend->GetType());
diff --git a/src/dawn/native/Instance.h b/src/dawn/native/Instance.h
index f6d518f..6ae291c 100644
--- a/src/dawn/native/Instance.h
+++ b/src/dawn/native/Instance.h
@@ -72,6 +72,8 @@
return false;
}
+ const TogglesState& GetTogglesState() const;
+
// Used to query the details of a toggle. Return nullptr if toggleName is not a valid name
// of a toggle supported in Dawn.
const ToggleInfo* GetToggleInfo(const char* toggleName);
@@ -113,7 +115,7 @@
Surface* APICreateSurface(const SurfaceDescriptor* descriptor);
private:
- InstanceBase();
+ explicit InstanceBase(const TogglesState& instanceToggles);
~InstanceBase() override;
void WillDropLastExternalRef() override;
@@ -150,6 +152,8 @@
std::vector<std::unique_ptr<BackendConnection>> mBackends;
std::vector<Ref<AdapterBase>> mAdapters;
+ TogglesState mToggles;
+
FeaturesInfo mFeaturesInfo;
TogglesInfo mTogglesInfo;
diff --git a/src/dawn/native/Toggles.cpp b/src/dawn/native/Toggles.cpp
index 39e1fc2..028ded6 100644
--- a/src/dawn/native/Toggles.cpp
+++ b/src/dawn/native/Toggles.cpp
@@ -176,7 +176,7 @@
{"disallow_unsafe_apis",
"Produces validation errors on API entry points or parameter combinations that aren't "
"considered secure yet.",
- "http://crbug.com/1138528", ToggleStage::Device}},
+ "http://crbug.com/1138528", ToggleStage::Instance}},
{Toggle::FlushBeforeClientWaitSync,
{"flush_before_client_wait_sync",
"Call glFlush before glClientWaitSync to work around bugs in the latter",
@@ -447,7 +447,9 @@
Toggle toggle = togglesInfo.ToggleNameToEnum(togglesDesc->enabledToggles[i]);
if (toggle != Toggle::InvalidEnum) {
const ToggleInfo* toggleInfo = togglesInfo.GetToggleInfo(toggle);
- if (toggleInfo->stage == requiredStage) {
+ // Accept the required toggles of current and earlier stage to allow override
+ // inheritance.
+ if (toggleInfo->stage <= requiredStage) {
togglesState.mTogglesSet.Set(toggle, true);
togglesState.mEnabledToggles.Set(toggle, true);
}
@@ -457,7 +459,9 @@
Toggle toggle = togglesInfo.ToggleNameToEnum(togglesDesc->disabledToggles[i]);
if (toggle != Toggle::InvalidEnum) {
const ToggleInfo* toggleInfo = togglesInfo.GetToggleInfo(toggle);
- if (toggleInfo->stage == requiredStage) {
+ // Accept the required toggles of current and earlier stage to allow override
+ // inheritance.
+ if (toggleInfo->stage <= requiredStage) {
togglesState.mTogglesSet.Set(toggle, true);
togglesState.mEnabledToggles.Set(toggle, false);
}
@@ -467,6 +471,30 @@
return togglesState;
}
+TogglesState& TogglesState::InheritFrom(const TogglesState& inheritedToggles) {
+ ASSERT(inheritedToggles.GetStage() < mStage);
+
+ // Do inheritance. All toggles that are force-set in the inherited toggles states would
+ // be force-set in the result toggles state, and all toggles that are set in the inherited
+ // toggles states and not required in current toggles state would be set in the result toggles
+ // state.
+ for (uint32_t i : inheritedToggles.mTogglesSet.Iterate()) {
+ const Toggle& toggle = static_cast<Toggle>(i);
+ ASSERT(TogglesInfo::GetToggleInfo(toggle)->stage < mStage);
+ bool isEnabled = inheritedToggles.mEnabledToggles.Has(toggle);
+ bool isForced = inheritedToggles.mForcedToggles.Has(toggle);
+ // Only inherit a toggle if it is not set by user requirement or is forced in earlier stage.
+ // In this way we allow user requirement override the inheritance if not forced.
+ if (!mTogglesSet.Has(toggle) || isForced) {
+ mTogglesSet.Set(toggle, true);
+ mEnabledToggles.Set(toggle, isEnabled);
+ mForcedToggles.Set(toggle, isForced);
+ }
+ }
+
+ return *this;
+}
+
// Set a toggle to given state, if the toggle has not been already set. Do nothing otherwise.
void TogglesState::Default(Toggle toggle, bool enabled) {
ASSERT(toggle != Toggle::InvalidEnum);
@@ -492,6 +520,15 @@
mForcedToggles.Set(toggle, true);
}
+TogglesState& TogglesState::SetForTesting(Toggle toggle, bool enabled, bool forced) {
+ ASSERT(toggle != Toggle::InvalidEnum);
+ mTogglesSet.Set(toggle, true);
+ mEnabledToggles.Set(toggle, enabled);
+ mForcedToggles.Set(toggle, forced);
+
+ return *this;
+}
+
bool TogglesState::IsSet(Toggle toggle) const {
// Ensure that the toggle never used earlier than its stage.
ASSERT(TogglesInfo::GetToggleInfo(toggle)->stage <= mStage);
diff --git a/src/dawn/native/Toggles.h b/src/dawn/native/Toggles.h
index 6d75fff..064ebf1 100644
--- a/src/dawn/native/Toggles.h
+++ b/src/dawn/native/Toggles.h
@@ -127,17 +127,25 @@
// Create an empty toggles state of given stage
explicit TogglesState(ToggleStage stage);
- // Create a RequiredTogglesSet from a DawnTogglesDescriptor, only considering toggles of
+ // Create a TogglesState from a DawnTogglesDescriptor, only considering toggles of
// required toggle stage.
static TogglesState CreateFromTogglesDescriptor(const DawnTogglesDescriptor* togglesDesc,
ToggleStage requiredStage);
+ // Inherit from a given toggles state of earlier stage, only inherit the forced and the
+ // unrequired toggles to allow overriding. Return *this to allow method chaining manner.
+ TogglesState& InheritFrom(const TogglesState& inheritedToggles);
+
// Set a toggle of the same stage of toggles state stage if and only if it is not already set.
void Default(Toggle toggle, bool enabled);
// Force set a toggle of same stage of toggles state stage. A force-set toggle will get
// inherited to all later stage as forced.
void ForceSet(Toggle toggle, bool enabled);
+ // Set a toggle of any stage for testing propose. Return *this to allow method chaining
+ // manner.
+ TogglesState& SetForTesting(Toggle toggle, bool enabled, bool forced);
+
// Return whether the toggle is set or not. Force-set is always treated as set.
bool IsSet(Toggle toggle) const;
// Return true if and only if the toggle is set to true.
diff --git a/src/dawn/native/d3d12/AdapterD3D12.cpp b/src/dawn/native/d3d12/AdapterD3D12.cpp
index 8fd7993..bd261c4 100644
--- a/src/dawn/native/d3d12/AdapterD3D12.cpp
+++ b/src/dawn/native/d3d12/AdapterD3D12.cpp
@@ -28,8 +28,10 @@
namespace dawn::native::d3d12 {
-Adapter::Adapter(Backend* backend, ComPtr<IDXGIAdapter3> hardwareAdapter)
- : AdapterBase(backend->GetInstance(), wgpu::BackendType::D3D12),
+Adapter::Adapter(Backend* backend,
+ ComPtr<IDXGIAdapter3> hardwareAdapter,
+ const TogglesState& adapterToggles)
+ : AdapterBase(backend->GetInstance(), wgpu::BackendType::D3D12, adapterToggles),
mHardwareAdapter(hardwareAdapter),
mBackend(backend) {}
diff --git a/src/dawn/native/d3d12/AdapterD3D12.h b/src/dawn/native/d3d12/AdapterD3D12.h
index 0535ee1..4309dff4 100644
--- a/src/dawn/native/d3d12/AdapterD3D12.h
+++ b/src/dawn/native/d3d12/AdapterD3D12.h
@@ -26,7 +26,9 @@
class Adapter : public AdapterBase {
public:
- Adapter(Backend* backend, ComPtr<IDXGIAdapter3> hardwareAdapter);
+ Adapter(Backend* backend,
+ ComPtr<IDXGIAdapter3> hardwareAdapter,
+ const TogglesState& adapterToggles);
~Adapter() override;
// AdapterBase Implementation
diff --git a/src/dawn/native/d3d12/BackendD3D12.cpp b/src/dawn/native/d3d12/BackendD3D12.cpp
index ac2f5f2..6e5fff5 100644
--- a/src/dawn/native/d3d12/BackendD3D12.cpp
+++ b/src/dawn/native/d3d12/BackendD3D12.cpp
@@ -69,10 +69,12 @@
}
ResultOrError<Ref<AdapterBase>> CreateAdapterFromIDXGIAdapter(Backend* backend,
- ComPtr<IDXGIAdapter> dxgiAdapter) {
+ ComPtr<IDXGIAdapter> dxgiAdapter,
+ const TogglesState& adapterToggles) {
ComPtr<IDXGIAdapter3> dxgiAdapter3;
DAWN_TRY(CheckHRESULT(dxgiAdapter.As(&dxgiAdapter3), "DXGIAdapter retrieval"));
- Ref<Adapter> adapter = AcquireRef(new Adapter(backend, std::move(dxgiAdapter3)));
+ Ref<Adapter> adapter =
+ AcquireRef(new Adapter(backend, std::move(dxgiAdapter3), adapterToggles));
DAWN_TRY(adapter->Initialize());
return {std::move(adapter)};
@@ -271,9 +273,9 @@
return mFunctions.get();
}
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
AdapterDiscoveryOptions options;
- auto result = DiscoverAdapters(&options);
+ auto result = DiscoverAdapters(&options, adapterToggles);
if (result.IsError()) {
GetInstance()->ConsumedError(result.AcquireError());
return {};
@@ -282,7 +284,8 @@
}
ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* optionsBase) {
+ const AdapterDiscoveryOptionsBase* optionsBase,
+ const TogglesState& adapterToggles) {
ASSERT(optionsBase->backendType == WGPUBackendType_D3D12);
const AdapterDiscoveryOptions* options =
static_cast<const AdapterDiscoveryOptions*>(optionsBase);
@@ -291,7 +294,8 @@
if (options->dxgiAdapter != nullptr) {
// |dxgiAdapter| was provided. Discover just that adapter.
Ref<AdapterBase> adapter;
- DAWN_TRY_ASSIGN(adapter, CreateAdapterFromIDXGIAdapter(this, options->dxgiAdapter));
+ DAWN_TRY_ASSIGN(adapter,
+ CreateAdapterFromIDXGIAdapter(this, options->dxgiAdapter, adapterToggles));
adapters.push_back(std::move(adapter));
return std::move(adapters);
}
@@ -304,7 +308,8 @@
}
ASSERT(dxgiAdapter != nullptr);
- ResultOrError<Ref<AdapterBase>> adapter = CreateAdapterFromIDXGIAdapter(this, dxgiAdapter);
+ ResultOrError<Ref<AdapterBase>> adapter =
+ CreateAdapterFromIDXGIAdapter(this, dxgiAdapter, adapterToggles);
if (adapter.IsError()) {
GetInstance()->ConsumedError(adapter.AcquireError());
continue;
diff --git a/src/dawn/native/d3d12/BackendD3D12.h b/src/dawn/native/d3d12/BackendD3D12.h
index 4d0184a..f2bb13f 100644
--- a/src/dawn/native/d3d12/BackendD3D12.h
+++ b/src/dawn/native/d3d12/BackendD3D12.h
@@ -75,9 +75,11 @@
const PlatformFunctions* GetFunctions() const;
- std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+ std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+ const TogglesState& adapterToggles) override;
ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* optionsBase) override;
+ const AdapterDiscoveryOptionsBase* optionsBase,
+ const TogglesState& adapterToggles) override;
private:
// Acquiring DXC version information and store the result in mDxcVersionInfo. This function
diff --git a/src/dawn/native/metal/BackendMTL.h b/src/dawn/native/metal/BackendMTL.h
index 75be730..b5b9601 100644
--- a/src/dawn/native/metal/BackendMTL.h
+++ b/src/dawn/native/metal/BackendMTL.h
@@ -26,9 +26,11 @@
explicit Backend(InstanceBase* instance);
~Backend() override;
- std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+ std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+ const TogglesState& adapterToggles) override;
ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* optionsBase) override;
+ const AdapterDiscoveryOptionsBase* optionsBase,
+ const TogglesState& adapterToggles) override;
};
} // namespace dawn::native::metal
diff --git a/src/dawn/native/metal/BackendMTL.mm b/src/dawn/native/metal/BackendMTL.mm
index 5a1b166..512ab99 100644
--- a/src/dawn/native/metal/BackendMTL.mm
+++ b/src/dawn/native/metal/BackendMTL.mm
@@ -255,8 +255,8 @@
class Adapter : public AdapterBase {
public:
- Adapter(InstanceBase* instance, id<MTLDevice> device)
- : AdapterBase(instance, wgpu::BackendType::Metal), mDevice(device) {
+ Adapter(InstanceBase* instance, id<MTLDevice> device, const TogglesState& requiredAdapterToggle)
+ : AdapterBase(instance, wgpu::BackendType::Metal, requiredAdapterToggle), mDevice(device) {
mName = std::string([[*mDevice name] UTF8String]);
PCIIDs ids;
@@ -774,9 +774,9 @@
Backend::~Backend() = default;
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
AdapterDiscoveryOptions options;
- auto result = DiscoverAdapters(&options);
+ auto result = DiscoverAdapters(&options, adapterToggles);
if (result.IsError()) {
GetInstance()->ConsumedError(result.AcquireError());
return {};
@@ -785,7 +785,8 @@
}
ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* optionsBase) {
+ const AdapterDiscoveryOptionsBase* optionsBase,
+ const TogglesState& adapterToggles) {
ASSERT(optionsBase->backendType == WGPUBackendType_Metal);
std::vector<Ref<AdapterBase>> adapters;
@@ -793,7 +794,7 @@
NSRef<NSArray<id<MTLDevice>>> devices = AcquireNSRef(MTLCopyAllDevices());
for (id<MTLDevice> device in devices.Get()) {
- Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), device));
+ Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), device, adapterToggles));
if (!GetInstance()->ConsumedError(adapter->Initialize())) {
adapters.push_back(std::move(adapter));
}
@@ -802,7 +803,8 @@
// iOS only has a single device so MTLCopyAllDevices doesn't exist there.
#if defined(DAWN_PLATFORM_IOS)
- Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), MTLCreateSystemDefaultDevice()));
+ Ref<Adapter> adapter =
+ AcquireRef(new Adapter(GetInstance(), MTLCreateSystemDefaultDevice(), adapterToggles));
if (!GetInstance()->ConsumedError(adapter->Initialize())) {
adapters.push_back(std::move(adapter));
}
diff --git a/src/dawn/native/null/DeviceNull.cpp b/src/dawn/native/null/DeviceNull.cpp
index c9d32ad..9827bdf 100644
--- a/src/dawn/native/null/DeviceNull.cpp
+++ b/src/dawn/native/null/DeviceNull.cpp
@@ -30,7 +30,12 @@
// Implementation of pre-Device objects: the null adapter, null backend connection and Connect()
-Adapter::Adapter(InstanceBase* instance) : AdapterBase(instance, wgpu::BackendType::Null) {
+Adapter::Adapter(InstanceBase* instance)
+ : Adapter(instance,
+ TogglesState(ToggleStage::Adapter).InheritFrom(instance->GetTogglesState())) {}
+
+Adapter::Adapter(InstanceBase* instance, const TogglesState& adapterToggles)
+ : AdapterBase(instance, wgpu::BackendType::Null, adapterToggles) {
mVendorId = 0;
mDeviceId = 0;
mName = "Null backend";
@@ -85,11 +90,12 @@
explicit Backend(InstanceBase* instance)
: BackendConnection(instance, wgpu::BackendType::Null) {}
- std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override {
+ std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+ const TogglesState& adapterToggles) override {
// There is always a single Null adapter because it is purely CPU based and doesn't
// depend on the system.
std::vector<Ref<AdapterBase>> adapters;
- Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance()));
+ Ref<Adapter> adapter = AcquireRef(new Adapter(GetInstance(), adapterToggles));
adapters.push_back(std::move(adapter));
return adapters;
}
diff --git a/src/dawn/native/null/DeviceNull.h b/src/dawn/native/null/DeviceNull.h
index b53b036..d5ea66f 100644
--- a/src/dawn/native/null/DeviceNull.h
+++ b/src/dawn/native/null/DeviceNull.h
@@ -171,7 +171,10 @@
class Adapter : public AdapterBase {
public:
+ // Create null adapter without providing toggles state for testing, only inherit instance's
+ // toggles state
explicit Adapter(InstanceBase* instance);
+ Adapter(InstanceBase* instance, const TogglesState& adapterToggles);
~Adapter() override;
// AdapterBase Implementation
diff --git a/src/dawn/native/opengl/AdapterGL.cpp b/src/dawn/native/opengl/AdapterGL.cpp
index b965e42..4bffcf6 100644
--- a/src/dawn/native/opengl/AdapterGL.cpp
+++ b/src/dawn/native/opengl/AdapterGL.cpp
@@ -53,8 +53,10 @@
} // anonymous namespace
-Adapter::Adapter(InstanceBase* instance, wgpu::BackendType backendType)
- : AdapterBase(instance, backendType) {}
+Adapter::Adapter(InstanceBase* instance,
+ wgpu::BackendType backendType,
+ const TogglesState& adapterToggle)
+ : AdapterBase(instance, backendType, adapterToggle) {}
MaybeError Adapter::InitializeGLFunctions(void* (*getProc)(const char*)) {
// Use getProc to populate the dispatch table
diff --git a/src/dawn/native/opengl/AdapterGL.h b/src/dawn/native/opengl/AdapterGL.h
index 918e439..22b47f0 100644
--- a/src/dawn/native/opengl/AdapterGL.h
+++ b/src/dawn/native/opengl/AdapterGL.h
@@ -23,7 +23,9 @@
class Adapter : public AdapterBase {
public:
- Adapter(InstanceBase* instance, wgpu::BackendType backendType);
+ Adapter(InstanceBase* instance,
+ wgpu::BackendType backendType,
+ const TogglesState& adapterToggle);
MaybeError InitializeGLFunctions(void* (*getProc)(const char*));
diff --git a/src/dawn/native/opengl/BackendGL.cpp b/src/dawn/native/opengl/BackendGL.cpp
index ac4e374..dec7976 100644
--- a/src/dawn/native/opengl/BackendGL.cpp
+++ b/src/dawn/native/opengl/BackendGL.cpp
@@ -33,7 +33,7 @@
Backend::Backend(InstanceBase* instance, wgpu::BackendType backendType)
: BackendConnection(instance, backendType) {}
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
std::vector<Ref<AdapterBase>> adapters;
#if DAWN_PLATFORM_IS(WINDOWS)
const char* eglLib = "libEGL.dll";
@@ -69,7 +69,7 @@
context->MakeCurrent();
- auto result = DiscoverAdapters(&options);
+ auto result = DiscoverAdapters(&options, adapterToggles);
if (result.IsError()) {
GetInstance()->ConsumedError(result.AcquireError());
@@ -84,7 +84,8 @@
}
ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* optionsBase) {
+ const AdapterDiscoveryOptionsBase* optionsBase,
+ const TogglesState& adapterToggles) {
// TODO(cwallez@chromium.org): For now only create a single OpenGL adapter because don't
// know how to handle MakeCurrent.
DAWN_INVALID_IF(mCreatedAdapter, "The OpenGL backend can only create a single adapter.");
@@ -95,8 +96,8 @@
DAWN_INVALID_IF(options->getProc == nullptr, "AdapterDiscoveryOptions::getProc must be set");
- Ref<Adapter> adapter = AcquireRef(
- new Adapter(GetInstance(), static_cast<wgpu::BackendType>(optionsBase->backendType)));
+ Ref<Adapter> adapter = AcquireRef(new Adapter(
+ GetInstance(), static_cast<wgpu::BackendType>(optionsBase->backendType), adapterToggles));
DAWN_TRY(adapter->InitializeGLFunctions(options->getProc));
DAWN_TRY(adapter->Initialize());
diff --git a/src/dawn/native/opengl/BackendGL.h b/src/dawn/native/opengl/BackendGL.h
index dc8fea5..e31dd8d 100644
--- a/src/dawn/native/opengl/BackendGL.h
+++ b/src/dawn/native/opengl/BackendGL.h
@@ -26,9 +26,11 @@
public:
Backend(InstanceBase* instance, wgpu::BackendType backendType);
- std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+ std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+ const TogglesState& adapterToggles) override;
ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* options) override;
+ const AdapterDiscoveryOptionsBase* option,
+ const TogglesState& adapterToggless) override;
private:
bool mCreatedAdapter = false;
diff --git a/src/dawn/native/vulkan/AdapterVk.cpp b/src/dawn/native/vulkan/AdapterVk.cpp
index 19556823..556f5f8 100644
--- a/src/dawn/native/vulkan/AdapterVk.cpp
+++ b/src/dawn/native/vulkan/AdapterVk.cpp
@@ -58,8 +58,9 @@
Adapter::Adapter(InstanceBase* instance,
VulkanInstance* vulkanInstance,
- VkPhysicalDevice physicalDevice)
- : AdapterBase(instance, wgpu::BackendType::Vulkan),
+ VkPhysicalDevice physicalDevice,
+ const TogglesState& adapterToggles)
+ : AdapterBase(instance, wgpu::BackendType::Vulkan, adapterToggles),
mPhysicalDevice(physicalDevice),
mVulkanInstance(vulkanInstance) {}
diff --git a/src/dawn/native/vulkan/AdapterVk.h b/src/dawn/native/vulkan/AdapterVk.h
index 8619808..ebdbfcb 100644
--- a/src/dawn/native/vulkan/AdapterVk.h
+++ b/src/dawn/native/vulkan/AdapterVk.h
@@ -29,7 +29,8 @@
public:
Adapter(InstanceBase* instance,
VulkanInstance* vulkanInstance,
- VkPhysicalDevice physicalDevice);
+ VkPhysicalDevice physicalDevice,
+ const TogglesState& adapterToggles);
~Adapter() override;
// AdapterBase Implementation
diff --git a/src/dawn/native/vulkan/BackendVk.cpp b/src/dawn/native/vulkan/BackendVk.cpp
index e90cee6..7b5c41f 100644
--- a/src/dawn/native/vulkan/BackendVk.cpp
+++ b/src/dawn/native/vulkan/BackendVk.cpp
@@ -457,9 +457,9 @@
Backend::~Backend() = default;
-std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters() {
+std::vector<Ref<AdapterBase>> Backend::DiscoverDefaultAdapters(const TogglesState& adapterToggles) {
AdapterDiscoveryOptions options;
- auto result = DiscoverAdapters(&options);
+ auto result = DiscoverAdapters(&options, adapterToggles);
if (result.IsError()) {
GetInstance()->ConsumedError(result.AcquireError());
return {};
@@ -468,7 +468,8 @@
}
ResultOrError<std::vector<Ref<AdapterBase>>> Backend::DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* optionsBase) {
+ const AdapterDiscoveryOptionsBase* optionsBase,
+ const TogglesState& adapterToggles) {
ASSERT(optionsBase->backendType == WGPUBackendType_Vulkan);
const AdapterDiscoveryOptions* options =
@@ -497,8 +498,8 @@
const std::vector<VkPhysicalDevice>& physicalDevices =
mVulkanInstances[icd]->GetPhysicalDevices();
for (uint32_t i = 0; i < physicalDevices.size(); ++i) {
- Ref<Adapter> adapter =
- AcquireRef(new Adapter(instance, mVulkanInstances[icd].Get(), physicalDevices[i]));
+ Ref<Adapter> adapter = AcquireRef(new Adapter(instance, mVulkanInstances[icd].Get(),
+ physicalDevices[i], adapterToggles));
if (instance->ConsumedError(adapter->Initialize())) {
continue;
}
diff --git a/src/dawn/native/vulkan/BackendVk.h b/src/dawn/native/vulkan/BackendVk.h
index f912344..f8f0339 100644
--- a/src/dawn/native/vulkan/BackendVk.h
+++ b/src/dawn/native/vulkan/BackendVk.h
@@ -91,9 +91,11 @@
MaybeError Initialize();
- std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters() override;
+ std::vector<Ref<AdapterBase>> DiscoverDefaultAdapters(
+ const TogglesState& adapterToggles) override;
ResultOrError<std::vector<Ref<AdapterBase>>> DiscoverAdapters(
- const AdapterDiscoveryOptionsBase* optionsBase) override;
+ const AdapterDiscoveryOptionsBase* optionsBase,
+ const TogglesState& adapterToggles) override;
private:
ityp::array<ICD, Ref<VulkanInstance>, 2> mVulkanInstances = {};
diff --git a/src/dawn/tests/BUILD.gn b/src/dawn/tests/BUILD.gn
index 35e2165..4c3d14c 100644
--- a/src/dawn/tests/BUILD.gn
+++ b/src/dawn/tests/BUILD.gn
@@ -309,6 +309,7 @@
"unittests/SubresourceStorageTests.cpp",
"unittests/SystemUtilsTests.cpp",
"unittests/ToBackendTests.cpp",
+ "unittests/ToggleTests.cpp",
"unittests/TypedIntegerTests.cpp",
"unittests/UnicodeTests.cpp",
"unittests/native/AllowedErrorTests.cpp",
diff --git a/src/dawn/tests/DawnNativeTest.cpp b/src/dawn/tests/DawnNativeTest.cpp
index bd5cf45..e8f0628 100644
--- a/src/dawn/tests/DawnNativeTest.cpp
+++ b/src/dawn/tests/DawnNativeTest.cpp
@@ -45,7 +45,19 @@
}
void DawnNativeTest::SetUp() {
- instance = std::make_unique<dawn::native::Instance>();
+ // Create an instance with toggle DisallowUnsafeApis disabled, which would be inherited to
+ // adapter and device toggles and allow us to test unsafe apis (including experimental
+ // features).
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor instanceToggles = {};
+ instanceToggles.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ instanceToggles.disabledTogglesCount = 1;
+ instanceToggles.disabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceToggles.chain;
+
+ instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
instance->EnableAdapterBlocklist(false);
platform = CreateTestPlatform();
dawn::native::FromAPI(instance->Get())->SetPlatformForTesting(platform.get());
@@ -78,16 +90,7 @@
}
WGPUDevice DawnNativeTest::CreateTestDevice() {
- // Disabled disallowing unsafe APIs so we can test them.
- wgpu::DeviceDescriptor deviceDescriptor = {};
- wgpu::DawnTogglesDescriptor deviceTogglesDesc = {};
- deviceDescriptor.nextInChain = &deviceTogglesDesc;
-
- const char* toggle = "disallow_unsafe_apis";
- deviceTogglesDesc.disabledToggles = &toggle;
- deviceTogglesDesc.disabledTogglesCount = 1;
-
- return adapter.CreateDevice(&deviceDescriptor);
+ return adapter.CreateDevice();
}
// static
diff --git a/src/dawn/tests/DawnTest.cpp b/src/dawn/tests/DawnTest.cpp
index e70b263..3765c44 100644
--- a/src/dawn/tests/DawnTest.cpp
+++ b/src/dawn/tests/DawnTest.cpp
@@ -73,6 +73,56 @@
result << std::endl;
}
+// A helper class to create DawnTogglesDescriptor from test params
+struct ParamTogglesHelper {
+ std::vector<const char*> enabledToggles;
+ std::vector<const char*> disabledToggles;
+ wgpu::DawnTogglesDescriptor togglesDesc;
+
+ // Create toggles descriptor for a given stage from test param and global test env
+ ParamTogglesHelper(const AdapterTestParam& testParam, dawn::native::ToggleStage requiredStage) {
+ for (const char* requireEnabledWorkaround : testParam.forceEnabledWorkarounds) {
+ const dawn::native::ToggleInfo* info =
+ gTestEnv->GetInstance()->GetToggleInfo(requireEnabledWorkaround);
+ ASSERT(info != nullptr);
+ if (info->stage == requiredStage) {
+ enabledToggles.push_back(requireEnabledWorkaround);
+ }
+ }
+ for (const char* requireDisabledWorkaround : testParam.forceDisabledWorkarounds) {
+ const dawn::native::ToggleInfo* info =
+ gTestEnv->GetInstance()->GetToggleInfo(requireDisabledWorkaround);
+ ASSERT(info != nullptr);
+ if (info->stage == requiredStage) {
+ disabledToggles.push_back(requireDisabledWorkaround);
+ }
+ }
+
+ for (const std::string& toggle : gTestEnv->GetEnabledToggles()) {
+ const dawn::native::ToggleInfo* info =
+ gTestEnv->GetInstance()->GetToggleInfo(toggle.c_str());
+ ASSERT(info != nullptr);
+ if (info->stage == requiredStage) {
+ enabledToggles.push_back(info->name);
+ }
+ }
+
+ for (const std::string& toggle : gTestEnv->GetDisabledToggles()) {
+ const dawn::native::ToggleInfo* info =
+ gTestEnv->GetInstance()->GetToggleInfo(toggle.c_str());
+ ASSERT(info != nullptr);
+ if (info->stage == requiredStage) {
+ disabledToggles.push_back(info->name);
+ }
+ }
+
+ togglesDesc = {};
+ togglesDesc.enabledToggles = enabledToggles.data();
+ togglesDesc.enabledTogglesCount = enabledToggles.size();
+ togglesDesc.disabledToggles = disabledToggles.data();
+ togglesDesc.disabledTogglesCount = disabledToggles.size();
+ }
+};
} // anonymous namespace
DawnTestBase::PrintToStringParamName::PrintToStringParamName(const char* test) : mTest(test) {}
@@ -307,7 +357,19 @@
}
std::unique_ptr<dawn::native::Instance> DawnTestEnvironment::CreateInstanceAndDiscoverAdapters() {
- auto instance = std::make_unique<dawn::native::Instance>();
+ // Create an instance with toggle DisallowUnsafeApis disabled, which would be inherited to
+ // adapter and device toggles and allow us to test unsafe apis (including experimental
+ // features).
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor instanceToggles = {};
+ instanceToggles.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ instanceToggles.disabledTogglesCount = 1;
+ instanceToggles.disabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceToggles.chain;
+
+ auto instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
instance->EnableBeginCaptureOnStartup(mBeginCaptureOnStartup);
instance->SetBackendValidationLevel(mBackendValidationLevel);
instance->EnableAdapterBlocklist(false);
@@ -577,8 +639,9 @@
gCurrentTest = this;
DawnProcTable procs = dawn::native::GetProcs();
- // Override procs to provide harness-specific behavior to always select the null adapter,
- // and to allow fixture-specific overriding of the test device with CreateDeviceImpl.
+ // Override procs to provide harness-specific behavior to always select the adapter required in
+ // testing parameter, and to allow fixture-specific overriding of the test device with
+ // CreateDeviceImpl.
procs.instanceRequestAdapter = [](WGPUInstance instance, const WGPURequestAdapterOptions*,
WGPURequestAdapterCallback callback, void* userdata) {
ASSERT(gCurrentTest);
@@ -872,55 +935,26 @@
WGPUDevice DawnTestBase::CreateDeviceImpl(std::string isolationKey) {
// Create the device from the adapter
- for (const char* forceEnabledWorkaround : mParam.forceEnabledWorkarounds) {
- ASSERT(gTestEnv->GetInstance()->GetToggleInfo(forceEnabledWorkaround) != nullptr);
- }
- for (const char* forceDisabledWorkaround : mParam.forceDisabledWorkarounds) {
- ASSERT(gTestEnv->GetInstance()->GetToggleInfo(forceDisabledWorkaround) != nullptr);
- }
-
- std::vector<const char*> forceEnabledToggles = mParam.forceEnabledWorkarounds;
- std::vector<const char*> forceDisabledToggles = mParam.forceDisabledWorkarounds;
-
std::vector<wgpu::FeatureName> requiredFeatures = GetRequiredFeatures();
wgpu::SupportedLimits supportedLimits;
mBackendAdapter.GetLimits(reinterpret_cast<WGPUSupportedLimits*>(&supportedLimits));
wgpu::RequiredLimits requiredLimits = GetRequiredLimits(supportedLimits);
- // Disabled disallowing unsafe APIs so we can test them.
- forceDisabledToggles.push_back("disallow_unsafe_apis");
-
- for (const std::string& toggle : gTestEnv->GetEnabledToggles()) {
- const dawn::native::ToggleInfo* info =
- gTestEnv->GetInstance()->GetToggleInfo(toggle.c_str());
- ASSERT(info != nullptr);
- forceEnabledToggles.push_back(info->name);
- }
-
- for (const std::string& toggle : gTestEnv->GetDisabledToggles()) {
- const dawn::native::ToggleInfo* info =
- gTestEnv->GetInstance()->GetToggleInfo(toggle.c_str());
- ASSERT(info != nullptr);
- forceDisabledToggles.push_back(info->name);
- }
-
wgpu::DeviceDescriptor deviceDescriptor = {};
deviceDescriptor.requiredLimits = &requiredLimits;
deviceDescriptor.requiredFeatures = requiredFeatures.data();
deviceDescriptor.requiredFeaturesCount = requiredFeatures.size();
- wgpu::DawnTogglesDescriptor deviceTogglesDesc = {};
- deviceDescriptor.nextInChain = &deviceTogglesDesc;
- deviceTogglesDesc.enabledToggles = forceEnabledToggles.data();
- deviceTogglesDesc.enabledTogglesCount = forceEnabledToggles.size();
- deviceTogglesDesc.disabledToggles = forceDisabledToggles.data();
- deviceTogglesDesc.disabledTogglesCount = forceDisabledToggles.size();
-
wgpu::DawnCacheDeviceDescriptor cacheDesc = {};
- deviceTogglesDesc.nextInChain = &cacheDesc;
+ deviceDescriptor.nextInChain = &cacheDesc;
cacheDesc.isolationKey = isolationKey.c_str();
+ // Note that DisallowUnsafeApis is disabled when creating testing instance and would be
+ // inherited to all adapters' toggles set.
+ ParamTogglesHelper deviceTogglesHelper(mParam, dawn::native::ToggleStage::Device);
+ cacheDesc.nextInChain = &deviceTogglesHelper.togglesDesc;
+
return mBackendAdapter.CreateDevice(&deviceDescriptor);
}
@@ -931,7 +965,9 @@
// to CreateDeviceImpl.
mNextIsolationKeyQueue.push(std::move(isolationKey));
- // This descriptor doesn't matter since device selection is overriden by CreateDeviceImpl.
+ // RequestDevice is overriden by CreateDeviceImpl and device descriptor is ignored by it. Give
+ // an empty descriptor.
+ // TODO(dawn:1684): Replace empty DeviceDescriptor with nullptr after Dawn wire support it.
wgpu::DeviceDescriptor deviceDesc = {};
mAdapter.RequestDevice(
&deviceDesc,
@@ -988,7 +1024,9 @@
"_" + ::testing::UnitTest::GetInstance()->current_test_info()->name();
mWireHelper->BeginWireTrace(traceName.c_str());
- // These options are unused since adapter selection is overriden to use the test params
+ // RequestAdapter is overriden to ignore RequestAdapterOptions, but dawn_wire requires a valid
+ // pointer, so give a empty option.
+ // TODO(dawn:1684): Replace empty RequestAdapterOptions with nullptr after Dawn wire support it.
wgpu::RequestAdapterOptions options = {};
mInstance.RequestAdapter(
&options,
diff --git a/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp b/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp
index d77de5b..073b896 100644
--- a/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp
+++ b/src/dawn/tests/end2end/ExperimentalDP4aTests.cpp
@@ -86,7 +86,8 @@
// Adapter support the feature
IsDP4aSupportedOnAdapter() &&
// Proper toggle, disallow_unsafe_apis and use_dxc if d3d12
- // Note that "disallow_unsafe_apis" is always disabled in DawnTestBase::CreateDeviceImpl.
+ // Note that "disallow_unsafe_apis" is always disabled in
+ // DawnTestEnvironment::CreateInstanceAndDiscoverAdapters.
!HasToggleEnabled("disallow_unsafe_apis") && UseDxcEnabledOrNonD3D12();
const bool deviceSupportDP4AFeature =
device.HasFeature(wgpu::FeatureName::ChromiumExperimentalDp4a);
diff --git a/src/dawn/tests/unittests/FeatureTests.cpp b/src/dawn/tests/unittests/FeatureTests.cpp
index 45351d9..f879225 100644
--- a/src/dawn/tests/unittests/FeatureTests.cpp
+++ b/src/dawn/tests/unittests/FeatureTests.cpp
@@ -16,6 +16,7 @@
#include "dawn/native/Features.h"
#include "dawn/native/Instance.h"
+#include "dawn/native/Toggles.h"
#include "dawn/native/null/DeviceNull.h"
#include "gtest/gtest.h"
@@ -24,7 +25,11 @@
FeatureTests()
: testing::Test(),
mInstanceBase(dawn::native::InstanceBase::Create()),
- mAdapterBase(mInstanceBase.Get()) {}
+ mAdapterBase(mInstanceBase.Get()),
+ mUnsafeAdapterBase(
+ mInstanceBase.Get(),
+ dawn::native::TogglesState(dawn::native::ToggleStage::Adapter)
+ .SetForTesting(dawn::native::Toggle::DisallowUnsafeAPIs, false, false)) {}
std::vector<wgpu::FeatureName> GetAllFeatureNames() {
std::vector<wgpu::FeatureName> allFeatureNames(kTotalFeaturesCount);
@@ -38,8 +43,13 @@
static_cast<size_t>(dawn::native::Feature::EnumCount);
protected:
+ // By default DisallowUnsafeAPIs is enabled in this instance.
Ref<dawn::native::InstanceBase> mInstanceBase;
+ // The adapter that inherit toggles states from the instance, also have DisallowUnsafeAPIs
+ // enabled.
dawn::native::null::Adapter mAdapterBase;
+ // The adapter that override DisallowUnsafeAPIs to disabled in toggles state.
+ dawn::native::null::Adapter mUnsafeAdapterBase;
};
// Test the creation of a device will fail if the requested feature is not supported on the
@@ -52,14 +62,11 @@
std::vector<wgpu::FeatureName> featureNamesWithoutOne = kAllFeatureNames;
featureNamesWithoutOne.erase(featureNamesWithoutOne.begin() + i);
- mAdapterBase.SetSupportedFeatures(featureNamesWithoutOne);
- dawn::native::Adapter adapterWithoutFeature(&mAdapterBase);
-
- // Test that creating device with and without DisallowUnsafeApis toggle disabled will both
- // failed.
-
- // Without disabling DisallowUnsafeApis toggle
+ // Test that the adapter with unsafe apis disallowed validate features as expected.
{
+ mAdapterBase.SetSupportedFeatures(featureNamesWithoutOne);
+ dawn::native::Adapter adapterWithoutFeature(&mAdapterBase);
+
wgpu::DeviceDescriptor deviceDescriptor;
wgpu::FeatureName featureName = FeatureEnumToAPIFeature(notSupportedFeature);
deviceDescriptor.requiredFeatures = &featureName;
@@ -70,48 +77,46 @@
ASSERT_EQ(nullptr, deviceWithFeature);
}
- // Disabling DisallowUnsafeApis toggle
+ // Test that the adapter with unsafe apis allowed validate features as expected.
{
- wgpu::DeviceDescriptor unsafeDeviceDescriptor;
- wgpu::FeatureName featureName = FeatureEnumToAPIFeature(notSupportedFeature);
- unsafeDeviceDescriptor.requiredFeatures = &featureName;
- unsafeDeviceDescriptor.requiredFeaturesCount = 1;
+ mUnsafeAdapterBase.SetSupportedFeatures(featureNamesWithoutOne);
+ dawn::native::Adapter adapterWithoutFeature(&mUnsafeAdapterBase);
- wgpu::DawnTogglesDescriptor deviceTogglesDesc;
- unsafeDeviceDescriptor.nextInChain = &deviceTogglesDesc;
- const char* toggle = "disallow_unsafe_apis";
- deviceTogglesDesc.disabledToggles = &toggle;
- deviceTogglesDesc.disabledTogglesCount = 1;
+ wgpu::DeviceDescriptor deviceDescriptor;
+ wgpu::FeatureName featureName = FeatureEnumToAPIFeature(notSupportedFeature);
+ deviceDescriptor.requiredFeatures = &featureName;
+ deviceDescriptor.requiredFeaturesCount = 1;
WGPUDevice deviceWithFeature = adapterWithoutFeature.CreateDevice(
- reinterpret_cast<const WGPUDeviceDescriptor*>(&unsafeDeviceDescriptor));
+ reinterpret_cast<const WGPUDeviceDescriptor*>(&deviceDescriptor));
ASSERT_EQ(nullptr, deviceWithFeature);
}
}
}
-// Test creating device requiring a supported feature can succeed (with DisallowUnsafeApis guarded
-// for experimental features), and Device.GetEnabledFeatures() can return the names of the enabled
-// features correctly.
+// Test creating device requiring a supported feature can succeed (with DisallowUnsafeApis adapter
+// toggle disabled for experimental features), and Device.GetEnabledFeatures() can return the names
+// of the enabled features correctly.
TEST_F(FeatureTests, RequireAndGetEnabledFeatures) {
dawn::native::Adapter adapter(&mAdapterBase);
+ dawn::native::Adapter unsafeAdapter(&mUnsafeAdapterBase);
dawn::native::FeaturesInfo featuresInfo;
for (size_t i = 0; i < kTotalFeaturesCount; ++i) {
dawn::native::Feature feature = static_cast<dawn::native::Feature>(i);
wgpu::FeatureName featureName = FeatureEnumToAPIFeature(feature);
- // Test with DisallowUnsafeApis not disabled.
- {
- wgpu::DeviceDescriptor deviceDescriptor;
- deviceDescriptor.requiredFeatures = &featureName;
- deviceDescriptor.requiredFeaturesCount = 1;
+ wgpu::DeviceDescriptor deviceDescriptor;
+ deviceDescriptor.requiredFeatures = &featureName;
+ deviceDescriptor.requiredFeaturesCount = 1;
+ // Test with the adapter with DisallowUnsafeApis adapter toggles not disabled.
+ {
dawn::native::DeviceBase* deviceBase = dawn::native::FromAPI(adapter.CreateDevice(
reinterpret_cast<const WGPUDeviceDescriptor*>(&deviceDescriptor)));
- // Device creation should fail if requiring experimental features without disabling
- // DisallowUnsafeApis
+ // Creating a device with experimental feature requires the adapter disables
+ // DisallowUnsafeApis, otherwise a validation error.
if (featuresInfo.GetFeatureInfo(featureName)->featureState ==
dawn::native::FeatureInfo::FeatureState::Experimental) {
ASSERT_EQ(nullptr, deviceBase);
@@ -126,20 +131,11 @@
}
}
- // Test with DisallowUnsafeApis disabled, creating device should always succeed.
+ // Test with the adapter with DisallowUnsafeApis toggles disabled, creating device should
+ // always succeed.
{
- wgpu::DeviceDescriptor unsafeDeviceDescriptor;
- unsafeDeviceDescriptor.requiredFeatures = &featureName;
- unsafeDeviceDescriptor.requiredFeaturesCount = 1;
-
- const char* const disableToggles[] = {"disallow_unsafe_apis"};
- wgpu::DawnTogglesDescriptor toggleDesc;
- toggleDesc.disabledToggles = disableToggles;
- toggleDesc.disabledTogglesCount = 1;
- unsafeDeviceDescriptor.nextInChain = &toggleDesc;
-
- dawn::native::DeviceBase* deviceBase = dawn::native::FromAPI(adapter.CreateDevice(
- reinterpret_cast<const WGPUDeviceDescriptor*>(&unsafeDeviceDescriptor)));
+ dawn::native::DeviceBase* deviceBase = dawn::native::FromAPI(unsafeAdapter.CreateDevice(
+ reinterpret_cast<const WGPUDeviceDescriptor*>(&deviceDescriptor)));
ASSERT_NE(nullptr, deviceBase);
ASSERT_EQ(1u, deviceBase->APIEnumerateFeatures(nullptr));
diff --git a/src/dawn/tests/unittests/ToggleTests.cpp b/src/dawn/tests/unittests/ToggleTests.cpp
new file mode 100644
index 0000000..5157805
--- /dev/null
+++ b/src/dawn/tests/unittests/ToggleTests.cpp
@@ -0,0 +1,202 @@
+// Copyright 2023 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <memory>
+#include <vector>
+
+#include "dawn/dawn_proc.h"
+#include "dawn/native/Adapter.h"
+#include "dawn/native/DawnNative.h"
+#include "dawn/native/Device.h"
+#include "dawn/native/Instance.h"
+#include "dawn/native/Toggles.h"
+#include "dawn/native/dawn_platform.h"
+#include "dawn/tests/MockCallback.h"
+#include "dawn/utils/SystemUtils.h"
+#include "dawn/utils/WGPUHelpers.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+using testing::Contains;
+using testing::MockCallback;
+using testing::NotNull;
+using testing::SaveArg;
+using testing::StrEq;
+
+class InstanceToggleTest : public testing::Test {
+ protected:
+ void SetUp() override { dawnProcSetProcs(&dawn::native::GetProcs()); }
+
+ void TearDown() override { dawnProcSetProcs(nullptr); }
+};
+
+// Test that instance toggles are set by requirement or default as expected.
+TEST_F(InstanceToggleTest, InstanceTogglesSet) {
+ auto validateInstanceToggles = [](const dawn::native::Instance* nativeInstance,
+ std::initializer_list<const char*> enableToggles,
+ std::initializer_list<const char*> disableToggles) {
+ const dawn::native::InstanceBase* instance = dawn::native::FromAPI(nativeInstance->Get());
+ const dawn::native::TogglesState& instanceTogglesState = instance->GetTogglesState();
+ std::vector<const char*> enabledToggles = instanceTogglesState.GetEnabledToggleNames();
+ std::vector<const char*> disabledToggles = instanceTogglesState.GetDisabledToggleNames();
+ EXPECT_EQ(disabledToggles.size(), disableToggles.size());
+ EXPECT_EQ(enabledToggles.size(), enableToggles.size());
+ for (auto* enableToggle : enableToggles) {
+ EXPECT_THAT(enabledToggles, Contains(StrEq(enableToggle)));
+ }
+ for (auto* disableToggle : disableToggles) {
+ EXPECT_THAT(disabledToggles, Contains(StrEq(disableToggle)));
+ }
+ };
+
+ // Create instance with no toggles descriptor
+ {
+ std::unique_ptr<dawn::native::Instance> instance;
+
+ // Create an instance with default toggles, where DisallowUnsafeApis is enabled.
+ instance = std::make_unique<dawn::native::Instance>();
+ validateInstanceToggles(instance.get(), {"disallow_unsafe_apis"}, {});
+ }
+
+ // Create instance with empty toggles descriptor
+ {
+ std::unique_ptr<dawn::native::Instance> instance;
+
+ // Make an instance descriptor chaining an empty toggles descriptor
+ WGPUDawnTogglesDescriptor instanceTogglesDesc = {};
+ instanceTogglesDesc.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceTogglesDesc.chain;
+
+ // Create an instance with default toggles, where DisallowUnsafeApis is enabled.
+ instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
+ validateInstanceToggles(instance.get(), {"disallow_unsafe_apis"}, {});
+ }
+
+ // Create instance with DisallowUnsafeAPIs explicitly enabled in toggles descriptor
+ {
+ std::unique_ptr<dawn::native::Instance> instance;
+
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor instanceTogglesDesc = {};
+ instanceTogglesDesc.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ instanceTogglesDesc.enabledTogglesCount = 1;
+ instanceTogglesDesc.enabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceTogglesDesc.chain;
+
+ // Create an instance with DisallowUnsafeApis explicitly enabled.
+ instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
+ validateInstanceToggles(instance.get(), {disallowUnsafeApisToggle}, {});
+ }
+
+ // Create instance with DisallowUnsafeAPIs explicitly disabled in toggles descriptor
+ {
+ std::unique_ptr<dawn::native::Instance> instance;
+
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor instanceTogglesDesc = {};
+ instanceTogglesDesc.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ instanceTogglesDesc.disabledTogglesCount = 1;
+ instanceTogglesDesc.disabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceTogglesDesc.chain;
+
+ // Create an instance with DisallowUnsafeApis explicitly disabled.
+ instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
+ validateInstanceToggles(instance.get(), {}, {disallowUnsafeApisToggle});
+ }
+}
+
+// Test that instance toggles are inherited to the adapters and devices it creates.
+TEST_F(InstanceToggleTest, InstanceTogglesInheritToAdapterAndDevice) {
+ auto validateInstanceTogglesInheritedToAdapter = [&](dawn::native::Instance* nativeInstance) {
+ dawn::native::InstanceBase* instance = dawn::native::FromAPI(nativeInstance->Get());
+ const dawn::native::TogglesState& instanceTogglesState = instance->GetTogglesState();
+
+ // Discover adapters with default toggles.
+ instance->DiscoverDefaultAdapters();
+
+ // Get the adapter created by instance with default toggles.
+ dawn::native::AdapterBase* nullAdapter = nullptr;
+ for (auto& adapter : instance->GetAdapters()) {
+ if (adapter->GetBackendType() == wgpu::BackendType::Null) {
+ nullAdapter = adapter.Get();
+ break;
+ }
+ }
+ ASSERT_NE(nullAdapter, nullptr);
+ auto& adapterTogglesState = nullAdapter->GetTogglesState();
+
+ // Creater a default device.
+ dawn::native::DeviceBase* nullDevice = nullAdapter->APICreateDevice();
+
+ // Check instance toggles are inherited by adapter and device.
+ dawn::native::TogglesInfo togglesInfo;
+ static_assert(std::is_same_v<std::underlying_type_t<dawn::native::Toggle>, int>);
+ for (int i = 0; i < static_cast<int>(dawn::native::Toggle::EnumCount); i++) {
+ dawn::native::Toggle toggle = static_cast<dawn::native::Toggle>(i);
+ if (togglesInfo.GetToggleInfo(toggle)->stage != dawn::native::ToggleStage::Instance) {
+ continue;
+ }
+ EXPECT_EQ(instanceTogglesState.IsSet(toggle), adapterTogglesState.IsSet(toggle));
+ EXPECT_EQ(instanceTogglesState.IsEnabled(toggle),
+ adapterTogglesState.IsEnabled(toggle));
+ EXPECT_EQ(instanceTogglesState.IsEnabled(toggle), nullDevice->IsToggleEnabled(toggle));
+ }
+
+ nullDevice->Release();
+ };
+
+ // Create instance with DisallowUnsafeAPIs explicitly enabled in toggles descriptor
+ {
+ std::unique_ptr<dawn::native::Instance> instance;
+
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor instanceTogglesDesc = {};
+ instanceTogglesDesc.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ instanceTogglesDesc.enabledTogglesCount = 1;
+ instanceTogglesDesc.enabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceTogglesDesc.chain;
+
+ // Create an instance with DisallowUnsafeApis explicitly enabled.
+ instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
+ validateInstanceTogglesInheritedToAdapter(instance.get());
+ }
+
+ // Create instance with DisallowUnsafeAPIs explicitly disabled in toggles descriptor
+ {
+ std::unique_ptr<dawn::native::Instance> instance;
+
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor instanceTogglesDesc = {};
+ instanceTogglesDesc.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ instanceTogglesDesc.disabledTogglesCount = 1;
+ instanceTogglesDesc.disabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceTogglesDesc.chain;
+
+ // Create an instance with DisallowUnsafeApis explicitly enabled.
+ instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
+ validateInstanceTogglesInheritedToAdapter(instance.get());
+ }
+}
+} // anonymous namespace
diff --git a/src/dawn/tests/unittests/native/DeviceCreationTests.cpp b/src/dawn/tests/unittests/native/DeviceCreationTests.cpp
index 17a94d7..add691a 100644
--- a/src/dawn/tests/unittests/native/DeviceCreationTests.cpp
+++ b/src/dawn/tests/unittests/native/DeviceCreationTests.cpp
@@ -16,8 +16,10 @@
#include <vector>
#include "dawn/dawn_proc.h"
+#include "dawn/native/Adapter.h"
#include "dawn/native/DawnNative.h"
#include "dawn/native/Device.h"
+#include "dawn/native/Toggles.h"
#include "dawn/native/dawn_platform.h"
#include "dawn/tests/MockCallback.h"
#include "dawn/utils/SystemUtils.h"
@@ -37,7 +39,20 @@
void SetUp() override {
dawnProcSetProcs(&dawn::native::GetProcs());
- instance = std::make_unique<dawn::native::Instance>();
+ WGPUInstanceDescriptor safeInstanceDesc = {};
+
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor unsafeInstanceTogglesDesc = {};
+ unsafeInstanceTogglesDesc.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ unsafeInstanceTogglesDesc.disabledTogglesCount = 1;
+ unsafeInstanceTogglesDesc.disabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor unsafeInstanceDesc = {};
+ unsafeInstanceDesc.nextInChain = &unsafeInstanceTogglesDesc.chain;
+
+ // Create an instance with default toggles, where DisallowUnsafeApis is enabled, and create
+ // an adapter from it.
+ instance = std::make_unique<dawn::native::Instance>(&safeInstanceDesc);
instance->DiscoverDefaultAdapters();
for (dawn::native::Adapter& nativeAdapter : instance->GetAdapters()) {
wgpu::AdapterProperties properties;
@@ -48,17 +63,41 @@
break;
}
}
+
+ // Create an instance with toggle DisallowUnsafeApis disabled, and create an unsafe adapter
+ // from it.
+ unsafeInstance = std::make_unique<dawn::native::Instance>(&unsafeInstanceDesc);
+ unsafeInstance->DiscoverDefaultAdapters();
+ for (dawn::native::Adapter& nativeAdapter : unsafeInstance->GetAdapters()) {
+ wgpu::AdapterProperties properties;
+ nativeAdapter.GetProperties(&properties);
+
+ if (properties.backendType == wgpu::BackendType::Null) {
+ unsafeAdapter = wgpu::Adapter(nativeAdapter.Get());
+ break;
+ }
+ }
+
ASSERT_NE(adapter, nullptr);
+ ASSERT_NE(unsafeAdapter, nullptr);
}
void TearDown() override {
adapter = nullptr;
+ unsafeAdapter = nullptr;
instance = nullptr;
+ unsafeInstance = nullptr;
dawnProcSetProcs(nullptr);
}
+ static constexpr size_t kTotalFeaturesCount =
+ static_cast<size_t>(dawn::native::Feature::EnumCount);
+
std::unique_ptr<dawn::native::Instance> instance;
+ std::unique_ptr<dawn::native::Instance> unsafeInstance;
wgpu::Adapter adapter;
+ wgpu::Adapter unsafeAdapter;
+ dawn::native::FeaturesInfo featuresInfo;
};
// Test successful call to CreateDevice with no descriptor
@@ -91,23 +130,53 @@
EXPECT_THAT(toggles, Contains(StrEq(toggle)));
}
-// Test features guarded by toggles are validated when creating devices.
-TEST_F(DeviceCreationTest, CreateDeviceRequiringFeaturesGuardedByToggle) {
- std::vector<wgpu::FeatureName> featuresGuardedByToggle = {
- wgpu::FeatureName::ShaderF16, wgpu::FeatureName::ChromiumExperimentalDp4a};
+// Test experimental features are guarded by DisallowUnsafeApis adapter toggle, it is inherited from
+// instance but can be overriden by device toggles.
+TEST_F(DeviceCreationTest, CreateDeviceRequiringExperimentalFeatures) {
+ // Ensure that DisallowUnsafeApis adapter toggle is enabled on safe adapter.
+ auto safeAdapterBase = dawn::native::FromAPI(adapter.Get());
+ ASSERT_TRUE(
+ safeAdapterBase->GetTogglesState().IsEnabled(dawn::native::Toggle::DisallowUnsafeAPIs));
+ // Ensure that DisallowUnsafeApis adapter toggle is disabled on unsafe adapter.
+ auto unsafeAdapterBase = dawn::native::FromAPI(unsafeAdapter.Get());
+ ASSERT_FALSE(
+ unsafeAdapterBase->GetTogglesState().IsEnabled(dawn::native::Toggle::DisallowUnsafeAPIs));
- for (auto feature : featuresGuardedByToggle) {
+ for (size_t i = 0; i < kTotalFeaturesCount; i++) {
+ dawn::native::Feature feature = static_cast<dawn::native::Feature>(i);
+ wgpu::FeatureName featureName = dawn::native::FeatureEnumToAPIFeature(feature);
+
+ // Only test experimental features.
+ if (featuresInfo.GetFeatureInfo(featureName)->featureState ==
+ dawn::native::FeatureInfo::FeatureState::Stable) {
+ continue;
+ }
+
wgpu::DeviceDescriptor deviceDescriptor;
- deviceDescriptor.requiredFeatures = &feature;
+ deviceDescriptor.requiredFeatures = &featureName;
deviceDescriptor.requiredFeaturesCount = 1;
- // Test creating device without toggle would fail.
+ // Test creating device on the adapter with DisallowUnsafeApis toggle enabled would fail.
{
wgpu::Device device = adapter.CreateDevice(&deviceDescriptor);
EXPECT_EQ(device, nullptr);
}
- // Test creating device without DisallowUnsafeApis toggle disabled.
+ // Test creating device on the adapter with DisallowUnsafeApis toggle disabled would
+ // succeed.
+ {
+ // unsafeAdapter has DisallowUnsafeApis adapter toggle disabled.
+ wgpu::Device device = unsafeAdapter.CreateDevice(&deviceDescriptor);
+ EXPECT_NE(device, nullptr);
+
+ ASSERT_EQ(1u, device.EnumerateFeatures(nullptr));
+ wgpu::FeatureName enabledFeature;
+ device.EnumerateFeatures(&enabledFeature);
+ EXPECT_EQ(enabledFeature, featureName);
+ }
+
+ // Test creating device with DisallowUnsafeApis disabled in device toggle descriptor will
+ // success on both adapter, as device toggles will override the inherited adapter toggles.
{
const char* const disableToggles[] = {"disallow_unsafe_apis"};
wgpu::DawnTogglesDescriptor deviceTogglesDesc;
@@ -115,14 +184,49 @@
deviceTogglesDesc.disabledTogglesCount = 1;
deviceDescriptor.nextInChain = &deviceTogglesDesc;
- wgpu::Device device = adapter.CreateDevice(&deviceDescriptor);
- EXPECT_NE(device, nullptr);
+ // Test on adapter with DisallowUnsafeApis enabled.
+ {
+ wgpu::Device device = adapter.CreateDevice(&deviceDescriptor);
+ EXPECT_NE(device, nullptr);
- ASSERT_EQ(1u, device.EnumerateFeatures(nullptr));
- wgpu::FeatureName enabledFeature;
- device.EnumerateFeatures(&enabledFeature);
- EXPECT_EQ(enabledFeature, feature);
- device.Release();
+ ASSERT_EQ(1u, device.EnumerateFeatures(nullptr));
+ wgpu::FeatureName enabledFeature;
+ device.EnumerateFeatures(&enabledFeature);
+ EXPECT_EQ(enabledFeature, featureName);
+ }
+
+ // Test on adapter with DisallowUnsafeApis disabled.
+ {
+ wgpu::Device device = unsafeAdapter.CreateDevice(&deviceDescriptor);
+ EXPECT_NE(device, nullptr);
+
+ ASSERT_EQ(1u, device.EnumerateFeatures(nullptr));
+ wgpu::FeatureName enabledFeature;
+ device.EnumerateFeatures(&enabledFeature);
+ EXPECT_EQ(enabledFeature, featureName);
+ }
+ }
+
+ // Test creating device with DisallowUnsafeApis enabled in device toggle descriptor will
+ // fail on both adapter, as device toggles will override the inherited adapter toggles.
+ {
+ const char* const enableToggles[] = {"disallow_unsafe_apis"};
+ wgpu::DawnTogglesDescriptor deviceToggleDesc;
+ deviceToggleDesc.enabledToggles = enableToggles;
+ deviceToggleDesc.enabledTogglesCount = 1;
+ deviceDescriptor.nextInChain = &deviceToggleDesc;
+
+ // Test on adapter with DisallowUnsafeApis enabled.
+ {
+ wgpu::Device device = adapter.CreateDevice(&deviceDescriptor);
+ EXPECT_EQ(device, nullptr);
+ }
+
+ // Test on adapter with DisallowUnsafeApis disabled.
+ {
+ wgpu::Device device = unsafeAdapter.CreateDevice(&deviceDescriptor);
+ EXPECT_EQ(device, nullptr);
+ }
}
}
}
diff --git a/src/dawn/tests/unittests/validation/QueryValidationTests.cpp b/src/dawn/tests/unittests/validation/QueryValidationTests.cpp
index ea2e378..ccf1210 100644
--- a/src/dawn/tests/unittests/validation/QueryValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/QueryValidationTests.cpp
@@ -279,12 +279,6 @@
descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1;
- wgpu::DawnTogglesDescriptor deviceTogglesDesc;
- descriptor.nextInChain = &deviceTogglesDesc;
- const char* disabledToggles[1] = {"disallow_unsafe_apis"};
- deviceTogglesDesc.disabledToggles = disabledToggles;
- deviceTogglesDesc.disabledTogglesCount = 1;
-
return dawnAdapter.CreateDevice(&descriptor);
}
@@ -582,12 +576,6 @@
descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 2;
- wgpu::DawnTogglesDescriptor deviceTogglesDesc;
- descriptor.nextInChain = &deviceTogglesDesc;
- const char* disabledToggles[1] = {"disallow_unsafe_apis"};
- deviceTogglesDesc.disabledToggles = disabledToggles;
- deviceTogglesDesc.disabledTogglesCount = 1;
-
return dawnAdapter.CreateDevice(&descriptor);
}
};
@@ -722,19 +710,14 @@
class PipelineStatisticsQueryValidationTest : public QuerySetValidationTest {
protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override {
+ // Create a device with pipeline statistic query feature required. Note that Pipeline
+ // statistic query is an unsafe API, while DisallowUnsafeApis instance toggle is disabled
+ // when ValidationTest creating testing instance, so we can test it.
wgpu::DeviceDescriptor descriptor;
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::PipelineStatisticsQuery};
descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1;
- // TODO(crbug.com/1177506): Pipeline statistic query is an unsafe API, disable disallowing
- // unsafe APIs to test it.
- wgpu::DawnTogglesDescriptor deviceTogglesDesc;
- descriptor.nextInChain = &deviceTogglesDesc;
- const char* disabledToggles[1] = {"disallow_unsafe_apis"};
- deviceTogglesDesc.disabledToggles = disabledToggles;
- deviceTogglesDesc.disabledTogglesCount = 1;
-
return dawnAdapter.CreateDevice(&descriptor);
}
};
diff --git a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
index 811de6e..2aadaf7 100644
--- a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
@@ -26,22 +26,11 @@
class RenderPipelineValidationTest : public ValidationTest {
protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override {
- // Disabled disallowing unsafe APIs so we can test ShaderF16 feature.
- const char* disabledToggle[] = {"disallow_unsafe_apis"};
-
wgpu::DeviceDescriptor descriptor;
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::ShaderF16};
descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1;
- wgpu::DawnTogglesDescriptor deviceTogglesDesc;
- descriptor.nextInChain = &deviceTogglesDesc;
-
- deviceTogglesDesc.enabledToggles = nullptr;
- deviceTogglesDesc.enabledTogglesCount = 0;
- deviceTogglesDesc.disabledToggles = disabledToggle;
- deviceTogglesDesc.disabledTogglesCount = 1;
-
return dawnAdapter.CreateDevice(&descriptor);
}
diff --git a/src/dawn/tests/unittests/validation/TextureValidationTests.cpp b/src/dawn/tests/unittests/validation/TextureValidationTests.cpp
index 5cc3d9c..bc3f33c 100644
--- a/src/dawn/tests/unittests/validation/TextureValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/TextureValidationTests.cpp
@@ -729,14 +729,6 @@
descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 3;
- // TODO(dawn:814): Remove when 1D texture support is complete.
- const char* kDisallowUnsafeApis = "disallow_unsafe_apis";
- wgpu::DawnTogglesDescriptor deviceTogglesDesc;
- deviceTogglesDesc.disabledToggles = &kDisallowUnsafeApis;
- deviceTogglesDesc.disabledTogglesCount = 1;
-
- descriptor.nextInChain = &deviceTogglesDesc;
-
return dawnAdapter.CreateDevice(&descriptor);
}
diff --git a/src/dawn/tests/unittests/validation/UnsafeAPIValidationTests.cpp b/src/dawn/tests/unittests/validation/UnsafeAPIValidationTests.cpp
index c422eae..5ecd096 100644
--- a/src/dawn/tests/unittests/validation/UnsafeAPIValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/UnsafeAPIValidationTests.cpp
@@ -26,7 +26,11 @@
class UnsafeAPIValidationTest : public ValidationTest {
protected:
+ // UnsafeAPIValidationTest create the device with toggle DisallowUnsafeApis explicitly enabled,
+ // which overrides the inheritance.
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override {
+ // Enable the DisallowUnsafeAPIs toggles in device toggles descriptor to override the
+ // inheritance and create a device disallowing unsafe apis.
wgpu::DeviceDescriptor descriptor;
wgpu::DawnTogglesDescriptor deviceTogglesDesc;
descriptor.nextInChain = &deviceTogglesDesc;
diff --git a/src/dawn/tests/unittests/validation/ValidationTest.cpp b/src/dawn/tests/unittests/validation/ValidationTest.cpp
index 4556beb..708da78 100644
--- a/src/dawn/tests/unittests/validation/ValidationTest.cpp
+++ b/src/dawn/tests/unittests/validation/ValidationTest.cpp
@@ -84,11 +84,14 @@
gCurrentTest = this;
DawnProcTable procs = dawn::native::GetProcs();
- // Override procs to provide harness-specific behavior to always select the null adapter,
- // and to allow fixture-specific overriding of the test device with CreateTestDevice.
+
+ // Override procs to provide harness-specific behavior to always select the null adapter, with
+ // adapter toggles inherited from instance toggles state. WGPURequestAdapterOptions is ignored
+ // here.
procs.instanceRequestAdapter = [](WGPUInstance instance, const WGPURequestAdapterOptions*,
WGPURequestAdapterCallback callback, void* userdata) {
ASSERT(gCurrentTest);
+
std::vector<dawn::native::Adapter> adapters = gCurrentTest->mDawnInstance->GetAdapters();
// Validation tests run against the null backend, find the corresponding adapter
for (auto& adapter : adapters) {
@@ -121,7 +124,21 @@
}
void ValidationTest::SetUp() {
- mDawnInstance = std::make_unique<dawn::native::Instance>();
+ // Create an instance with toggle DisallowUnsafeApis disabled, which would be inherited to
+ // adapter and device toggles and allow us to test unsafe apis (including experimental
+ // features). To test device of DisallowUnsafeApis enabled, require it in device toggles
+ // descriptor to override the inheritance.
+ const char* disallowUnsafeApisToggle = "disallow_unsafe_apis";
+ WGPUDawnTogglesDescriptor instanceToggles = {};
+ instanceToggles.chain.sType = WGPUSType::WGPUSType_DawnTogglesDescriptor;
+ instanceToggles.disabledTogglesCount = 1;
+ instanceToggles.disabledToggles = &disallowUnsafeApisToggle;
+
+ WGPUInstanceDescriptor instanceDesc = {};
+ instanceDesc.nextInChain = &instanceToggles.chain;
+
+ mDawnInstance = std::make_unique<dawn::native::Instance>(&instanceDesc);
+
mDawnInstance->DiscoverDefaultAdapters();
mInstance = mWireHelper->RegisterInstance(mDawnInstance->Get());
@@ -130,7 +147,8 @@
"_" + ::testing::UnitTest::GetInstance()->current_test_info()->name();
mWireHelper->BeginWireTrace(traceName.c_str());
- // These options are unused since validation tests always select the null adapter
+ // RequestAdapter is overriden to ignore RequestAdapterOptions and always select the null
+ // adapter.
wgpu::RequestAdapterOptions options = {};
mInstance.RequestAdapter(
&options,
@@ -263,9 +281,8 @@
}
WGPUDevice ValidationTest::CreateTestDevice(dawn::native::Adapter dawnAdapter) {
- // Disabled disallowing unsafe APIs so we can test them.
std::vector<const char*> enabledToggles;
- std::vector<const char*> disabledToggles = {"disallow_unsafe_apis"};
+ std::vector<const char*> disabledToggles;
for (const std::string& toggle : gToggleParser->GetEnabledToggles()) {
enabledToggles.push_back(toggle.c_str());
