encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-06-08 15:43:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Allow device lost callback to be passed at creation

Browse Source 
This change updates the Device descriptor to allow a device lost
callback to be passed in at device creation time. This will be
important for allowing the API to return devices which have
already been lost in a future CL, which is the behavior required
by the spec.

This change does not yet deprecate the old method for setting the
callback, as there's still some tricky scenarios that will need to
be worked around to enable that and this CL is already fairly
large. (The uses in question pass the device or a value created
from the device as the userdata.)

Bug: chromium:1234617
Change-Id: I1adea5ceffdfdcfedff9fff4960f12303abba29c
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/121041
Reviewed-by: Austin Eng <enga@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Brandon Jones <bajones@chromium.org>
This commit is contained in:
Brandon Jones 2023-05-17 01:52:30 +00:00 committed by Dawn LUCI CQ
parent 0e6534e44d
commit 112b7fd856
24 changed files with 150 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
dawn.json
View File

@ -163,7 +163,9 @@
{"name": "required features count", "type": "uint32_t", "default": 0}, {"name": "required features count", "type": "uint32_t", "default": 0},
{"name": "required features", "type": "feature name", "annotation": "const*", "length": "required features count", "default": "nullptr"}, {"name": "required features", "type": "feature name", "annotation": "const*", "length": "required features count", "default": "nullptr"},
{"name": "required limits", "type": "required limits", "annotation": "const*", "optional": true}, {"name": "required limits", "type": "required limits", "annotation": "const*", "optional": true},
{"name": "default queue", "type": "queue descriptor"} {"name": "default queue", "type": "queue descriptor"},
{"name": "device lost callback", "type": "device lost callback", "default": "nullptr"},
{"name": "device lost userdata", "type": "void *", "default": "nullptr"}
] ]
}, },
"dawn toggles descriptor": { "dawn toggles descriptor": {
@ -1191,6 +1193,7 @@
{ {
"name": "set device lost callback", "name": "set device lost callback",
"no autolock": true, "no autolock": true,
"tags": ["deprecated"],
"args": [ "args": [
{"name": "callback", "type": "device lost callback"}, {"name": "callback", "type": "device lost callback"},
{"name": "userdata", "type": "void", "annotation": "*"} {"name": "userdata", "type": "void", "annotation": "*"}

17
generator/templates/api.h
View File

@ -65,6 +65,11 @@ typedef uint32_t {{c_prefix}}Flags;
typedef struct {{as_cType(type.name)}}Impl* {{as_cType(type.name)}}; typedef struct {{as_cType(type.name)}}Impl* {{as_cType(type.name)}};
{% endfor %} {% endfor %}
// Structure forward declarations
{% for type in by_category["structure"] %}
struct {{as_cType(type.name)}};
{% endfor %}
{% for type in by_category["enum"] + by_category["bitmask"] %} {% for type in by_category["enum"] + by_category["bitmask"] %}
typedef enum {{as_cType(type.name)}} { typedef enum {{as_cType(type.name)}} {
{% for value in type.values %} {% for value in type.values %}
@ -78,6 +83,18 @@ typedef uint32_t {{c_prefix}}Flags;
{% endfor -%} {% endfor -%}
{% for type in by_category["function pointer"] %}
typedef {{as_cType(type.return_type.name)}} (*{{as_cType(type.name)}})(
{%- if type.arguments == [] -%}
void
{%- else -%}
{%- for arg in type.arguments -%}
{% if not loop.first %}, {% endif %}{% if arg.type.category == "structure" %}struct {% endif %}{{as_annotated_cType(arg)}}
{%- endfor -%}
{%- endif -%}
);
{% endfor %}
typedef struct {{c_prefix}}ChainedStruct { typedef struct {{c_prefix}}ChainedStruct {
struct {{c_prefix}}ChainedStruct const * next; struct {{c_prefix}}ChainedStruct const * next;
{{c_prefix}}SType sType; {{c_prefix}}SType sType;

7
src/dawn/native/Device.cpp
View File

@ -176,6 +176,9 @@ DeviceBase::DeviceBase(AdapterBase* adapter,
: mAdapter(adapter), mToggles(deviceToggles), mNextPipelineCompatibilityToken(1) { : mAdapter(adapter), mToggles(deviceToggles), mNextPipelineCompatibilityToken(1) {
ASSERT(descriptor != nullptr); ASSERT(descriptor != nullptr);
mDeviceLostCallback = descriptor->deviceLostCallback;
mDeviceLostUserdata = descriptor->deviceLostUserdata;
AdapterProperties adapterProperties; AdapterProperties adapterProperties;
adapter->APIGetProperties(&adapterProperties); adapter->APIGetProperties(&adapterProperties);
@ -234,6 +237,7 @@ MaybeError DeviceBase::Initialize(Ref<QueueBase> defaultQueue) {
} }
}; };
if (!mDeviceLostCallback) {
mDeviceLostCallback = [](WGPUDeviceLostReason, char const*, void*) { mDeviceLostCallback = [](WGPUDeviceLostReason, char const*, void*) {
static bool calledOnce = false; static bool calledOnce = false;
if (!calledOnce) { if (!calledOnce) {
@ -243,6 +247,7 @@ MaybeError DeviceBase::Initialize(Ref<QueueBase> defaultQueue) {
"and suppress this message, set the callback to null."; "and suppress this message, set the callback to null.";
} }
}; };
}
#endif // DAWN_ENABLE_ASSERTS #endif // DAWN_ENABLE_ASSERTS
mCaches = std::make_unique<DeviceBase::Caches>(); mCaches = std::make_unique<DeviceBase::Caches>();
@ -611,6 +616,8 @@ void DeviceBase::APISetUncapturedErrorCallback(wgpu::ErrorCallback callback, voi
} }
void DeviceBase::APISetDeviceLostCallback(wgpu::DeviceLostCallback callback, void* userdata) { void DeviceBase::APISetDeviceLostCallback(wgpu::DeviceLostCallback callback, void* userdata) {
// TODO(chromium:1234617): Add a deprecation warning.
// The registered callback function and userdata pointer are stored and used by deferred // The registered callback function and userdata pointer are stored and used by deferred
// callback tasks, and after setting a different callback (especially in the case of // callback tasks, and after setting a different callback (especially in the case of
// resetting) the resources pointed by such pointer may be freed. Flush all deferred // resetting) the resources pointed by such pointer may be freed. Flush all deferred

32
src/dawn/tests/DawnTest.cpp
View File

@ -699,7 +699,7 @@ DawnTestBase::DawnTestBase(const AdapterTestParam& param) : mParam(param) {
callback(WGPURequestAdapterStatus_Success, cAdapter, nullptr, userdata); callback(WGPURequestAdapterStatus_Success, cAdapter, nullptr, userdata);
}; };
procs.adapterRequestDevice = [](WGPUAdapter adapter, const WGPUDeviceDescriptor*, procs.adapterRequestDevice = [](WGPUAdapter adapter, const WGPUDeviceDescriptor* descriptor,
WGPURequestDeviceCallback callback, void* userdata) { WGPURequestDeviceCallback callback, void* userdata) {
ASSERT(gCurrentTest); ASSERT(gCurrentTest);
@ -711,7 +711,7 @@ DawnTestBase::DawnTestBase(const AdapterTestParam& param) : mParam(param) {
isolationKey = std::move(gCurrentTest->mNextIsolationKeyQueue.front()); isolationKey = std::move(gCurrentTest->mNextIsolationKeyQueue.front());
gCurrentTest->mNextIsolationKeyQueue.pop(); gCurrentTest->mNextIsolationKeyQueue.pop();
} }
WGPUDevice cDevice = gCurrentTest->CreateDeviceImpl(std::move(isolationKey)); WGPUDevice cDevice = gCurrentTest->CreateDeviceImpl(std::move(isolationKey), descriptor);
ASSERT(cDevice != nullptr); ASSERT(cDevice != nullptr);
gCurrentTest->mLastCreatedBackendDevice = cDevice; gCurrentTest->mLastCreatedBackendDevice = cDevice;
@ -978,7 +978,12 @@ bool DawnTestBase::SupportsFeatures(const std::vector<wgpu::FeatureName>& featur
return true; return true;
} }
WGPUDevice DawnTestBase::CreateDeviceImpl(std::string isolationKey) { void* DawnTestBase::GetUniqueUserdata() {
return reinterpret_cast<void*>(++mNextUniqueUserdata);
}
WGPUDevice DawnTestBase::CreateDeviceImpl(std::string isolationKey,
const WGPUDeviceDescriptor* descriptor) {
// Create the device from the adapter // Create the device from the adapter
std::vector<wgpu::FeatureName> requiredFeatures = GetRequiredFeatures(); std::vector<wgpu::FeatureName> requiredFeatures = GetRequiredFeatures();
if (IsImplicitDeviceSyncEnabled()) { if (IsImplicitDeviceSyncEnabled()) {
@ -989,7 +994,8 @@ WGPUDevice DawnTestBase::CreateDeviceImpl(std::string isolationKey) {
mBackendAdapter.GetLimits(reinterpret_cast<WGPUSupportedLimits*>(&supportedLimits)); mBackendAdapter.GetLimits(reinterpret_cast<WGPUSupportedLimits*>(&supportedLimits));
wgpu::RequiredLimits requiredLimits = GetRequiredLimits(supportedLimits); wgpu::RequiredLimits requiredLimits = GetRequiredLimits(supportedLimits);
wgpu::DeviceDescriptor deviceDescriptor = {}; wgpu::DeviceDescriptor deviceDescriptor =
*reinterpret_cast<const wgpu::DeviceDescriptor*>(descriptor);
deviceDescriptor.requiredLimits = &requiredLimits; deviceDescriptor.requiredLimits = &requiredLimits;
deviceDescriptor.requiredFeatures = requiredFeatures.data(); deviceDescriptor.requiredFeatures = requiredFeatures.data();
deviceDescriptor.requiredFeaturesCount = requiredFeatures.size(); deviceDescriptor.requiredFeaturesCount = requiredFeatures.size();
@ -1017,6 +1023,12 @@ wgpu::Device DawnTestBase::CreateDevice(std::string isolationKey) {
// Give an empty descriptor. // Give an empty descriptor.
// TODO(dawn:1684): Replace empty DeviceDescriptor with nullptr after Dawn wire support it. // TODO(dawn:1684): Replace empty DeviceDescriptor with nullptr after Dawn wire support it.
wgpu::DeviceDescriptor deviceDesc = {}; wgpu::DeviceDescriptor deviceDesc = {};
// Set up the mocks for device loss.
void* deviceUserdata = GetUniqueUserdata();
deviceDesc.deviceLostCallback = mDeviceLostCallback.Callback();
deviceDesc.deviceLostUserdata = mDeviceLostCallback.MakeUserdata(deviceUserdata);
mAdapter.RequestDevice( mAdapter.RequestDevice(
&deviceDesc, &deviceDesc,
[](WGPURequestDeviceStatus, WGPUDevice cDevice, const char*, void* userdata) { [](WGPURequestDeviceStatus, WGPUDevice cDevice, const char*, void* userdata) {
@ -1026,14 +1038,13 @@ wgpu::Device DawnTestBase::CreateDevice(std::string isolationKey) {
FlushWire(); FlushWire();
ASSERT(apiDevice); ASSERT(apiDevice);
// Set up the mocks for uncaptured errors and device loss. The loss of the device is // Set up the mocks for uncaptured errors.
// expected to happen at the end of the test so at it directly.
apiDevice.SetUncapturedErrorCallback(mDeviceErrorCallback.Callback(), apiDevice.SetUncapturedErrorCallback(mDeviceErrorCallback.Callback(),
mDeviceErrorCallback.MakeUserdata(apiDevice.Get())); mDeviceErrorCallback.MakeUserdata(apiDevice.Get()));
apiDevice.SetDeviceLostCallback(mDeviceLostCallback.Callback(),
mDeviceLostCallback.MakeUserdata(apiDevice.Get())); // The loss of the device is expected to happen at the end of the test so at it directly.
EXPECT_CALL(mDeviceLostCallback, EXPECT_CALL(mDeviceLostCallback,
Call(WGPUDeviceLostReason_Destroyed, testing::_, apiDevice.Get())) Call(WGPUDeviceLostReason_Destroyed, testing::_, deviceUserdata))
.Times(testing::AtMost(1)); .Times(testing::AtMost(1));
apiDevice.SetLoggingCallback( apiDevice.SetLoggingCallback(
@ -1123,8 +1134,7 @@ void DawnTestBase::LoseDeviceForTesting(wgpu::Device device) {
resolvedDevice = this->device; resolvedDevice = this->device;
} }
EXPECT_CALL(mDeviceLostCallback, EXPECT_CALL(mDeviceLostCallback, Call(WGPUDeviceLostReason_Undefined, testing::_, testing::_))
Call(WGPUDeviceLostReason_Undefined, testing::_, resolvedDevice.Get()))
.Times(1); .Times(1);
resolvedDevice.ForceLoss(wgpu::DeviceLostReason::Undefined, "Device lost for testing"); resolvedDevice.ForceLoss(wgpu::DeviceLostReason::Undefined, "Device lost for testing");
resolvedDevice.Tick(); resolvedDevice.Tick();

7
src/dawn/tests/DawnTest.h
View File

@ -580,6 +580,8 @@ class DawnTestBase {
wgpu::SupportedLimits GetAdapterLimits(); wgpu::SupportedLimits GetAdapterLimits();
wgpu::SupportedLimits GetSupportedLimits(); wgpu::SupportedLimits GetSupportedLimits();
void* GetUniqueUserdata();
private: private:
utils::ScopedAutoreleasePool mObjCAutoreleasePool; utils::ScopedAutoreleasePool mObjCAutoreleasePool;
AdapterTestParam mParam; AdapterTestParam mParam;
@ -587,12 +589,15 @@ class DawnTestBase {
wgpu::Instance mInstance; wgpu::Instance mInstance;
wgpu::Adapter mAdapter; wgpu::Adapter mAdapter;
// Helps generate unique userdata values passed to deviceLostUserdata.
std::atomic<uintptr_t> mNextUniqueUserdata = 0;
// Isolation keys are not exposed to the wire client. Device creation in the tests from // Isolation keys are not exposed to the wire client. Device creation in the tests from
// the client first push the key into this queue, which is then consumed by the server. // the client first push the key into this queue, which is then consumed by the server.
std::queue<std::string> mNextIsolationKeyQueue; std::queue<std::string> mNextIsolationKeyQueue;
// Internal device creation function for default device creation with some optional overrides. // Internal device creation function for default device creation with some optional overrides.
WGPUDevice CreateDeviceImpl(std::string isolationKey); WGPUDevice CreateDeviceImpl(std::string isolationKey, const WGPUDeviceDescriptor* descriptor);
std::ostringstream& AddTextureExpectationImpl(const char* file, std::ostringstream& AddTextureExpectationImpl(const char* file,
int line, int line,

4
src/dawn/tests/unittests/validation/BindGroupValidationTests.cpp
View File

@ -79,8 +79,8 @@ class BindGroupValidationTest : public ValidationTest {
return desc; return desc;
} }
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

16
src/dawn/tests/unittests/validation/CopyCommandsValidationTests.cpp
View File

@ -420,8 +420,8 @@ TEST_F(CopyCommandTest_B2B, CopyWithinSameBuffer) {
class CopyCommandTest_B2T : public CopyCommandTest { class CopyCommandTest_B2T : public CopyCommandTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -1028,8 +1028,8 @@ TEST_F(CopyCommandTest_B2T, RequiredBytesInCopyOverflow) {
class CopyCommandTest_T2B : public CopyCommandTest { class CopyCommandTest_T2B : public CopyCommandTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -1665,8 +1665,8 @@ TEST_F(CopyCommandTest_T2B, RequiredBytesInCopyOverflow) {
class CopyCommandTest_T2T : public CopyCommandTest { class CopyCommandTest_T2T : public CopyCommandTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -2144,8 +2144,8 @@ TEST_F(CopyCommandTest_T2T, CopyWithinSameTexture) {
class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest { class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[3] = {wgpu::FeatureName::TextureCompressionBC, wgpu::FeatureName requiredFeatures[3] = {wgpu::FeatureName::TextureCompressionBC,
wgpu::FeatureName::TextureCompressionETC2, wgpu::FeatureName::TextureCompressionETC2,
wgpu::FeatureName::TextureCompressionASTC}; wgpu::FeatureName::TextureCompressionASTC};

8
src/dawn/tests/unittests/validation/CopyTextureForBrowserTests.cpp
View File

@ -101,8 +101,8 @@ class CopyTextureForBrowserTest : public ValidationTest {
class CopyTextureForBrowserInternalUsageTest : public CopyTextureForBrowserTest { class CopyTextureForBrowserInternalUsageTest : public CopyTextureForBrowserTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName feature = wgpu::FeatureName::DawnInternalUsages; wgpu::FeatureName feature = wgpu::FeatureName::DawnInternalUsages;
descriptor.requiredFeatures = &feature; descriptor.requiredFeatures = &feature;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -142,8 +142,8 @@ class CopyExternalTextureForBrowserTest : public ValidationTest {
class CopyExternalTextureForBrowserInternalUsageTest : public CopyExternalTextureForBrowserTest { class CopyExternalTextureForBrowserInternalUsageTest : public CopyExternalTextureForBrowserTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName feature = wgpu::FeatureName::DawnInternalUsages; wgpu::FeatureName feature = wgpu::FeatureName::DawnInternalUsages;
descriptor.requiredFeatures = &feature; descriptor.requiredFeatures = &feature;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

4
src/dawn/tests/unittests/validation/InternalUsageValidationTests.cpp
View File

@ -64,8 +64,8 @@ TEST_F(InternalUsageValidationDisabledTest, CommandEncoderDescriptorRequiresFeat
} }
class TextureInternalUsageValidationTest : public ValidationTest { class TextureInternalUsageValidationTest : public ValidationTest {
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DawnInternalUsages}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DawnInternalUsages};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

4
src/dawn/tests/unittests/validation/OverridableConstantsValidationTests.cpp
View File

@ -21,7 +21,8 @@
class ComputePipelineOverridableConstantsValidationTest : public ValidationTest { class ComputePipelineOverridableConstantsValidationTest : public ValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor deviceDescriptor) override {
std::vector<const char*> enabledToggles; std::vector<const char*> enabledToggles;
std::vector<const char*> disabledToggles; std::vector<const char*> disabledToggles;
@ -35,7 +36,6 @@ class ComputePipelineOverridableConstantsValidationTest : public ValidationTest
const wgpu::FeatureName requiredFeatures[] = {wgpu::FeatureName::ShaderF16}; const wgpu::FeatureName requiredFeatures[] = {wgpu::FeatureName::ShaderF16};
wgpu::DeviceDescriptor deviceDescriptor;
deviceDescriptor.nextInChain = &deviceTogglesDesc; deviceDescriptor.nextInChain = &deviceTogglesDesc;
deviceDescriptor.requiredFeatures = requiredFeatures; deviceDescriptor.requiredFeatures = requiredFeatures;
deviceDescriptor.requiredFeaturesCount = 1; deviceDescriptor.requiredFeaturesCount = 1;

12
src/dawn/tests/unittests/validation/QueryValidationTests.cpp
View File

@ -273,8 +273,8 @@ TEST_F(OcclusionQueryValidationTest, InvalidBeginAndEnd) {
class TimestampQueryValidationTest : public QuerySetValidationTest { class TimestampQueryValidationTest : public QuerySetValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::TimestampQuery}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::TimestampQuery};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -566,8 +566,8 @@ TEST_F(TimestampQueryValidationTest, WriteTimestampOnCommandEncoder) {
class TimestampQueryInsidePassesValidationTest : public QuerySetValidationTest { class TimestampQueryInsidePassesValidationTest : public QuerySetValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
// The timestamp query feature must be supported if the timestamp query inside passes // The timestamp query feature must be supported if the timestamp query inside passes
// feature is supported. Enable timestamp query for validating queries overwrite inside and // feature is supported. Enable timestamp query for validating queries overwrite inside and
// outside of the passes. // outside of the passes.
@ -709,11 +709,11 @@ TEST_F(TimestampQueryInsidePassesValidationTest, WriteTimestampOnRenderPassEncod
class PipelineStatisticsQueryValidationTest : public QuerySetValidationTest { class PipelineStatisticsQueryValidationTest : public QuerySetValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor) override {
// Create a device with pipeline statistic query feature required. Note that Pipeline // Create a device with pipeline statistic query feature required. Note that Pipeline
// statistic query is an unsafe API, while AllowUnsafeApis instance toggle is enabled // statistic query is an unsafe API, while AllowUnsafeApis instance toggle is enabled
// when ValidationTest creating testing instance, so we can test it. // when ValidationTest creating testing instance, so we can test it.
wgpu::DeviceDescriptor descriptor;
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::PipelineStatisticsQuery}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::PipelineStatisticsQuery};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

4
src/dawn/tests/unittests/validation/QueueWriteTextureValidationTests.cpp
View File

@ -536,8 +536,8 @@ TEST_F(QueueWriteTextureValidationTest, WriteToStencilAspect) {
class WriteTextureTest_CompressedTextureFormats : public QueueWriteTextureValidationTest { class WriteTextureTest_CompressedTextureFormats : public QueueWriteTextureValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[3] = {wgpu::FeatureName::TextureCompressionBC, wgpu::FeatureName requiredFeatures[3] = {wgpu::FeatureName::TextureCompressionBC,
wgpu::FeatureName::TextureCompressionETC2, wgpu::FeatureName::TextureCompressionETC2,
wgpu::FeatureName::TextureCompressionASTC}; wgpu::FeatureName::TextureCompressionASTC};

12
src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
View File

@ -24,8 +24,8 @@
class RenderPipelineValidationTest : public ValidationTest { class RenderPipelineValidationTest : public ValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::ShaderF16}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::ShaderF16};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -1595,8 +1595,8 @@ TEST_F(RenderPipelineValidationTest, RenderPipelineColorAttachmentBytesPerSample
class DepthClipControlValidationTest : public RenderPipelineValidationTest { class DepthClipControlValidationTest : public RenderPipelineValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DepthClipControl}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DepthClipControl};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -1894,8 +1894,8 @@ TEST_F(InterStageVariableMatchingValidationTest, DifferentInterpolationAttribute
class RenderPipelineTransientAttachmentValidationTest : public RenderPipelineValidationTest { class RenderPipelineTransientAttachmentValidationTest : public RenderPipelineValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[2] = {wgpu::FeatureName::ShaderF16, wgpu::FeatureName requiredFeatures[2] = {wgpu::FeatureName::ShaderF16,
wgpu::FeatureName::TransientAttachments}; wgpu::FeatureName::TransientAttachments};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;

8
src/dawn/tests/unittests/validation/StorageTextureValidationTests.cpp
View File

@ -269,8 +269,8 @@ TEST_F(StorageTextureValidationTests, StorageTextureFormatInShaders) {
class BGRA8UnormStorageTextureInShaderValidationTests : public StorageTextureValidationTests { class BGRA8UnormStorageTextureInShaderValidationTests : public StorageTextureValidationTests {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::BGRA8UnormStorage}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::BGRA8UnormStorage};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -427,8 +427,8 @@ TEST_F(StorageTextureValidationTests, StorageTextureFormatInBindGroupLayout) {
class BGRA8UnormStorageBindGroupLayoutTest : public StorageTextureValidationTests { class BGRA8UnormStorageBindGroupLayoutTest : public StorageTextureValidationTests {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::BGRA8UnormStorage}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::BGRA8UnormStorage};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

20
src/dawn/tests/unittests/validation/TextureValidationTests.cpp
View File

@ -699,8 +699,8 @@ TEST_F(TextureValidationTest, UseASTCFormatWithoutEnablingFeature) {
class D32S8TextureFormatsValidationTests : public TextureValidationTest { class D32S8TextureFormatsValidationTests : public TextureValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -721,8 +721,8 @@ TEST_F(D32S8TextureFormatsValidationTests, DepthStencilFormatsFor3D) {
class CompressedTextureFormatsValidationTests : public TextureValidationTest { class CompressedTextureFormatsValidationTests : public TextureValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[3] = {wgpu::FeatureName::TextureCompressionBC, wgpu::FeatureName requiredFeatures[3] = {wgpu::FeatureName::TextureCompressionBC,
wgpu::FeatureName::TextureCompressionETC2, wgpu::FeatureName::TextureCompressionETC2,
wgpu::FeatureName::TextureCompressionASTC}; wgpu::FeatureName::TextureCompressionASTC};
@ -879,8 +879,8 @@ TEST_F(CompressedTextureFormatsValidationTests, TextureSize) {
class RG11B10UfloatTextureFormatsValidationTests : public TextureValidationTest { class RG11B10UfloatTextureFormatsValidationTests : public TextureValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::RG11B10UfloatRenderable}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::RG11B10UfloatRenderable};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -902,8 +902,8 @@ TEST_F(RG11B10UfloatTextureFormatsValidationTests, RenderableFeature) {
class BGRA8UnormTextureFormatsValidationTests : public TextureValidationTest { class BGRA8UnormTextureFormatsValidationTests : public TextureValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::BGRA8UnormStorage}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::BGRA8UnormStorage};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;
@ -1038,8 +1038,8 @@ TEST_F(TextureValidationTest, TransientAttachmentOnUnsupportedDevice) {
class TransientAttachmentValidationTest : public TextureValidationTest { class TransientAttachmentValidationTest : public TextureValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::TransientAttachments}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::TransientAttachments};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

4
src/dawn/tests/unittests/validation/TextureViewValidationTests.cpp
View File

@ -916,8 +916,8 @@ TEST_F(TextureViewValidationTest, AspectMustExist) {
class D32S8TextureViewValidationTests : public ValidationTest { class D32S8TextureViewValidationTests : public ValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::Depth32FloatStencil8};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

4
src/dawn/tests/unittests/validation/UnsafeAPIValidationTests.cpp
View File

@ -28,10 +28,10 @@ class UnsafeAPIValidationTest : public ValidationTest {
protected: protected:
// UnsafeAPIValidationTest create the device with the AllowUnsafeAPIs toggle explicitly // UnsafeAPIValidationTest create the device with the AllowUnsafeAPIs toggle explicitly
// disabled, which overrides the inheritance. // disabled, which overrides the inheritance.
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor) override {
// Disable the AllowUnsafeAPIs toggles in device toggles descriptor to override the // Disable the AllowUnsafeAPIs toggles in device toggles descriptor to override the
// inheritance and create a device disallowing unsafe apis. // inheritance and create a device disallowing unsafe apis.
wgpu::DeviceDescriptor descriptor;
wgpu::DawnTogglesDescriptor deviceTogglesDesc; wgpu::DawnTogglesDescriptor deviceTogglesDesc;
descriptor.nextInChain = &deviceTogglesDesc; descriptor.nextInChain = &deviceTogglesDesc;
const char* toggle = "allow_unsafe_apis"; const char* toggle = "allow_unsafe_apis";

18
src/dawn/tests/unittests/validation/ValidationTest.cpp
View File

@ -111,11 +111,14 @@ ValidationTest::ValidationTest() {
UNREACHABLE(); UNREACHABLE();
}; };
procs.adapterRequestDevice = [](WGPUAdapter adapter, const WGPUDeviceDescriptor*, procs.adapterRequestDevice = [](WGPUAdapter adapter, const WGPUDeviceDescriptor* descriptor,
WGPURequestDeviceCallback callback, void* userdata) { WGPURequestDeviceCallback callback, void* userdata) {
ASSERT(gCurrentTest); ASSERT(gCurrentTest);
wgpu::DeviceDescriptor deviceDesc =
*(reinterpret_cast<const wgpu::DeviceDescriptor*>(descriptor));
WGPUDevice cDevice = gCurrentTest->CreateTestDevice( WGPUDevice cDevice = gCurrentTest->CreateTestDevice(
dawn::native::Adapter(reinterpret_cast<dawn::native::AdapterBase*>(adapter))); dawn::native::Adapter(reinterpret_cast<dawn::native::AdapterBase*>(adapter)),
deviceDesc);
ASSERT(cDevice != nullptr); ASSERT(cDevice != nullptr);
gCurrentTest->mLastCreatedBackendDevice = cDevice; gCurrentTest->mLastCreatedBackendDevice = cDevice;
callback(WGPURequestDeviceStatus_Success, cDevice, nullptr, userdata); callback(WGPURequestDeviceStatus_Success, cDevice, nullptr, userdata);
@ -160,11 +163,14 @@ void ValidationTest::SetUp() {
FlushWire(); FlushWire();
ASSERT(adapter); ASSERT(adapter);
device = RequestDeviceSync(wgpu::DeviceDescriptor{}); wgpu::DeviceDescriptor deviceDescriptor = {};
deviceDescriptor.deviceLostCallback = ValidationTest::OnDeviceLost;
deviceDescriptor.deviceLostUserdata = this;
device = RequestDeviceSync(deviceDescriptor);
backendDevice = mLastCreatedBackendDevice; backendDevice = mLastCreatedBackendDevice;
device.SetUncapturedErrorCallback(ValidationTest::OnDeviceError, this); device.SetUncapturedErrorCallback(ValidationTest::OnDeviceError, this);
device.SetDeviceLostCallback(ValidationTest::OnDeviceLost, this);
} }
ValidationTest::~ValidationTest() { ValidationTest::~ValidationTest() {
@ -281,7 +287,8 @@ dawn::native::Adapter& ValidationTest::GetBackendAdapter() {
return mBackendAdapter; return mBackendAdapter;
} }
WGPUDevice ValidationTest::CreateTestDevice(dawn::native::Adapter dawnAdapter) { WGPUDevice ValidationTest::CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor deviceDescriptor) {
std::vector<const char*> enabledToggles; std::vector<const char*> enabledToggles;
std::vector<const char*> disabledToggles; std::vector<const char*> disabledToggles;
@ -293,7 +300,6 @@ WGPUDevice ValidationTest::CreateTestDevice(dawn::native::Adapter dawnAdapter) {
disabledToggles.push_back(toggle.c_str()); disabledToggles.push_back(toggle.c_str());
} }
wgpu::DeviceDescriptor deviceDescriptor;
wgpu::DawnTogglesDescriptor deviceTogglesDesc; wgpu::DawnTogglesDescriptor deviceTogglesDesc;
deviceDescriptor.nextInChain = &deviceTogglesDesc; deviceDescriptor.nextInChain = &deviceTogglesDesc;

3
src/dawn/tests/unittests/validation/ValidationTest.h
View File

@ -135,7 +135,8 @@ class ValidationTest : public testing::Test {
protected: protected:
dawn::native::Adapter& GetBackendAdapter(); dawn::native::Adapter& GetBackendAdapter();
virtual WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter); virtual WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor);
wgpu::Device RequestDeviceSync(const wgpu::DeviceDescriptor& deviceDesc); wgpu::Device RequestDeviceSync(const wgpu::DeviceDescriptor& deviceDesc);

4
src/dawn/tests/unittests/validation/VideoViewsValidationTests.cpp
View File

@ -21,8 +21,8 @@ namespace {
class VideoViewsValidation : public ValidationTest { class VideoViewsValidation : public ValidationTest {
protected: protected:
WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter,
wgpu::DeviceDescriptor descriptor; wgpu::DeviceDescriptor descriptor) override {
wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DawnMultiPlanarFormats}; wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DawnMultiPlanarFormats};
descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeatures = requiredFeatures;
descriptor.requiredFeaturesCount = 1; descriptor.requiredFeaturesCount = 1;

2
src/dawn/wire/client/Adapter.cpp
View File

@ -71,7 +71,7 @@ void Adapter::RequestDevice(const WGPUDeviceDescriptor* descriptor,
return; return;
} }
Device* device = client->Make<Device>(); Device* device = client->Make<Device>(descriptor);
uint64_t serial = mRequestDeviceRequests.Add({callback, device->GetWireId(), userdata}); uint64_t serial = mRequestDeviceRequests.Add({callback, device->GetWireId(), userdata});
AdapterRequestDeviceCmd cmd; AdapterRequestDeviceCmd cmd;

2
src/dawn/wire/client/Client.cpp
View File

@ -106,7 +106,7 @@ ReservedSwapChain Client::ReserveSwapChain(WGPUDevice device) {
} }
ReservedDevice Client::ReserveDevice() { ReservedDevice Client::ReserveDevice() {
Device* device = Make<Device>(); Device* device = Make<Device>(nullptr);
ReservedDevice result; ReservedDevice result;
result.device = ToAPI(device); result.device = ToAPI(device);

9
src/dawn/wire/client/Device.cpp
View File

@ -23,8 +23,13 @@
namespace dawn::wire::client { namespace dawn::wire::client {
Device::Device(const ObjectBaseParams& params) Device::Device(const ObjectBaseParams& params, const WGPUDeviceDescriptor* descriptor)
: ObjectBase(params), mIsAlive(std::make_shared<bool>()) { : ObjectBase(params), mIsAlive(std::make_shared<bool>()) {
if (descriptor && descriptor->deviceLostCallback) {
mDeviceLostCallback = descriptor->deviceLostCallback;
mDeviceLostUserdata = descriptor->deviceLostUserdata;
}
#if defined(DAWN_ENABLE_ASSERTS) #if defined(DAWN_ENABLE_ASSERTS)
mErrorCallback = [](WGPUErrorType, char const*, void*) { mErrorCallback = [](WGPUErrorType, char const*, void*) {
static bool calledOnce = false; static bool calledOnce = false;
@ -36,6 +41,7 @@ Device::Device(const ObjectBaseParams& params)
} }
}; };
if (!mDeviceLostCallback) {
mDeviceLostCallback = [](WGPUDeviceLostReason, char const*, void*) { mDeviceLostCallback = [](WGPUDeviceLostReason, char const*, void*) {
static bool calledOnce = false; static bool calledOnce = false;
if (!calledOnce) { if (!calledOnce) {
@ -45,6 +51,7 @@ Device::Device(const ObjectBaseParams& params)
"and suppress this message, set the callback to null."; "and suppress this message, set the callback to null.";
} }
}; };
}
#endif // DAWN_ENABLE_ASSERTS #endif // DAWN_ENABLE_ASSERTS
} }

2
src/dawn/wire/client/Device.h
View File

@ -32,7 +32,7 @@ class Queue;
class Device final : public ObjectBase { class Device final : public ObjectBase {
public: public:
explicit Device(const ObjectBaseParams& params); explicit Device(const ObjectBaseParams& params, const WGPUDeviceDescriptor* descriptor);
~Device() override; ~Device() override;
void SetUncapturedErrorCallback(WGPUErrorCallback errorCallback, void* errorUserdata); void SetUncapturedErrorCallback(WGPUErrorCallback errorCallback, void* errorUserdata);