Immediates: promote/rename, use limit only, remove feature
- Promote/rename immediateSize and maxImmediateSize to match webgpu.h.
- Avoided renaming related symbols, to reduce the size of the CL.
- Since maxImmediateSize is now core, it defaults to 0 instead of 16.
- Vulkan backend now needs to explicitly set it, others keep it as 0.
- Since there's no longer an extension struct for the limits, we also
need new rules for how it's validated. Keeping the feature with the
limit introduces questions about how the feature and the limit
interact (what happens if you request one but not the other?), so
instead this removes the feature entirely and gates maxImmediateSize>0
on AllowUnsafeAPIs.
- This simplifies some validation, as it all relies on
maxImmediateSize and not the feature. Only
AdapterBase::UpdateLimits() needs to care about the toggle, and
SetImmediateData needs to explicitly error if maxImmediateSize=0.
- The WGSL feature is gated on AllowUnsafeAPIs, along with other
existing experimental features.
- In Wasm, pass maxImmediateSize through, but only if it's > 0.
No other projects seem to depend on immediates, so this changes
everything at once without any deprecations.
Fixed: 415086848
Change-Id: I980856fee5b5ec4ff98444291c410f5ab35bc178
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/240934
Reviewed-by: Loko Kung <lokokung@google.com>
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
diff --git a/src/dawn/dawn.json b/src/dawn/dawn.json
index f08d658..3d4b87a 100644
--- a/src/dawn/dawn.json
+++ b/src/dawn/dawn.json
@@ -1592,6 +1592,7 @@
{"name": "max compute workgroup size y", "type": "uint32_t", "default": "limit u32 undefined"},
{"name": "max compute workgroup size z", "type": "uint32_t", "default": "limit u32 undefined"},
{"name": "max compute workgroups per dimension", "type": "uint32_t", "default": "limit u32 undefined"},
+ {"name": "max immediate size", "type": "uint32_t", "default": "limit u32 undefined"},
{"name": "max storage buffers in vertex stage", "type": "uint32_t", "default": "limit u32 undefined"},
{"name": "max storage textures in vertex stage", "type": "uint32_t", "default": "limit u32 undefined"},
{"name": "max storage buffers in fragment stage", "type": "uint32_t", "default": "limit u32 undefined"},
@@ -1607,15 +1608,6 @@
{"name": "subgroup max size", "type": "uint32_t", "default": "limit u32 undefined"}
]
},
- "dawn experimental immediate data limits": {
- "category": "structure",
- "chained": "out",
- "chain roots": ["limits"],
- "tags": ["dawn"],
- "members": [
- {"name": "max immediate data range byte size", "type": "uint32_t", "default": "limit u32 undefined"}
- ]
- },
"dawn texel copy buffer row alignment limits": {
"category": "structure",
"chained": "out",
@@ -2286,7 +2278,6 @@
{"value": 2, "name": "dawn native", "tags": ["dawn", "native"]},
{"value": 3, "name": "chromium experimental timestamp query inside passes", "tags": ["dawn"]},
{"value": 4, "name": "implicit device synchronization", "tags": ["dawn", "native"]},
- {"value": 5, "name": "chromium experimental immediate", "tags": ["dawn"]},
{"value": 6, "name": "transient attachments", "tags": ["dawn"]},
{"value": 7, "name": "MSAA render to single sampled", "tags": ["dawn"]},
{"value": 8, "name": "D3D11 multithread protected", "tags": ["dawn", "native"]},
@@ -2655,7 +2646,7 @@
{"name": "label", "type": "string view", "optional": true},
{"name": "bind group layout count", "type": "size_t"},
{"name": "bind group layouts", "type": "bind group layout", "annotation": "const*", "length": "bind group layout count", "optional": true},
- {"name": "immediate data range byte size", "type": "uint32_t", "default": 0}
+ {"name": "immediate size", "type": "uint32_t", "default": 0}
]
},
"pipeline layout pixel local storage": {
@@ -3858,7 +3849,6 @@
{"value": 54, "name": "y cb cr vk descriptor", "tags": ["dawn"]},
{"value": 55, "name": "shared texture memory a hardware buffer properties", "tags": ["dawn", "native"]},
{"value": 56, "name": "a hardware buffer properties", "tags": ["dawn", "native"]},
- {"value": 57, "name": "dawn experimental immediate data limits", "tags": ["dawn"]},
{"value": 58, "name": "dawn texel copy buffer row alignment limits", "tags": ["dawn"]},
{"value": 59, "name": "adapter properties subgroup matrix configs", "tags": ["dawn"]},
{"value": 60, "name": "shared fence EGL sync descriptor", "tags": ["dawn", "native"]},
diff --git a/src/dawn/native/Adapter.cpp b/src/dawn/native/Adapter.cpp
index 69ab98d..1a4a740 100644
--- a/src/dawn/native/Adapter.cpp
+++ b/src/dawn/native/Adapter.cpp
@@ -98,6 +98,11 @@
void AdapterBase::UpdateLimits() {
mLimits = mPhysicalDevice->GetLimits();
+ // Disable unsafe limits if needed.
+ if (!mTogglesState.IsEnabled(Toggle::AllowUnsafeAPIs)) {
+ mLimits.v1.maxImmediateSize = 0;
+ }
+
// Apply the tiered limits if needed.
if (mUseTieredLimits) {
ApplyLimitTiers(&mLimits);
@@ -287,8 +292,8 @@
// toggles. Note that certain toggles in device toggles state may be overridden by user and
// different from the adapter toggles state, and in this case a device may support features
// that not supported by the adapter. We allow such toggles overriding for the convenience e.g.
- // creating a device for internal usage with AllowUnsafeAPI enabled from an adapter that
- // disabled AllowUnsafeAPIS.
+ // creating a device for internal usage with AllowUnsafeAPIs enabled from an adapter that
+ // disabled AllowUnsafeAPIs.
for (wgpu::FeatureName requiredFeature : requiredFeatureSet) {
FeatureValidationResult result =
mPhysicalDevice->ValidateFeatureSupportedWithToggles(requiredFeature, deviceToggles);
diff --git a/src/dawn/native/Device.cpp b/src/dawn/native/Device.cpp
index ee7c8ee..2d63972 100644
--- a/src/dawn/native/Device.cpp
+++ b/src/dawn/native/Device.cpp
@@ -1668,6 +1668,8 @@
mWGSLAllowedFeatures.extensions.insert(
tint::wgsl::Extension::kChromiumDisableUniformityAnalysis);
mWGSLAllowedFeatures.extensions.insert(tint::wgsl::Extension::kChromiumInternalGraphite);
+ mWGSLAllowedFeatures.extensions.insert(
+ tint::wgsl::Extension::kChromiumExperimentalImmediate);
}
if (mEnabledFeatures.IsEnabled(Feature::DualSourceBlending)) {
mWGSLAllowedFeatures.extensions.insert(tint::wgsl::Extension::kDualSourceBlending);
@@ -1688,10 +1690,6 @@
mWGSLAllowedFeatures.extensions.insert(
tint::wgsl::Extension::kChromiumExperimentalSubgroupMatrix);
}
- if (mEnabledFeatures.IsEnabled(Feature::ChromiumExperimentalImmediate)) {
- mWGSLAllowedFeatures.extensions.insert(
- tint::wgsl::Extension::kChromiumExperimentalImmediate);
- }
// Language features are enabled instance-wide.
const auto& allowedFeatures = GetInstance()->GetAllowedWGSLLanguageFeatures();
diff --git a/src/dawn/native/Features.cpp b/src/dawn/native/Features.cpp
index 3e1afee..efa7ea8 100644
--- a/src/dawn/native/Features.cpp
+++ b/src/dawn/native/Features.cpp
@@ -396,10 +396,6 @@
{"Support the \"enable clip_distances;\" directive in WGSL.",
"https://gpuweb.github.io/gpuweb/#dom-gpufeaturename-clip-distances",
FeatureInfo::FeatureState::Stable}},
- {Feature::ChromiumExperimentalImmediate,
- {"Support the \"enable chromium_experimental_immediate;\" directive in WGSL.",
- "https://github.com/gpuweb/gpuweb/blob/main/proposals/push-constants.md",
- FeatureInfo::FeatureState::Experimental}},
{Feature::DawnTexelCopyBufferRowAlignment,
{"Expose the min row alignment in buffer for texel copy operations.",
"https://dawn.googlesource.com/dawn/+/refs/heads/main/docs/dawn/features/"
diff --git a/src/dawn/native/Limits.cpp b/src/dawn/native/Limits.cpp
index 1435f33..3a76cb0 100644
--- a/src/dawn/native/Limits.cpp
+++ b/src/dawn/native/Limits.cpp
@@ -125,13 +125,8 @@
X(v1, Maximum, maxVertexBuffers, 8, 8, 8) \
X(v1, Maximum, maxVertexAttributes, 16, 16, 30) \
X(v1, Maximum, maxVertexBufferArrayStride, 2048, 2048, 2048) \
- X(v1, Maximum, maxColorAttachments, 4, 8, 8)
-
-// These limits represents experimental features. The only element experimentalImmediateDataLimits
-// doesn't have tiers yet. Define compat and two tiers with the same value since the macros in this file expect more than one tier.
-// compat tier0 tier1
-#define LIMITS_EXPERIMENTAL(X) \
- X(experimentalImmediateDataLimits, Maximum, maxImmediateDataRangeByteSize, 16, 16, 16)
+ X(v1, Maximum, maxColorAttachments, 4, 8, 8) \
+ X(v1, Maximum, maxImmediateSize, 0, 0, 16)
// clang-format on
@@ -157,8 +152,7 @@
LIMITS_ATTACHMENTS(X) \
LIMITS_INTER_STAGE_SHADER_VARIABLES(X) \
LIMITS_TEXTURE_DIMENSIONS(X) \
- LIMITS_OTHER(X) \
- LIMITS_EXPERIMENTAL(X)
+ LIMITS_OTHER(X)
namespace dawn::native {
namespace {
@@ -274,17 +268,9 @@
out->v1 = **unpacked;
out->v1.nextInChain = nullptr;
- if (auto* requiredExperimentalImmediateDataLimits =
- unpacked.Get<DawnExperimentalImmediateDataLimits>()) {
- DAWN_INVALID_IF(
- !supportedFeatures.contains(wgpu::FeatureName::ChromiumExperimentalImmediate),
- "ImmediateData is not supported without ChromiumExperimentalImmediateData supported.");
- out->experimentalImmediateDataLimits = *requiredExperimentalImmediateDataLimits;
- out->experimentalImmediateDataLimits.nextInChain = nullptr;
- }
-
// TODO(crbug.com/378361783): Add validation and default values to support requiring limits for
- // DawnTexelCopyBufferRowAlignmentLimits.
+ // DawnTexelCopyBufferRowAlignmentLimits. Test this, see old test removed here:
+ // https://dawn-review.googlesource.com/c/dawn/+/240934/11/src/dawn/tests/unittests/native/LimitsTests.cpp#b269
if (unpacked.Get<DawnTexelCopyBufferRowAlignmentLimits>()) {
dawn::WarningLog()
<< "DawnTexelCopyBufferRowAlignmentLimits is not supported in required limits";
@@ -307,12 +293,6 @@
// copy required v1 limits.
out->v1 = **unpacked;
out->v1.nextInChain = nullptr;
-
- if (auto* requiredExperimentalImmediateDataLimits =
- unpacked.Get<DawnExperimentalImmediateDataLimits>()) {
- out->experimentalImmediateDataLimits = *requiredExperimentalImmediateDataLimits;
- out->experimentalImmediateDataLimits.nextInChain = nullptr;
- }
}
MaybeError ValidateLimits(const CombinedLimits& supportedLimits,
@@ -401,8 +381,8 @@
}
void NormalizeLimits(CombinedLimits* limits) {
- // Enforce internal Dawn constants for some limits to ensure they don't go over fixed-size
- // arrays in Dawn's internal code.
+ // Enforce internal Dawn constants for some limits to ensure they don't go over fixed limits
+ // in Dawn's internal code.
limits->v1.maxVertexBufferArrayStride =
std::min(limits->v1.maxVertexBufferArrayStride, kMaxVertexBufferArrayStride);
limits->v1.maxColorAttachments =
@@ -432,17 +412,14 @@
std::min(limits->v1.maxStorageTexturesInFragmentStage, kMaxStorageTexturesPerShaderStage);
limits->v1.maxUniformBuffersPerShaderStage =
std::min(limits->v1.maxUniformBuffersPerShaderStage, kMaxUniformBuffersPerShaderStage);
+ limits->v1.maxImmediateSize =
+ std::min(limits->v1.maxImmediateSize, kMaxSupportedImmediateDataBytes);
// Additional enforcement for dependent limits.
limits->v1.maxStorageBufferBindingSize =
std::min(limits->v1.maxStorageBufferBindingSize, limits->v1.maxBufferSize);
limits->v1.maxUniformBufferBindingSize =
std::min(limits->v1.maxUniformBufferBindingSize, limits->v1.maxBufferSize);
-
- // Enforce immediate data bytes to ensure they don't go over a fixed limit in Dawn's internal
- // code.
- limits->experimentalImmediateDataLimits.maxImmediateDataRangeByteSize =
- kMaxSupportedImmediateDataBytes;
}
void EnforceLimitSpecInvariants(Limits* limits, wgpu::FeatureLevel featureLevel) {
@@ -491,23 +468,6 @@
unpacked->nextInChain = originalChain;
}
- if (auto* immediateDataLimits = unpacked.Get<DawnExperimentalImmediateDataLimits>()) {
- wgpu::ChainedStructOut* originalChain = immediateDataLimits->nextInChain;
- if (!supportedFeatures.IsEnabled(wgpu::FeatureName::ChromiumExperimentalImmediate)) {
- // If immediate data features are not supported, return the default-initialized
- // DawnExperimentalImmediateDataLimits object, where maxImmediateDataByteSize is
- // WGPU_LIMIT_U32_UNDEFINED.
- *immediateDataLimits = DawnExperimentalImmediateDataLimits{};
- } else {
- // If adapter supports immediate data features, always return the valid immediate data
- // limits.
- *immediateDataLimits = combinedLimits.experimentalImmediateDataLimits;
- }
-
- // Recover origin chain.
- immediateDataLimits->nextInChain = originalChain;
- }
-
if (auto* texelCopyBufferRowAlignmentLimits =
unpacked.Get<DawnTexelCopyBufferRowAlignmentLimits>()) {
wgpu::ChainedStructOut* originalChain = texelCopyBufferRowAlignmentLimits->nextInChain;
diff --git a/src/dawn/native/Limits.h b/src/dawn/native/Limits.h
index afe8a51..825c40e 100644
--- a/src/dawn/native/Limits.h
+++ b/src/dawn/native/Limits.h
@@ -40,7 +40,6 @@
struct CombinedLimits {
Limits v1;
- DawnExperimentalImmediateDataLimits experimentalImmediateDataLimits;
DawnHostMappedPointerLimits hostMappedPointerLimits;
DawnTexelCopyBufferRowAlignmentLimits texelCopyBufferRowAlignmentLimits;
};
diff --git a/src/dawn/native/PipelineLayout.cpp b/src/dawn/native/PipelineLayout.cpp
index 64d3356..702f0b4 100644
--- a/src/dawn/native/PipelineLayout.cpp
+++ b/src/dawn/native/PipelineLayout.cpp
@@ -99,19 +99,12 @@
DAWN_TRY(ValidateBindingCounts(device->GetLimits(), bindingCounts, device->GetAdapter()));
- // Validate immediateDataRangeByteSize.
- if (descriptor->immediateDataRangeByteSize) {
- DAWN_INVALID_IF(!device->HasFeature(Feature::ChromiumExperimentalImmediate),
- "Set non-zero immediateDatRangeByteSize without "
- "%s feature is not allowed.",
- ToAPI(Feature::ChromiumExperimentalImmediate));
-
- uint32_t maxImmediateDataRangeByteSize =
- device->GetLimits().experimentalImmediateDataLimits.maxImmediateDataRangeByteSize;
-
- DAWN_INVALID_IF(descriptor->immediateDataRangeByteSize > maxImmediateDataRangeByteSize,
- "immediateDataRangeByteSize (%i) is larger than the maximum allowed (%i).",
- descriptor->immediateDataRangeByteSize, maxImmediateDataRangeByteSize);
+ // Validate immediateSize.
+ if (descriptor->immediateSize) {
+ uint32_t maxImmediateSize = device->GetLimits().v1.maxImmediateSize;
+ DAWN_INVALID_IF(descriptor->immediateSize > maxImmediateSize,
+ "immediateSize (%i) is larger than the maximum allowed (%i).",
+ descriptor->immediateSize, maxImmediateSize);
}
return unpacked;
@@ -134,7 +127,7 @@
const UnpackedPtr<PipelineLayoutDescriptor>& descriptor,
ApiObjectBase::UntrackedByDeviceTag tag)
: ApiObjectBase(device, descriptor->label),
- mImmediateDataRangeByteSize(descriptor->immediateDataRangeByteSize) {
+ mImmediateDataRangeByteSize(descriptor->immediateSize) {
DAWN_ASSERT(descriptor->bindGroupLayoutCount <= kMaxBindGroups);
// According to WebGPU SPEC of CreatePipelineLayout(), if bindGroupLayouts[i] is null or
@@ -441,7 +434,7 @@
PipelineLayoutDescriptor desc = {};
desc.bindGroupLayouts = bgls.data();
desc.bindGroupLayoutCount = static_cast<uint32_t>(kMaxBindGroupsTyped);
- desc.immediateDataRangeByteSize = immediateDataRangeByteSize;
+ desc.immediateSize = immediateDataRangeByteSize;
Ref<PipelineLayoutBase> result;
DAWN_TRY_ASSIGN(result, device->CreatePipelineLayout(&desc, pipelineCompatibilityToken));
@@ -480,7 +473,7 @@
const BindGroupLayoutInternalBase* PipelineLayoutBase::GetBindGroupLayout(
BindGroupIndex group) const {
- return GetFrontendBindGroupLayout(group)->GetInternalBindGroupLayout();
+ return GetFrontendBindGroupLayout(group)->GetInternalBindGroupLayout();
}
const BindGroupMask& PipelineLayoutBase::GetBindGroupLayoutsMask() const {
diff --git a/src/dawn/native/ProgrammableEncoder.cpp b/src/dawn/native/ProgrammableEncoder.cpp
index 5b2dfe8..219d5cd 100644
--- a/src/dawn/native/ProgrammableEncoder.cpp
+++ b/src/dawn/native/ProgrammableEncoder.cpp
@@ -119,30 +119,23 @@
mEncodingContext->TryEncode(
this,
[&](CommandAllocator* allocator) -> MaybeError {
- DAWN_INVALID_IF(!GetDevice()->HasFeature(Feature::ChromiumExperimentalImmediate),
- "SetImmediateData() called without "
- "Feature::ChromiumExperimentalImmediate supported.");
-
if (IsValidationEnabled()) {
- uint32_t maxImmediateDataRangeByteSize =
- GetDevice()
- ->GetLimits()
- .experimentalImmediateDataLimits.maxImmediateDataRangeByteSize;
+ uint32_t maxImmediateSize = GetDevice()->GetLimits().v1.maxImmediateSize;
+ DAWN_INVALID_IF(maxImmediateSize == 0,
+ "immediates are not enabled (the device's maxImmediateSize is 0; "
+ "AllowUnsafeAPIs may be needed to raise the adapter limit)");
+
// Validate offset and size are aligned to 4 bytes.
DAWN_INVALID_IF(offset % 4 != 0, "offset (%u) is not a multiple of 4", offset);
DAWN_INVALID_IF(size % 4 != 0, "size (%u) is not a multiple of 4", size);
// Validate OOB
- DAWN_INVALID_IF(offset > maxImmediateDataRangeByteSize,
- "offset (%u) is larger than maxImmediateDataRangeByteSize (%u).",
- offset, maxImmediateDataRangeByteSize);
- DAWN_INVALID_IF(size > maxImmediateDataRangeByteSize,
- "size (%u) is larger than maxImmediateDataRangeByteSize (%u).",
- size, maxImmediateDataRangeByteSize);
- DAWN_INVALID_IF(
- size > maxImmediateDataRangeByteSize - offset,
- "offset (%u) + size (%u): is larger than maxImmediateDataRangeByteSize (%u).",
- offset, size, maxImmediateDataRangeByteSize);
+ DAWN_INVALID_IF(offset > maxImmediateSize,
+ "offset (%u) is larger than maxImmediateSize (%u).", offset,
+ maxImmediateSize);
+ DAWN_INVALID_IF(size > maxImmediateSize - offset,
+ "offset (%u) + size (%u): is larger than maxImmediateSize (%u).",
+ offset, size, maxImmediateSize);
}
// Skip SetImmediateData when uploading constants are empty.
diff --git a/src/dawn/native/Toggles.cpp b/src/dawn/native/Toggles.cpp
index 67dc02b..8068400 100644
--- a/src/dawn/native/Toggles.cpp
+++ b/src/dawn/native/Toggles.cpp
@@ -563,7 +563,7 @@
"https://crbug.com/dawn/2260", ToggleStage::Instance}},
{Toggle::ExposeWGSLExperimentalFeatures,
{"expose_wgsl_experimental_features",
- "Make the Instance expose the experimental features but not the unsage ones, so that safe "
+ "Make the Instance expose the experimental features but not the unsafe ones, so that safe "
"experimental features can be used without the need for allow_unsafe_apis",
"https://crbug.com/dawn/2260", ToggleStage::Instance}},
{Toggle::DisablePolyfillsOnIntegerDivisonAndModulo,
@@ -700,6 +700,7 @@
"https://crbug.com/333424893", ToggleStage::Device}},
// Comment to separate the }} so it is clearer what to copy-paste to add a toggle.
}};
+
} // anonymous namespace
void TogglesSet::Set(Toggle toggle, bool enabled) {
diff --git a/src/dawn/native/null/DeviceNull.cpp b/src/dawn/native/null/DeviceNull.cpp
index 6f5f451..566654d 100644
--- a/src/dawn/native/null/DeviceNull.cpp
+++ b/src/dawn/native/null/DeviceNull.cpp
@@ -96,7 +96,7 @@
MaybeError PhysicalDevice::InitializeSupportedLimitsImpl(CombinedLimits* limits) {
GetDefaultLimitsForSupportedFeatureLevel(limits);
// Set the subgroups limit, as DeviceNull should support subgroups feature.
- limits->experimentalImmediateDataLimits.maxImmediateDataRangeByteSize =
+ limits->v1.maxImmediateSize =
kMaxExternalImmediateConstantsPerPipeline * kImmediateConstantElementByteSize;
return {};
}
diff --git a/src/dawn/native/vulkan/PhysicalDeviceVk.cpp b/src/dawn/native/vulkan/PhysicalDeviceVk.cpp
index 5f4a5c7..117b431 100644
--- a/src/dawn/native/vulkan/PhysicalDeviceVk.cpp
+++ b/src/dawn/native/vulkan/PhysicalDeviceVk.cpp
@@ -546,8 +546,6 @@
if (mDeviceInfo.HasExt(DeviceExt::ImageDrmFormatModifier)) {
EnableFeature(Feature::DawnDrmFormatCapabilities);
}
-
- EnableFeature(Feature::ChromiumExperimentalImmediate);
}
MaybeError PhysicalDevice::InitializeSupportedLimitsImpl(CombinedLimits* limits) {
@@ -737,12 +735,14 @@
}
}
- // vulkan needs to have enough push constant range size for all
+ // Vulkan needs to have enough push constant range size for all
// internal and external immediate data usages.
- constexpr uint32_t kMinVulkanPushConstants = 128;
- DAWN_ASSERT(vkLimits.maxPushConstantsSize >= kMinVulkanPushConstants);
- static_assert(kMinVulkanPushConstants >= sizeof(RenderImmediateConstants));
- static_assert(kMinVulkanPushConstants >= sizeof(ComputeImmediateConstants));
+ constexpr uint32_t kVkGuaranteedMaxPushConstantsSize = 128; // from Vulkan spec
+ static_assert(kVkGuaranteedMaxPushConstantsSize >=
+ kDefaultMaxImmediateDataBytes + std::max(sizeof(RenderImmediateConstants),
+ sizeof(ComputeImmediateConstants)));
+ DAWN_ASSERT(vkLimits.maxPushConstantsSize >= kVkGuaranteedMaxPushConstantsSize);
+ limits->v1.maxImmediateSize = kDefaultMaxImmediateDataBytes;
if (mDeviceInfo.HasExt(DeviceExt::ExternalMemoryHost) &&
mDeviceInfo.externalMemoryHostProperties.minImportedHostPointerAlignment <=
diff --git a/src/dawn/node/binding/Converter.cpp b/src/dawn/node/binding/Converter.cpp
index c5e3c9c..4622cf5 100644
--- a/src/dawn/node/binding/Converter.cpp
+++ b/src/dawn/node/binding/Converter.cpp
@@ -1533,9 +1533,6 @@
case interop::GPUFeatureName::kDualSourceBlending:
out = wgpu::FeatureName::DualSourceBlending;
return true;
- case interop::GPUFeatureName::kChromiumExperimentalImmediate:
- out = wgpu::FeatureName::ChromiumExperimentalImmediate;
- return true;
case interop::GPUFeatureName::kClipDistances:
out = wgpu::FeatureName::ClipDistances;
return true;
@@ -1572,7 +1569,6 @@
CASE(MultiDrawIndirect, kMultiDrawIndirect);
CASE(DualSourceBlending, kDualSourceBlending);
CASE(ClipDistances, kClipDistances);
- CASE(ChromiumExperimentalImmediate, kChromiumExperimentalImmediate);
CASE(ChromiumExperimentalSubgroupMatrix, kChromiumExperimentalSubgroupMatrix);
#undef CASE
diff --git a/src/dawn/node/binding/GPUAdapter.cpp b/src/dawn/node/binding/GPUAdapter.cpp
index f0d9784..0f180ab 100644
--- a/src/dawn/node/binding/GPUAdapter.cpp
+++ b/src/dawn/node/binding/GPUAdapter.cpp
@@ -99,20 +99,6 @@
interop::Interface<interop::GPUSupportedLimits> GPUAdapter::getLimits(Napi::Env env) {
wgpu::Limits limits{};
- wgpu::DawnExperimentalImmediateDataLimits immediateDataLimits{};
-
- auto InsertInChain = [&](wgpu::ChainedStructOut* node) {
- node->nextInChain = limits.nextInChain;
- limits.nextInChain = node;
- };
-
- wgpu::ChainedStructOut** limitsListTail = &limits.nextInChain;
- // Query the immediate data limits only if ChromiumExperimentalImmediateData feature
- // is available on adapter.
- if (adapter_.HasFeature(FeatureName::ChromiumExperimentalImmediate)) {
- InsertInChain(&immediateDataLimits);
- }
-
if (!adapter_.GetLimits(&limits)) {
Napi::Error::New(env, "failed to get adapter limits").ThrowAsJavaScriptException();
}
diff --git a/src/dawn/node/binding/GPUDevice.cpp b/src/dawn/node/binding/GPUDevice.cpp
index 938ba3b..19e95df 100644
--- a/src/dawn/node/binding/GPUDevice.cpp
+++ b/src/dawn/node/binding/GPUDevice.cpp
@@ -183,22 +183,10 @@
interop::Interface<interop::GPUSupportedLimits> GPUDevice::getLimits(Napi::Env env) {
wgpu::Limits limits{};
- wgpu::DawnExperimentalImmediateDataLimits immediateDataLimits{};
-
- auto InsertInChain = [&](wgpu::ChainedStructOut* node) {
- node->nextInChain = limits.nextInChain;
- limits.nextInChain = node;
- };
-
- // Query the immediate data limits only if ChromiumExperimentalImmediateData feature
- // is available on device.
- if (device_.HasFeature(FeatureName::ChromiumExperimentalImmediate)) {
- InsertInChain(&immediateDataLimits);
- }
-
if (!device_.GetLimits(&limits)) {
Napi::Error::New(env, "failed to get device limits").ThrowAsJavaScriptException();
}
+
return interop::GPUSupportedLimits::Create<GPUSupportedLimits>(env, limits);
}
diff --git a/src/dawn/node/interop/DawnExtensions.idl b/src/dawn/node/interop/DawnExtensions.idl
index 76dce3a..a996f31 100644
--- a/src/dawn/node/interop/DawnExtensions.idl
+++ b/src/dawn/node/interop/DawnExtensions.idl
@@ -30,7 +30,6 @@
enum GPUFeatureName {
"multi-draw-indirect",
- "chromium-experimental-immediate",
"chromium-experimental-subgroup-matrix",
"core-features-and-limits",
};
diff --git a/src/dawn/tests/end2end/ImmediateDataTests.cpp b/src/dawn/tests/end2end/ImmediateDataTests.cpp
index a08824a..f359594 100644
--- a/src/dawn/tests/end2end/ImmediateDataTests.cpp
+++ b/src/dawn/tests/end2end/ImmediateDataTests.cpp
@@ -40,8 +40,8 @@
class ImmediateDataTests : public DawnTest {
protected:
- std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
- return {wgpu::FeatureName::ChromiumExperimentalImmediate};
+ wgpu::Limits GetRequiredLimits(const wgpu::Limits&) override {
+ return wgpu::Limits{.maxImmediateSize = kDefaultMaxImmediateDataBytes};
}
void SetUp() override {
@@ -109,7 +109,7 @@
wgpu::PipelineLayoutDescriptor pipelineLayoutDesc;
pipelineLayoutDesc.bindGroupLayoutCount = 1;
pipelineLayoutDesc.bindGroupLayouts = &bindGroupLayout;
- pipelineLayoutDesc.immediateDataRangeByteSize = kDefaultMaxImmediateDataBytes;
+ pipelineLayoutDesc.immediateSize = kDefaultMaxImmediateDataBytes;
return device.CreatePipelineLayout(&pipelineLayoutDesc);
}
diff --git a/src/dawn/tests/unittests/native/DeviceCreationTests.cpp b/src/dawn/tests/unittests/native/DeviceCreationTests.cpp
index 56bee86..6a945d7 100644
--- a/src/dawn/tests/unittests/native/DeviceCreationTests.cpp
+++ b/src/dawn/tests/unittests/native/DeviceCreationTests.cpp
@@ -327,6 +327,41 @@
}
}
+// Test that maxImmediateSize is available iff the adapter has AllowUnsafeAPIs.
+TEST_F(DeviceCreationTest, AdapterMaxImmediateSize) {
+ wgpu::Limits requiredLimits{.maxImmediateSize = 1};
+ wgpu::DeviceDescriptor deviceDesc;
+ deviceDesc.requiredLimits = &requiredLimits;
+
+ {
+ wgpu::Adapter wgpuAdapter{adapter.Get()};
+ wgpu::Limits limits;
+ wgpuAdapter.GetLimits(&limits);
+ EXPECT_EQ(limits.maxImmediateSize, 0u);
+
+ wgpuAdapter.RequestDevice(
+ &deviceDesc, wgpu::CallbackMode::AllowSpontaneous,
+ [](wgpu::RequestDeviceStatus status, wgpu::Device device, wgpu::StringView message) {
+ EXPECT_EQ(status, wgpu::RequestDeviceStatus::Error);
+ EXPECT_EQ(device.Get(), nullptr);
+ });
+ }
+
+ // The null backend always supports immediates.
+ {
+ wgpu::Adapter wgpuAdapter{unsafeAdapter.Get()};
+ wgpu::Limits limits;
+ wgpuAdapter.GetLimits(&limits);
+ EXPECT_GT(limits.maxImmediateSize, 0u);
+ wgpuAdapter.RequestDevice(
+ &deviceDesc, wgpu::CallbackMode::AllowSpontaneous,
+ [](wgpu::RequestDeviceStatus status, wgpu::Device device, wgpu::StringView message) {
+ EXPECT_EQ(status, wgpu::RequestDeviceStatus::Success);
+ EXPECT_NE(device.Get(), nullptr);
+ });
+ }
+}
+
class DeviceCreationFutureTest : public DeviceCreationTest,
public ::testing::WithParamInterface<wgpu::CallbackMode> {
protected:
diff --git a/src/dawn/tests/unittests/native/LimitsTests.cpp b/src/dawn/tests/unittests/native/LimitsTests.cpp
index a2e37bb..4b08553 100644
--- a/src/dawn/tests/unittests/native/LimitsTests.cpp
+++ b/src/dawn/tests/unittests/native/LimitsTests.cpp
@@ -45,7 +45,7 @@
EXPECT_EQ(limits.v1.maxBindGroups, 4u);
}
-// Test |GetDefaultLimits| returns the default for FeatureLeveL::Compatibility.
+// Test |GetDefaultLimits| returns the default for FeatureLevel::Compatibility.
// Compatibility default limits are lower than Core.
TEST(Limits, GetDefaultLimits_Compat) {
CombinedLimits limits = {};
@@ -56,30 +56,6 @@
EXPECT_EQ(limits.v1.maxColorAttachments, 4u);
}
-// Test |GetDefaultLimits| returns the default immediate data range
-// limits kDeviceDefaultImmediateDataBytes.
-TEST(Limits, GetDeviceDefaultImmediateDataLimit) {
- // Core
- {
- CombinedLimits limits = {};
- EXPECT_NE(limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
-
- GetDefaultLimits(&limits, wgpu::FeatureLevel::Core);
-
- EXPECT_EQ(limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
- }
-
- // Compatibility
- {
- CombinedLimits limits = {};
- EXPECT_NE(limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
-
- GetDefaultLimits(&limits, wgpu::FeatureLevel::Compatibility);
-
- EXPECT_EQ(limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
- }
-}
-
// Test |ReifyDefaultLimits| populates the default for wgpu::FeatureLevel::Core
// if values are undefined.
TEST(Limits, ReifyDefaultLimits_PopulatesDefault) {
@@ -124,74 +100,6 @@
EXPECT_EQ(reified.v1.minUniformBufferOffsetAlignment, 256u);
}
-// Test |ReifyDefaultLimits| update the default value if provided
-// immediate data range byte size is supported.
-TEST(Limits, ReifyDeviceDefaultImmediateDataLimits) {
- // Core
- {
- CombinedLimits limits;
- limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize = 32u;
-
- CombinedLimits reified = ReifyDefaultLimits(limits, wgpu::FeatureLevel::Core);
- EXPECT_EQ(reified.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 32u);
- }
-
- // Compatibility
- {
- CombinedLimits limits;
- limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize = 32u;
-
- CombinedLimits reified = ReifyDefaultLimits(limits, wgpu::FeatureLevel::Compatibility);
- EXPECT_EQ(reified.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 32u);
- }
-}
-
-// Test |ReifyDefaultLimits| populates the device default immediate data
-// range byte size if the provided limits are undefined.
-TEST(Limits, ReifyDeviceDefaultImmediateDataLimits_PopulatesDefault) {
- // Core
- {
- CombinedLimits limits;
- limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize =
- wgpu::kLimitU32Undefined;
-
- CombinedLimits reified = ReifyDefaultLimits(limits, wgpu::FeatureLevel::Core);
- EXPECT_EQ(reified.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
- }
-
- // Compatibility
- {
- CombinedLimits limits;
- limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize =
- wgpu::kLimitU32Undefined;
-
- CombinedLimits reified = ReifyDefaultLimits(limits, wgpu::FeatureLevel::Compatibility);
- EXPECT_EQ(reified.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
- }
-}
-
-// Test |ReifyDeviceDefaultImmediateDataLimits| clamps to the device default immediate data
-// range byte size if the provided limits are worse.
-TEST(Limits, ReifyDeviceDefaultImmediateDataLimits_Clamps) {
- // Core
- {
- CombinedLimits limits;
- limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize = 8u;
-
- CombinedLimits reified = ReifyDefaultLimits(limits, wgpu::FeatureLevel::Core);
- EXPECT_EQ(reified.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
- }
-
- // Compatibility
- {
- CombinedLimits limits;
- limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize = 8u;
-
- CombinedLimits reified = ReifyDefaultLimits(limits, wgpu::FeatureLevel::Compatibility);
- EXPECT_EQ(reified.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize, 16u);
- }
-}
-
// Test |ValidateLimits| works to validate limits are not better
// than supported.
TEST(Limits, ValidateLimits) {
@@ -266,32 +174,6 @@
}
}
-// Test |ValidateAndUnpackLimitsIn| check chained limits are valid.
-TEST(Limits, ValidateAndUnpackedIn) {
- Limits requiredLimits;
- DawnExperimentalImmediateDataLimits dawnExperimentalImmediateDataLimits =
- DawnExperimentalImmediateDataLimits{};
- requiredLimits.nextInChain = &dawnExperimentalImmediateDataLimits;
- std::unordered_set<wgpu::FeatureName> supportedFeatures;
-
- // Success
- {
- supportedFeatures.insert(wgpu::FeatureName::ChromiumExperimentalImmediate);
- CombinedLimits limits = {};
- EXPECT_TRUE(
- ValidateAndUnpackLimitsIn(&requiredLimits, supportedFeatures, &limits).IsSuccess());
- }
-
- // Fail
- {
- supportedFeatures.clear();
- CombinedLimits limits = {};
- MaybeError err = ValidateAndUnpackLimitsIn(&requiredLimits, supportedFeatures, &limits);
- EXPECT_TRUE(err.IsError());
- err.AcquireError();
- }
-}
-
// Test that |ApplyLimitTiers| degrades limits to the next best tier.
TEST(Limits, ApplyLimitTiers) {
auto SetLimitsStorageBufferBindingSizeTier2 = [](CombinedLimits* limits) {
@@ -491,8 +373,7 @@
limits.v1.maxStorageBuffersPerShaderStage = kMaxStorageBuffersPerShaderStage + 1;
limits.v1.maxStorageTexturesPerShaderStage = kMaxStorageTexturesPerShaderStage + 1;
limits.v1.maxUniformBuffersPerShaderStage = kMaxUniformBuffersPerShaderStage + 1;
- limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize =
- kMaxSupportedImmediateDataBytes + 1;
+ limits.v1.maxImmediateSize = kMaxSupportedImmediateDataBytes + 1;
NormalizeLimits(&limits);
@@ -507,8 +388,7 @@
EXPECT_EQ(limits.v1.maxStorageBuffersPerShaderStage, kMaxStorageBuffersPerShaderStage);
EXPECT_EQ(limits.v1.maxStorageTexturesPerShaderStage, kMaxStorageTexturesPerShaderStage);
EXPECT_EQ(limits.v1.maxUniformBuffersPerShaderStage, kMaxUniformBuffersPerShaderStage);
- EXPECT_EQ(limits.experimentalImmediateDataLimits.maxImmediateDataRangeByteSize,
- kMaxSupportedImmediateDataBytes);
+ EXPECT_EQ(limits.v1.maxImmediateSize, kMaxSupportedImmediateDataBytes);
}
// Test maxStorageBufferBindingSize is clamped to maxBufferSize.
diff --git a/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp b/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp
index a60d6f1..97596ff 100644
--- a/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp
@@ -351,27 +351,8 @@
DAWN_SKIP_TEST_IF(UsesWire());
}
- std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
- return {wgpu::FeatureName::ChromiumExperimentalImmediate};
- }
-
- uint32_t GetMaxImmediateDataRangeByteSize(const wgpu::Limits& limits) {
- wgpu::ChainedStructOut* experimentalImmediateDataLimits = limits.nextInChain;
- while (experimentalImmediateDataLimits != nullptr &&
- experimentalImmediateDataLimits->sType !=
- wgpu::SType::DawnExperimentalImmediateDataLimits) {
- experimentalImmediateDataLimits = limits.nextInChain;
- }
-
- if (!experimentalImmediateDataLimits) {
- return 0;
- }
-
- wgpu::DawnExperimentalImmediateDataLimits* immediateDataLimits =
- static_cast<wgpu::DawnExperimentalImmediateDataLimits*>(
- experimentalImmediateDataLimits);
-
- return immediateDataLimits->maxImmediateDataRangeByteSize;
+ wgpu::Limits GetRequiredLimits(const wgpu::Limits&) override {
+ return wgpu::Limits{.maxImmediateSize = kDefaultMaxImmediateDataBytes};
}
MockCppCallback<void (*)(wgpu::RequestDeviceStatus, wgpu::Device, wgpu::StringView)>
@@ -381,65 +362,47 @@
// Test that requesting a device where a required immediate data range byte size limit is above the
// maximum value.
TEST_F(RequestDeviceWithImmediateDataValidationTest, HigherIsBetter) {
- wgpu::DawnExperimentalImmediateDataLimits experimentalImmediateData =
- wgpu::DawnExperimentalImmediateDataLimits{};
wgpu::Limits limits = {};
- limits.nextInChain = &experimentalImmediateData;
wgpu::DeviceDescriptor descriptor;
- std::array<wgpu::FeatureName, 1> requiredFeatures = {
- wgpu::FeatureName::ChromiumExperimentalImmediate};
- descriptor.requiredFeatures = requiredFeatures.data();
- descriptor.requiredFeatureCount = requiredFeatures.size();
descriptor.requiredLimits = &limits;
wgpu::Limits supportedLimits;
- wgpu::DawnExperimentalImmediateDataLimits dawnExperimentalImmediateDataLimits =
- wgpu::DawnExperimentalImmediateDataLimits{};
- supportedLimits.nextInChain = &dawnExperimentalImmediateDataLimits;
EXPECT_EQ(adapter.GetLimits(&supportedLimits), wgpu::Status::Success);
- uint32_t supportedImmediateDataLimit = GetMaxImmediateDataRangeByteSize(supportedLimits);
+ uint32_t supportedImmediateDataLimit = supportedLimits.maxImmediateSize;
// If we can support better than the default, test below the max.
if (supportedImmediateDataLimit >= kDefaultMaxImmediateDataBytes) {
- experimentalImmediateData.maxImmediateDataRangeByteSize = kDefaultMaxImmediateDataBytes;
+ limits.maxImmediateSize = kDefaultMaxImmediateDataBytes;
EXPECT_CALL(mRequestDeviceCallback,
Call(wgpu::RequestDeviceStatus::Success, NotNull(), EmptySizedString()))
.WillOnce(WithArgs<1>([&](wgpu::Device device) {
wgpu::Limits deviceLimits;
- wgpu::DawnExperimentalImmediateDataLimits dawnExperimentalImmediateDataLimits =
- wgpu::DawnExperimentalImmediateDataLimits{};
- deviceLimits.nextInChain = &dawnExperimentalImmediateDataLimits;
device.GetLimits(&deviceLimits);
// Check we got exactly the request.
- EXPECT_EQ(GetMaxImmediateDataRangeByteSize(deviceLimits),
- kDefaultMaxImmediateDataBytes);
+ EXPECT_EQ(deviceLimits.maxImmediateSize, kDefaultMaxImmediateDataBytes);
}));
adapter.RequestDevice(&descriptor, wgpu::CallbackMode::AllowSpontaneous,
mRequestDeviceCallback.Callback());
}
// Test the max.
- experimentalImmediateData.maxImmediateDataRangeByteSize = supportedImmediateDataLimit;
+ limits.maxImmediateSize = supportedImmediateDataLimit;
EXPECT_CALL(mRequestDeviceCallback,
Call(wgpu::RequestDeviceStatus::Success, NotNull(), EmptySizedString()))
.WillOnce(WithArgs<1>([&](wgpu::Device device) {
wgpu::Limits deviceLimits;
- wgpu::DawnExperimentalImmediateDataLimits dawnExperimentalImmediateDataLimits =
- wgpu::DawnExperimentalImmediateDataLimits{};
- deviceLimits.nextInChain = &dawnExperimentalImmediateDataLimits;
-
device.GetLimits(&deviceLimits);
// Check we got exactly the request.
- EXPECT_EQ(GetMaxImmediateDataRangeByteSize(deviceLimits), supportedImmediateDataLimit);
+ EXPECT_EQ(deviceLimits.maxImmediateSize, supportedImmediateDataLimit);
}));
adapter.RequestDevice(&descriptor, wgpu::CallbackMode::AllowSpontaneous,
mRequestDeviceCallback.Callback());
// Test above the max.
- experimentalImmediateData.maxImmediateDataRangeByteSize = supportedImmediateDataLimit + 4;
+ limits.maxImmediateSize = supportedImmediateDataLimit + 4;
EXPECT_CALL(mRequestDeviceCallback,
Call(wgpu::RequestDeviceStatus::Error, IsNull(), NonEmptySizedString()))
.Times(1);
@@ -447,17 +410,14 @@
mRequestDeviceCallback.Callback());
// Test worse than the default
- experimentalImmediateData.maxImmediateDataRangeByteSize = kDefaultMaxImmediateDataBytes / 2;
+ limits.maxImmediateSize = kDefaultMaxImmediateDataBytes / 2;
EXPECT_CALL(mRequestDeviceCallback,
Call(wgpu::RequestDeviceStatus::Success, NotNull(), EmptySizedString()))
.WillOnce(WithArgs<1>([&](wgpu::Device device) {
wgpu::Limits deviceLimits;
- wgpu::DawnExperimentalImmediateDataLimits dawnExperimentalImmediateDataLimits =
- wgpu::DawnExperimentalImmediateDataLimits{};
- deviceLimits.nextInChain = &dawnExperimentalImmediateDataLimits;
device.GetLimits(&deviceLimits);
- EXPECT_EQ(GetMaxImmediateDataRangeByteSize(deviceLimits),
- kDefaultMaxImmediateDataBytes);
+ // Check we got exactly the request because it's between tier0 and tier1.
+ EXPECT_EQ(deviceLimits.maxImmediateSize, kDefaultMaxImmediateDataBytes / 2);
}));
adapter.RequestDevice(&descriptor, wgpu::CallbackMode::AllowSpontaneous,
mRequestDeviceCallback.Callback());
diff --git a/src/dawn/tests/unittests/validation/ImmediateDataTests.cpp b/src/dawn/tests/unittests/validation/ImmediateDataTests.cpp
index dc66bde..81a3776 100644
--- a/src/dawn/tests/unittests/validation/ImmediateDataTests.cpp
+++ b/src/dawn/tests/unittests/validation/ImmediateDataTests.cpp
@@ -40,22 +40,40 @@
class ImmediateDataDisableTest : public ValidationTest {};
-// Check that creating a PipelineLayout with non-zero immediateDataRangeByteSize is disallowed
+// Check that creating a PipelineLayout with non-zero immediateSize is disallowed
// without the feature enabled.
-TEST_F(ImmediateDataDisableTest, ImmediateDataRangeByteSizeNotAllowed) {
+TEST_F(ImmediateDataDisableTest, ImmediateSizeNotAllowed) {
wgpu::PipelineLayoutDescriptor desc;
desc.bindGroupLayoutCount = 0;
- desc.immediateDataRangeByteSize = 1;
+ desc.immediateSize = 1;
ASSERT_DEVICE_ERROR(device.CreatePipelineLayout(&desc));
}
+// Check that SetImmediateData doesn't work (even with size=0) without maxImmediateSize>0.
+TEST_F(ImmediateDataDisableTest, SetImmediateData) {
+ {
+ wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+ wgpu::ComputePassEncoder pass = encoder.BeginComputePass();
+ pass.SetImmediateData(0, nullptr, 0);
+ pass.End();
+ ASSERT_DEVICE_ERROR(encoder.Finish());
+ }
+ {
+ const uint32_t data = 0;
+
+ wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+ wgpu::ComputePassEncoder pass = encoder.BeginComputePass();
+ pass.SetImmediateData(0, &data, 4);
+ pass.End();
+ ASSERT_DEVICE_ERROR(encoder.Finish());
+ }
+}
+
class ImmediateDataTest : public ValidationTest {
protected:
- std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
- // Test only the non-coherent version, ad assume that the same validaiton code paths are
- // taken for the coherent path
- return {wgpu::FeatureName::ChromiumExperimentalImmediate};
+ wgpu::Limits GetRequiredLimits(const wgpu::Limits&) override {
+ return wgpu::Limits{.maxImmediateSize = kDefaultMaxImmediateDataBytes};
}
wgpu::BindGroupLayout CreateBindGroupLayout() {
@@ -71,44 +89,40 @@
return device.CreateBindGroupLayout(&bindGroupLayoutDesc);
}
- wgpu::PipelineLayout CreatePipelineLayout(uint32_t requiredImmediateDataRangeByteSize) {
+ wgpu::PipelineLayout CreatePipelineLayout(uint32_t requiredImmediateSize) {
wgpu::BindGroupLayout bindGroupLayout = CreateBindGroupLayout();
wgpu::PipelineLayoutDescriptor pipelineLayoutDesc;
pipelineLayoutDesc.bindGroupLayoutCount = 1;
pipelineLayoutDesc.bindGroupLayouts = &bindGroupLayout;
- pipelineLayoutDesc.immediateDataRangeByteSize = requiredImmediateDataRangeByteSize;
+ pipelineLayoutDesc.immediateSize = requiredImmediateSize;
return device.CreatePipelineLayout(&pipelineLayoutDesc);
}
wgpu::ShaderModule mShaderModule;
};
-// Check that non-zero immediateDataRangeByteSize is possible with feature enabled and size must
+// Check that non-zero immediateSize is possible with feature enabled and size must
// below max size limits.
-TEST_F(ImmediateDataTest, ValidateImmediateDataRangeByteSize) {
- DAWN_SKIP_TEST_IF(!device.HasFeature(wgpu::FeatureName::ChromiumExperimentalImmediate));
-
+TEST_F(ImmediateDataTest, ValidateImmediateSize) {
wgpu::PipelineLayoutDescriptor desc;
desc.bindGroupLayoutCount = 0;
- // Success case with valid immediateDataRangeByteSize.
+ // Success case with valid immediateSize.
{
- desc.immediateDataRangeByteSize = kDefaultMaxImmediateDataBytes;
+ desc.immediateSize = kDefaultMaxImmediateDataBytes;
device.CreatePipelineLayout(&desc);
}
- // Failed case with invalid immediateDataRangeByteSize that exceed limits.
+ // Failed case with invalid immediateSize that exceed limits.
{
- desc.immediateDataRangeByteSize = kDefaultMaxImmediateDataBytes + 1;
+ desc.immediateSize = kDefaultMaxImmediateDataBytes + 1;
ASSERT_DEVICE_ERROR(device.CreatePipelineLayout(&desc));
}
}
// Check that SetImmediateData offset and length must be aligned to 4 bytes.
TEST_F(ImmediateDataTest, ValidateSetImmediateDataAlignment) {
- DAWN_SKIP_TEST_IF(!device.HasFeature(wgpu::FeatureName::ChromiumExperimentalImmediate));
-
// Success cases
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -149,8 +163,6 @@
// Check that SetImmediateData offset + length must be in bound.
TEST_F(ImmediateDataTest, ValidateSetImmediateDataOOB) {
- DAWN_SKIP_TEST_IF(!device.HasFeature(wgpu::FeatureName::ChromiumExperimentalImmediate));
-
// Success cases
{
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -224,7 +236,6 @@
// Check that pipelineLayout immediate data bytes compatible with shaders.
TEST_F(ImmediateDataTest, ValidatePipelineLayoutImmediateDataBytesAndShaders) {
- DAWN_SKIP_TEST_IF(!device.HasFeature(wgpu::FeatureName::ChromiumExperimentalImmediate));
constexpr uint32_t kShaderImmediateDataBytes = 12u;
wgpu::ShaderModule shaderModule = utils::CreateShaderModule(device, R"(
enable chromium_experimental_immediate;
@@ -308,7 +319,6 @@
// Check that default pipelineLayout has too many immediate data bytes .
TEST_F(ImmediateDataTest, ValidateDefaultPipelineLayout) {
- DAWN_SKIP_TEST_IF(!device.HasFeature(wgpu::FeatureName::ChromiumExperimentalImmediate));
wgpu::ShaderModule shaderModule = utils::CreateShaderModule(device, R"(
enable chromium_experimental_immediate;
var<immediate> fragmentConstants: vec4f;
diff --git a/src/dawn/wire/SupportedFeatures.cpp b/src/dawn/wire/SupportedFeatures.cpp
index 54ca704..7636eef 100644
--- a/src/dawn/wire/SupportedFeatures.cpp
+++ b/src/dawn/wire/SupportedFeatures.cpp
@@ -113,7 +113,6 @@
case WGPUFeatureName_DawnPartialLoadResolveTexture:
case WGPUFeatureName_Subgroups:
case WGPUFeatureName_ClipDistances:
- case WGPUFeatureName_ChromiumExperimentalImmediate:
case WGPUFeatureName_DawnTexelCopyBufferRowAlignment:
case WGPUFeatureName_FlexibleTextureViews:
case WGPUFeatureName_ChromiumExperimentalSubgroupMatrix:
diff --git a/src/dawn/wire/client/LimitsAndFeatures.cpp b/src/dawn/wire/client/LimitsAndFeatures.cpp
index 8ed62d0..e5aa437 100644
--- a/src/dawn/wire/client/LimitsAndFeatures.cpp
+++ b/src/dawn/wire/client/LimitsAndFeatures.cpp
@@ -46,13 +46,6 @@
// Store the WGPUChainedStruct to restore the chain after assignment.
WGPUChainedStruct originalChainedStruct = *chain;
switch (chain->sType) {
- case (WGPUSType_DawnExperimentalImmediateDataLimits): {
- auto* experimentalImmediateDataLimits =
- reinterpret_cast<WGPUDawnExperimentalImmediateDataLimits*>(chain);
- // This assignment break the next field of WGPUChainedStruct head.
- *experimentalImmediateDataLimits = mExperimentalImmediateDataLimits;
- break;
- }
case (WGPUSType_DawnTexelCopyBufferRowAlignmentLimits): {
auto* texelCopyBufferRowAlignmentLimits =
reinterpret_cast<WGPUDawnTexelCopyBufferRowAlignmentLimits*>(chain);
@@ -104,13 +97,6 @@
// Handle other limits that chained after WGPUSupportedLimits
for (auto* chain = limits->nextInChain; chain; chain = chain->next) {
switch (chain->sType) {
- case (WGPUSType_DawnExperimentalImmediateDataLimits): {
- auto* experimentalImmediateDataLimits =
- reinterpret_cast<WGPUDawnExperimentalImmediateDataLimits*>(chain);
- mExperimentalImmediateDataLimits = *experimentalImmediateDataLimits;
- mExperimentalImmediateDataLimits.chain.next = nullptr;
- break;
- }
case (WGPUSType_DawnTexelCopyBufferRowAlignmentLimits): {
auto* texelCopyBufferRowAlignmentLimits =
reinterpret_cast<WGPUDawnTexelCopyBufferRowAlignmentLimits*>(chain);
diff --git a/src/dawn/wire/client/LimitsAndFeatures.h b/src/dawn/wire/client/LimitsAndFeatures.h
index 83d60f4..ac0b7f2 100644
--- a/src/dawn/wire/client/LimitsAndFeatures.h
+++ b/src/dawn/wire/client/LimitsAndFeatures.h
@@ -48,7 +48,6 @@
private:
WGPULimits mLimits;
- WGPUDawnExperimentalImmediateDataLimits mExperimentalImmediateDataLimits;
WGPUDawnTexelCopyBufferRowAlignmentLimits mTexelCopyBufferRowAlignmentLimits;
absl::flat_hash_set<WGPUFeatureName> mFeatures;
};
diff --git a/src/dawn/wire/server/ServerAdapter.cpp b/src/dawn/wire/server/ServerAdapter.cpp
index f306409..7954178 100644
--- a/src/dawn/wire/server/ServerAdapter.cpp
+++ b/src/dawn/wire/server/ServerAdapter.cpp
@@ -117,15 +117,10 @@
// Query and report the adapter limits, including all known extension limits.
WGPULimits limits = {};
- // Chained DawnExperimentalImmediateDataLimits.
- WGPUDawnExperimentalImmediateDataLimits experimentalImmediateDataLimits = {};
- experimentalImmediateDataLimits.chain.sType = WGPUSType_DawnExperimentalImmediateDataLimits;
- limits.nextInChain = &experimentalImmediateDataLimits.chain;
-
// Chained DawnTexelCopyBufferRowAlignmentLimits.
WGPUDawnTexelCopyBufferRowAlignmentLimits texelCopyBufferRowAlignmentLimits = {};
texelCopyBufferRowAlignmentLimits.chain.sType = WGPUSType_DawnTexelCopyBufferRowAlignmentLimits;
- experimentalImmediateDataLimits.chain.next = &texelCopyBufferRowAlignmentLimits.chain;
+ limits.nextInChain = &texelCopyBufferRowAlignmentLimits.chain;
mProcs.deviceGetLimits(device, &limits);
cmd.limits = &limits;
diff --git a/src/dawn/wire/server/ServerInstance.cpp b/src/dawn/wire/server/ServerInstance.cpp
index bfd6c61..a266cea 100644
--- a/src/dawn/wire/server/ServerInstance.cpp
+++ b/src/dawn/wire/server/ServerInstance.cpp
@@ -141,15 +141,10 @@
// Query and report the adapter limits, including all known extension limits.
WGPULimits limits = {};
- // Chained DawnExperimentalImmediateDataLimits.
- WGPUDawnExperimentalImmediateDataLimits experimentalImmediateDataLimits = {};
- experimentalImmediateDataLimits.chain.sType = WGPUSType_DawnExperimentalImmediateDataLimits;
- limits.nextInChain = &experimentalImmediateDataLimits.chain;
-
// Chained DawnTexelCopyBufferRowAlignmentLimits.
WGPUDawnTexelCopyBufferRowAlignmentLimits texelCopyBufferRowAlignmentLimits = {};
texelCopyBufferRowAlignmentLimits.chain.sType = WGPUSType_DawnTexelCopyBufferRowAlignmentLimits;
- experimentalImmediateDataLimits.chain.next = &texelCopyBufferRowAlignmentLimits.chain;
+ limits.nextInChain = &texelCopyBufferRowAlignmentLimits.chain;
mProcs.adapterGetLimits(adapter, &limits);
cmd.limits = &limits;
diff --git a/third_party/emdawnwebgpu/pkg/webgpu/src/library_webgpu.js b/third_party/emdawnwebgpu/pkg/webgpu/src/library_webgpu.js
index 647cd65..260742b 100644
--- a/third_party/emdawnwebgpu/pkg/webgpu/src/library_webgpu.js
+++ b/third_party/emdawnwebgpu/pkg/webgpu/src/library_webgpu.js
@@ -572,6 +572,9 @@
setLimitValueU32('maxComputeWorkgroupSizeY', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeY }}});
setLimitValueU32('maxComputeWorkgroupSizeZ', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeZ }}});
setLimitValueU32('maxComputeWorkgroupsPerDimension', {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupsPerDimension }}});
+
+ // Non-standard. If this is undefined, it will correctly just cast to 0.
+ setLimitValueU32('maxImmediateSize', {{{ C_STRUCTS.WGPULimits.maxImmediateSize }}});
},
// Maps from enum string back to enum number, for callbacks.
@@ -763,10 +766,10 @@
if (limitsPtr) {
{{{ gpu.makeCheckDescriptor('limitsPtr') }}}
var requiredLimits = {};
- function setLimitU32IfDefined(name, limitOffset) {
+ function setLimitU32IfDefined(name, limitOffset, ignoreIfZero=false) {
var ptr = limitsPtr + limitOffset;
var value = {{{ gpu.makeGetU32('ptr', 0) }}};
- if (value != {{{ gpu.LIMIT_U32_UNDEFINED }}}) {
+ if (value != {{{ gpu.LIMIT_U32_UNDEFINED }}} && (!ignoreIfZero || value != 0)) {
requiredLimits[name] = value;
}
}
@@ -810,6 +813,10 @@
setLimitU32IfDefined("maxComputeWorkgroupSizeY", {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeY }}});
setLimitU32IfDefined("maxComputeWorkgroupSizeZ", {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeZ }}});
setLimitU32IfDefined("maxComputeWorkgroupsPerDimension", {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupsPerDimension }}});
+
+ // Non-standard. If this is 0, avoid passing it through so it won't cause an error.
+ setLimitU32IfDefined("maxImmediateSize", {{{ C_STRUCTS.WGPULimits.maxImmediateSize }}}, true);
+
desc["requiredLimits"] = requiredLimits;
}
