Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-18 23:15:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1915827 - update WebGPU CTS to 3d243847001f77fc98159169d654bc2d57e0dbde r=webgpu-reviewers,ErichDonGubler

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D220716
This commit is contained in:
Teodor Tanasoaia 2024-08-30 16:45:14 +00:00
parent 517850c2bb
commit b6e2ffda89
1379 changed files with 44886 additions and 7114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dom/webgpu/tests/cts/checkout/src/common/tools/dev_server.ts
View File

@ -107,8 +107,8 @@ const app = express();
// Send Chrome Origin Trial tokens
app.use((_req, res, next) => {
res.header('Origin-Trial', [
// Token for http://localhost:8080
'AvyDIV+RJoYs8fn3W6kIrBhWw0te0klraoz04mw/nPb8VTus3w5HCdy+vXqsSzomIH745CT6B5j1naHgWqt/tw8AAABJeyJvcmlnaW4iOiJodHRwOi8vbG9jYWxob3N0OjgwODAiLCJmZWF0dXJlIjoiV2ViR1BVIiwiZXhwaXJ5IjoxNjYzNzE4Mzk5fQ==',
// "WebGPU Subgroups Feature" token for http://localhost:8080
'AkMLfHisU+Fsbpi9g6tfKSZF4ngpsmjW4Oai360fUvZE2rgSPZDWSWb8ryrliJX5HR/Rw0yig0ir9el2hrnODwcAAABaeyJvcmlnaW4iOiJodHRwOi8vbG9jYWxob3N0OjgwODAiLCJmZWF0dXJlIjoiV2ViR1BVU3ViZ3JvdXBzRmVhdHVyZXMiLCJleHBpcnkiOjE3Mzk5MjMxOTl9',
]);
next();
});

81
dom/webgpu/tests/cts/checkout/src/webgpu/listing_meta.json
View File

@ -1525,6 +1525,10 @@
"webgpu:shader,execution,expression,call,builtin,step:f32:*": { "subcaseMS": 291.363 },
"webgpu:shader,execution,expression,call,builtin,storageBarrier:barrier:*": { "subcaseMS": 0.801 },
"webgpu:shader,execution,expression,call,builtin,storageBarrier:stage:*": { "subcaseMS": 2.402 },
"webgpu:shader,execution,expression,call,builtin,subgroupAdd:compute,split:*": { "subcaseMS": 2853.671 },
"webgpu:shader,execution,expression,call,builtin,subgroupAdd:data_types:*": { "subcaseMS": 9216.247 },
"webgpu:shader,execution,expression,call,builtin,subgroupAdd:fp_accuracy:*": { "subcaseMS": 9952.350 },
"webgpu:shader,execution,expression,call,builtin,subgroupAdd:fragment:*": { "subcaseMS": 0.229 },
"webgpu:shader,execution,expression,call,builtin,subgroupBallot:compute,split:*": { "subcaseMS": 38.740 },
"webgpu:shader,execution,expression,call,builtin,subgroupBallot:fragment,split:*": { "subcaseMS": 0.331 },
"webgpu:shader,execution,expression,call,builtin,subgroupBallot:fragment:*": { "subcaseMS": 0.059 },
@ -1534,6 +1538,10 @@
"webgpu:shader,execution,expression,call,builtin,subgroupBroadcast:dynamically_uniform_id:*": { "subcaseMS": 0.211 },
"webgpu:shader,execution,expression,call,builtin,subgroupBroadcast:fragment:*": { "subcaseMS": 0.108 },
"webgpu:shader,execution,expression,call,builtin,subgroupBroadcast:workgroup_uniform_load:*": { "subcaseMS": 109.832 },
"webgpu:shader,execution,expression,call,builtin,subgroupMul:compute,split:*": { "subcaseMS": 5034.263 },
"webgpu:shader,execution,expression,call,builtin,subgroupMul:data_types:*": { "subcaseMS": 11861.865 },
"webgpu:shader,execution,expression,call,builtin,subgroupMul:fp_accuracy:*": { "subcaseMS": 35606.717 },
"webgpu:shader,execution,expression,call,builtin,subgroupMul:fragment:*": { "subcaseMS": 0.263 },
"webgpu:shader,execution,expression,call,builtin,tan:abstract_float:*": { "subcaseMS": 17043.428 },
"webgpu:shader,execution,expression,call,builtin,tan:f16:*": { "subcaseMS": 116.157 },
"webgpu:shader,execution,expression,call,builtin,tan:f32:*": { "subcaseMS": 13.532 },
@ -2226,6 +2234,22 @@
"webgpu:shader,validation,expression,call,builtin,pow:invalid_argument:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,pow:must_use:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,pow:values:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:data_type:*": { "subcaseMS": 39.783 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:early_eval:*": { "subcaseMS": 63.825 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:id_constness:*": { "subcaseMS": 15.347 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:id_type:*": { "subcaseMS": 26.268 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:must_use:*": { "subcaseMS": 41.658 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:requires_subgroups:*": { "subcaseMS": 42.565 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:requires_subgroups_f16:*": { "subcaseMS": 44.998 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:return_type:*": { "subcaseMS": 363.607 },
"webgpu:shader,validation,expression,call,builtin,quadBroadcast:stage:*": { "subcaseMS": 3.050 },
"webgpu:shader,validation,expression,call,builtin,quadSwap:data_type:*": { "subcaseMS": 89.379 },
"webgpu:shader,validation,expression,call,builtin,quadSwap:early_eval:*": { "subcaseMS": 108.243 },
"webgpu:shader,validation,expression,call,builtin,quadSwap:must_use:*": { "subcaseMS": 5.557 },
"webgpu:shader,validation,expression,call,builtin,quadSwap:requires_subgroups:*": { "subcaseMS": 113.624 },
"webgpu:shader,validation,expression,call,builtin,quadSwap:requires_subgroups_f16:*": { "subcaseMS": 12.712 },
"webgpu:shader,validation,expression,call,builtin,quadSwap:return_type:*": { "subcaseMS": 1424.551 },
"webgpu:shader,validation,expression,call,builtin,quadSwap:stage:*": { "subcaseMS": 7.664 },
"webgpu:shader,validation,expression,call,builtin,quantizeToF16:args:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,quantizeToF16:must_use:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,quantizeToF16:values:*": { "subcaseMS": 1.000 },
@ -2278,16 +2302,73 @@
"webgpu:shader,validation,expression,call,builtin,step:args:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,step:must_use:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,step:values:*": { "subcaseMS": 1.000 },
"webgpu:shader,validation,expression,call,builtin,subgroupAdd:data_type:*": { "subcaseMS": 32.897 },
"webgpu:shader,validation,expression,call,builtin,subgroupAdd:early_eval:*": { "subcaseMS": 101.800 },
"webgpu:shader,validation,expression,call,builtin,subgroupAdd:invalid_types:*": { "subcaseMS": 95.889 },
"webgpu:shader,validation,expression,call,builtin,subgroupAdd:must_use:*": { "subcaseMS": 62.933 },
"webgpu:shader,validation,expression,call,builtin,subgroupAdd:return_type:*": { "subcaseMS": 363.546 },
"webgpu:shader,validation,expression,call,builtin,subgroupAdd:stage:*": { "subcaseMS": 3.536 },
"webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:data_type:*": { "subcaseMS": 57.943 },
"webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:early_eval:*": { "subcaseMS": 173.714 },
"webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:must_use:*": { "subcaseMS": 4.592 },
"webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:requires_subgroups:*": { "subcaseMS": 73.866 },
"webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:return_type:*": { "subcaseMS": 39.388 },
"webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:stage:*": { "subcaseMS": 6.862 },
"webgpu:shader,validation,expression,call,builtin,subgroupBallot:data_type:*": { "subcaseMS": 115.557 },
"webgpu:shader,validation,expression,call,builtin,subgroupBallot:early_eval:*": { "subcaseMS": 52.992 },
"webgpu:shader,validation,expression,call,builtin,subgroupBallot:must_use:*": { "subcaseMS": 39.441 },
"webgpu:shader,validation,expression,call,builtin,subgroupBallot:requires_subgroups:*": { "subcaseMS": 36.819 },
"webgpu:shader,validation,expression,call,builtin,subgroupBallot:return_type:*": { "subcaseMS": 22.381 },
"webgpu:shader,validation,expression,call,builtin,subgroupBallot:stage:*": { "subcaseMS": 3.712 },
"webgpu:shader,validation,expression,call,builtin,subgroupBitwise:data_type:*": { "subcaseMS": 94.072 },
"webgpu:shader,validation,expression,call,builtin,subgroupBitwise:early_eval:*": { "subcaseMS": 569.598 },
"webgpu:shader,validation,expression,call,builtin,subgroupBitwise:must_use:*": { "subcaseMS": 6.172 },
"webgpu:shader,validation,expression,call,builtin,subgroupBitwise:requires_subgroups:*": { "subcaseMS": 108.478 },
"webgpu:shader,validation,expression,call,builtin,subgroupBitwise:return_type:*": { "subcaseMS": 1430.736 },
"webgpu:shader,validation,expression,call,builtin,subgroupBitwise:stage:*": { "subcaseMS": 11.858 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:data_type:*": { "subcaseMS": 97.991 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:early_eval:*": { "subcaseMS": 1.254 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:id_constness:*": { "subcaseMS": 7.026 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:id_type:*": { "subcaseMS": 24.703 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:must_use:*": { "subcaseMS": 232.030 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:requires_subgroups:*": { "subcaseMS": 47.231 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:requires_subgroups_f16:*": { "subcaseMS": 38.503 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:return_type:*": { "subcaseMS": 496.031 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:stage:*": { "subcaseMS": 3.715 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:data_type:*": { "subcaseMS": 32.168 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:early_eval:*": { "subcaseMS": 57.922 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:must_use:*": { "subcaseMS": 36.296 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:requires_subgroups:*": { "subcaseMS": 42.522 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:requires_subgroups_f16:*": { "subcaseMS": 47.111 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:return_type:*": { "subcaseMS": 402.558 },
"webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:stage:*": { "subcaseMS": 2.869 },
"webgpu:shader,validation,expression,call,builtin,subgroupElect:data_type:*": { "subcaseMS": 72.441 },
"webgpu:shader,validation,expression,call,builtin,subgroupElect:early_eval:*": { "subcaseMS": 56.115 },
"webgpu:shader,validation,expression,call,builtin,subgroupElect:must_use:*": { "subcaseMS": 32.820 },
"webgpu:shader,validation,expression,call,builtin,subgroupElect:requires_subgroups:*": { "subcaseMS": 35.595 },
"webgpu:shader,validation,expression,call,builtin,subgroupElect:return_type:*": { "subcaseMS": 22.712 },
"webgpu:shader,validation,expression,call,builtin,subgroupElect:stage:*": { "subcaseMS": 3.790 },
"webgpu:shader,validation,expression,call,builtin,subgroupMinMax:data_type:*": { "subcaseMS": 64.143 },
"webgpu:shader,validation,expression,call,builtin,subgroupMinMax:early_eval:*": { "subcaseMS": 551.671 },
"webgpu:shader,validation,expression,call,builtin,subgroupMinMax:must_use:*": { "subcaseMS": 4.403 },
"webgpu:shader,validation,expression,call,builtin,subgroupMinMax:requires_subgroups:*": { "subcaseMS": 87.208 },
"webgpu:shader,validation,expression,call,builtin,subgroupMinMax:requires_subgroups_f16:*": { "subcaseMS": 25.190 },
"webgpu:shader,validation,expression,call,builtin,subgroupMinMax:return_type:*": { "subcaseMS": 911.454 },
"webgpu:shader,validation,expression,call,builtin,subgroupMinMax:stage:*": { "subcaseMS": 6.395 },
"webgpu:shader,validation,expression,call,builtin,subgroupMul:data_type:*": { "subcaseMS": 45.396 },
"webgpu:shader,validation,expression,call,builtin,subgroupMul:early_eval:*": { "subcaseMS": 56.571 },
"webgpu:shader,validation,expression,call,builtin,subgroupMul:invalid_types:*": { "subcaseMS": 91.040 },
"webgpu:shader,validation,expression,call,builtin,subgroupMul:must_use:*": { "subcaseMS": 39.041 },
"webgpu:shader,validation,expression,call,builtin,subgroupMul:return_type:*": { "subcaseMS": 549.172 },
"webgpu:shader,validation,expression,call,builtin,subgroupMul:stage:*": { "subcaseMS": 4.489 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:data_type:*": { "subcaseMS": 115.093 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:early_eval:*": { "subcaseMS": 110.489 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:must_use:*": { "subcaseMS": 7.628 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:param2_type:*": { "subcaseMS": 88.305 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:requires_subgroups:*": { "subcaseMS": 102.779 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:requires_subgroups_f16:*": { "subcaseMS": 13.121 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:return_type:*": { "subcaseMS": 1930.309 },
"webgpu:shader,validation,expression,call,builtin,subgroupShuffle:stage:*": { "subcaseMS": 9.527 },
"webgpu:shader,validation,expression,call,builtin,tan:args:*": { "subcaseMS": 43.560 },
"webgpu:shader,validation,expression,call,builtin,tan:must_use:*": { "subcaseMS": 5.401 },
"webgpu:shader,validation,expression,call,builtin,tan:values:*": { "subcaseMS": 0.350 },

356
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/subgroupAdd.spec.ts Normal file
View File

@ -0,0 +1,356 @@
export const description = `
Execution tests for subgroupAdd and subgroupExclusiveAdd
Note: There is a lack of portability for non-uniform execution so these tests
restrict themselves to uniform control flow.
Note: There is no guaranteed mapping between subgroup_invocation_id and
local_invocation_index. Tests should avoid assuming there is.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import { iterRange } from '../../../../../../common/util/util.js';
import { GPUTest } from '../../../../../gpu_test.js';
import {
kConcreteNumericScalarsAndVectors,
Type,
VectorType,
numberToFloatBits,
floatBitsToNumber,
kFloat32Format,
kFloat16Format,
scalarTypeOf,
} from '../../../../../util/conversion.js';
import { FP } from '../../../../../util/floating_point.js';
import {
kNumCases,
kStride,
kWGSizes,
kPredicateCases,
runAccuracyTest,
runComputeTest,
} from './subgroup_util.js';
export const g = makeTestGroup(GPUTest);
const kIdentity = 0;
const kDataTypes = objectsToRecord(kConcreteNumericScalarsAndVectors);
const kOperations = ['subgroupAdd', 'subgroupExclusiveAdd'] as const;
g.test('fp_accuracy')
.desc(
`Tests the accuracy of floating-point addition.
The order of operations is implementation defined, most threads are filled with
the identity value and two receive random values.
Subgroup sizes are not known ahead of time so some cases may not perform any
interesting operations. The test biases towards checking subgroup sizes under 64.
These tests only check two values in order to reuse more of the existing infrastructure
and limit the number of permutations needed to calculate the final result.`
)
.params(u =>
u
.combine('case', [...iterRange(kNumCases, x => x)])
.combine('type', ['f32', 'f16'] as const)
.combine('wgSize', [
[kStride, 1, 1],
[kStride / 2, 2, 1],
] as const)
)
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['subgroups' as GPUFeatureName];
if (t.params.type === 'f16') {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(async t => {
await runAccuracyTest(
t,
t.params.case,
[t.params.wgSize[0], t.params.wgSize[1], t.params.wgSize[2]],
'subgroupAdd',
t.params.type,
kIdentity,
t.params.type === 'f16' ? FP.f16.additionInterval : FP.f32.additionInterval
);
});
/**
* Checks subgroup additions
*
* Expected results:
* - subgroupAdd: each invocation should have result equal to real subgroup size
* - subgroupExclusiveAdd: each invocation should have result equal to its subgroup invocation id
* @param metadata An array containing actual subgroup size per invocation followed by
* subgroup invocation id per invocation
* @param output An array of additions
* @param type The data type
* @param operation Type of addition
*/
function checkAddition(
metadata: Uint32Array,
output: Uint32Array,
type: Type,
operation: 'subgroupAdd' | 'subgroupExclusiveAdd'
): undefined | Error {
let numEles = 1;
if (type instanceof VectorType) {
numEles = type.width;
}
const scalarTy = scalarTypeOf(type);
const expectedOffset = operation === 'subgroupAdd' ? 0 : metadata.length / 2;
for (let i = 0; i < metadata.length / 2; i++) {
const expected = metadata[i + expectedOffset];
for (let j = 0; j < numEles; j++) {
let idx = i * numEles + j;
const isOdd = idx & 0x1;
if (scalarTy === Type.f16) {
idx = Math.floor(idx / 2);
}
let val = output[idx];
if (scalarTy === Type.f32) {
val = floatBitsToNumber(val, kFloat32Format);
} else if (scalarTy === Type.f16) {
if (isOdd) {
val = val >> 16;
}
val = floatBitsToNumber(val & 0xffff, kFloat16Format);
}
if (expected !== val) {
return new Error(`Invocation ${i}, component ${j}: incorrect result
- expected: ${expected}
- got: ${val}`);
}
}
}
return undefined;
}
g.test('data_types')
.desc(
`Tests subgroup addition for valid data types
Tests a simple addition of all 1 values.
Reductions expect result to be equal to actual subgroup size.
Exclusice scans expect result to be equal subgroup invocation id.
TODO: support vec3 types.
`
)
.params(u =>
u
.combine('type', keysOf(kDataTypes))
.filter(t => {
const type = kDataTypes[t.type];
if (type instanceof VectorType) {
return type.width !== 3;
}
return true;
})
.beginSubcases()
.combine('wgSize', kWGSizes)
.combine('operation', kOperations)
)
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['subgroups' as GPUFeatureName];
const type = kDataTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(async t => {
const type = kDataTypes[t.params.type];
let numEles = 1;
if (type instanceof VectorType) {
numEles = type.width;
}
const scalarType = scalarTypeOf(type);
let enables = 'enable subgroups;\n';
if (type.requiresF16()) {
enables += 'enable f16;\nenable subgroups_f16;\n';
}
const wgThreads = t.params.wgSize[0] * t.params.wgSize[1] * t.params.wgSize[2];
const wgsl = `
${enables}
@group(0) @binding(0)
var<storage> inputs : array<${type.toString()}>;
@group(0) @binding(1)
var<storage, read_write> outputs : array<${type.toString()}>;
struct Metadata {
subgroup_size : array<u32, ${wgThreads}>,
subgroup_invocation_id : array<u32, ${wgThreads}>,
}
@group(0) @binding(2)
var<storage, read_write> metadata : Metadata;
@compute @workgroup_size(${t.params.wgSize[0]}, ${t.params.wgSize[1]}, ${t.params.wgSize[2]})
fn main(
@builtin(local_invocation_index) lid : u32,
@builtin(subgroup_invocation_id) id : u32,
) {
// Record the actual subgroup size for this invocation.
// Note: subgroup_size builtin is always a power-of-2 and might be larger
// if the subgroup is not full.
let ballot = subgroupBallot(true);
var size = countOneBits(ballot.x);
size += countOneBits(ballot.y);
size += countOneBits(ballot.z);
size += countOneBits(ballot.w);
metadata.subgroup_size[lid] = size;
// Record subgroup invocation id for this invocation.
metadata.subgroup_invocation_id[lid] = id;
outputs[lid] = ${t.params.operation}(inputs[lid]);
}`;
let fillValue = 1;
let numUints = wgThreads * numEles;
if (scalarType === Type.f32) {
fillValue = numberToFloatBits(1, kFloat32Format);
} else if (scalarType === Type.f16) {
const f16 = numberToFloatBits(1, kFloat16Format);
fillValue = f16 | (f16 << 16);
numUints = Math.ceil(numUints / 2);
}
await runComputeTest(
t,
wgsl,
[t.params.wgSize[0], t.params.wgSize[1], t.params.wgSize[2]],
numUints,
new Uint32Array([...iterRange(numUints, x => fillValue)]),
(metadata: Uint32Array, output: Uint32Array) => {
return checkAddition(metadata, output, type, t.params.operation);
}
);
});
g.test('fragment').unimplemented();
/**
* Performs correctness checking for predicated additions
*
* Assumes the shader performs a predicated subgroup addition with the
* subgroup_invocation_id as the data.
*
* @param metadata An array containing subgroup sizes and subgroup invocation ids
* @param output An array containing the output results
* @param operation The type of addition
* @param filter A functor that mirrors the predication in the shader
*/
function checkPredicatedAddition(
metadata: Uint32Array,
output: Uint32Array,
operation: 'subgroupAdd' | 'subgroupExclusiveAdd',
filter: (id: number, size: number) => boolean
): Error | undefined {
for (let i = 0; i < output.length; i++) {
const size = metadata[i];
const id = metadata[output.length + i];
let expected = 0;
if (filter(id, size)) {
const bound = operation === 'subgroupAdd' ? size : id;
for (let j = 0; j < bound; j++) {
if (filter(j, size)) {
expected += j;
}
}
} else {
expected = 999;
}
if (expected !== output[i]) {
return new Error(`Invocation ${i}: incorrect result
- expected: ${expected}
- got: ${output[i]}`);
}
}
return undefined;
}
g.test('compute,split')
.desc('Tests that only active invocations contribute to the operation')
.params(u =>
u
.combine('case', keysOf(kPredicateCases))
.beginSubcases()
.combine('operation', kOperations)
.combine('wgSize', kWGSizes)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(async t => {
const testcase = kPredicateCases[t.params.case];
const outputUintsPerElement = 1;
const inputData = new Uint32Array([0]); // no input data
const wgThreads = t.params.wgSize[0] * t.params.wgSize[1] * t.params.wgSize[2];
const wgsl = `
enable subgroups;
@group(0) @binding(0)
var<storage> input : array<u32>;
@group(0) @binding(1)
var<storage, read_write> outputs : array<u32>;
struct Metadata {
subgroup_size : array<u32, ${wgThreads}>,
subgroup_invocation_id : array<u32, ${wgThreads}>,
}
@group(0) @binding(2)
var<storage, read_write> metadata : Metadata;
@compute @workgroup_size(${t.params.wgSize[0]}, ${t.params.wgSize[1]}, ${t.params.wgSize[2]})
fn main(
@builtin(local_invocation_index) lid : u32,
@builtin(subgroup_invocation_id) id : u32,
) {
_ = input[0];
// Record the actual subgroup size for this invocation.
// Note: subgroup_size builtin is always a power-of-2 and might be larger
// if the subgroup is not full.
let ballot = subgroupBallot(true);
var subgroupSize = countOneBits(ballot.x);
subgroupSize += countOneBits(ballot.y);
subgroupSize += countOneBits(ballot.z);
subgroupSize += countOneBits(ballot.w);
metadata.subgroup_size[lid] = subgroupSize;
// Record subgroup invocation id for this invocation.
metadata.subgroup_invocation_id[lid] = id;
if ${testcase.cond} {
outputs[lid] = ${t.params.operation}(id);
} else {
return;
}
}`;
await runComputeTest(
t,
wgsl,
[t.params.wgSize[0], t.params.wgSize[1], t.params.wgSize[2]],
outputUintsPerElement,
inputData,
(metadata: Uint32Array, output: Uint32Array) => {
return checkPredicatedAddition(metadata, output, t.params.operation, testcase.filter);
}
);
});

375
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/subgroupMul.spec.ts Normal file
View File

@ -0,0 +1,375 @@
export const description = `
Execution tests for subgroupMul and subgroupExclusiveMul
Note: There is a lack of portability for non-uniform execution so these tests
restrict themselves to uniform control flow.
Note: There is no guaranteed mapping between subgroup_invocation_id and
local_invocation_index. Tests should avoid assuming there is.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import { iterRange } from '../../../../../../common/util/util.js';
import { GPUTest } from '../../../../../gpu_test.js';
import {
kConcreteNumericScalarsAndVectors,
Type,
VectorType,
numberToFloatBits,
floatBitsToNumber,
kFloat32Format,
kFloat16Format,
scalarTypeOf,
} from '../../../../../util/conversion.js';
import { FP } from '../../../../../util/floating_point.js';
import {
kNumCases,
kStride,
kWGSizes,
kPredicateCases,
runAccuracyTest,
runComputeTest,
} from './subgroup_util.js';
export const g = makeTestGroup(GPUTest);
const kIdentity = 1;
const kDataTypes = objectsToRecord(kConcreteNumericScalarsAndVectors);
const kOperations = ['subgroupMul', 'subgroupExclusiveMul'] as const;
g.test('fp_accuracy')
.desc(
`Tests the accuracy of floating-point multiplication.
The order of operations is implementation defined, most threads are filled with
the identity value and two receive random values.
Subgroup sizes are not known ahead of time so some cases may not perform any
interesting operations. The test biases towards checking subgroup sizes under 64.
These tests only check two values in order to reuse more of the existing infrastructure
and limit the number of permutations needed to calculate the final result.`
)
.params(u =>
u
.combine('case', [...iterRange(kNumCases, x => x)])
.combine('type', ['f32', 'f16'] as const)
.combine('wgSize', [
[kStride, 1, 1],
[kStride / 2, 2, 1],
] as const)
)
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['subgroups' as GPUFeatureName];
if (t.params.type === 'f16') {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(async t => {
await runAccuracyTest(
t,
t.params.case,
[t.params.wgSize[0], t.params.wgSize[1], t.params.wgSize[2]],
'subgroupMul',
t.params.type,
kIdentity,
t.params.type === 'f16' ? FP.f16.multiplicationInterval : FP.f32.multiplicationInterval
);
});
/**
* Checks subgroup multiplications.
*
* Expected results:
* - subgroupMul: each invocation should have result equal to 2 to the real subgroup size
* - subgroupExclusiveMul: each invocation should have result equal to 2 to its subgroup invocation id
* @param metadata An array containing actual subgroup size per invocation followed by
* subgroup invocation id per invocation
* @param output An array of multiplications
* @param type The data type
* @param operation Type of multiplication
*/
function checkMultiplication(
metadata: Uint32Array,
output: Uint32Array,
type: Type,
operation: 'subgroupMul' | 'subgroupExclusiveMul'
): undefined | Error {
let numEles = 1;
if (type instanceof VectorType) {
numEles = type.width;
}
const scalarTy = scalarTypeOf(type);
const expectedOffset = operation === 'subgroupMul' ? 0 : metadata.length / 2;
for (let i = 0; i < metadata.length / 2; i++) {
const expected = Math.pow(2, metadata[i + expectedOffset]);
for (let j = 0; j < numEles; j++) {
let idx = i * numEles + j;
const isOdd = idx & 0x1;
if (scalarTy === Type.f16) {
idx = Math.floor(idx / 2);
}
let val = output[idx];
if (scalarTy === Type.f32) {
val = floatBitsToNumber(val, kFloat32Format);
} else if (scalarTy === Type.f16) {
if (isOdd) {
val = val >> 16;
}
val = floatBitsToNumber(val & 0xffff, kFloat16Format);
}
if (expected !== val) {
return new Error(`Invocation ${i}, component ${j}: incorrect result
- expected: ${expected}
- got: ${val}`);
}
}
}
return undefined;
}
g.test('data_types')
.desc(
`Tests subgroup multiplication for valid data types
Tests a simple multiplication of all 2 values.
Reductions expect result to be equal to actual subgroup size.
Exclusice scans expect result to be equal subgroup invocation id.
TODO: support vec3 types.
`
)
.params(u =>
u
.combine('type', keysOf(kDataTypes))
.filter(t => {
const type = kDataTypes[t.type];
if (type instanceof VectorType) {
return type.width !== 3;
}
return true;
})
.beginSubcases()
// Workgroup sizes are kept < 16 to avoid overflows.
// Other tests cover that the full subgroup will contribute.
.combine('wgSize', [
[4, 1, 1],
[8, 1, 1],
[1, 4, 1],
[1, 8, 1],
[1, 1, 4],
[1, 1, 8],
[2, 2, 2],
[4, 2, 1],
[4, 1, 2],
[2, 4, 1],
[2, 1, 4],
[1, 4, 2],
[1, 2, 4],
[3, 3, 1],
[3, 1, 3],
[1, 3, 3],
] as const)
.combine('operation', kOperations)
)
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['subgroups' as GPUFeatureName];
const type = kDataTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(async t => {
const type = kDataTypes[t.params.type];
let numEles = 1;
if (type instanceof VectorType) {
numEles = type.width;
}
const scalarType = scalarTypeOf(type);
let enables = 'enable subgroups;\n';
if (type.requiresF16()) {
enables += 'enable f16;\nenable subgroups_f16;\n';
}
const wgThreads = t.params.wgSize[0] * t.params.wgSize[1] * t.params.wgSize[2];
const wgsl = `
${enables}
@group(0) @binding(0)
var<storage> inputs : array<${type.toString()}>;
@group(0) @binding(1)
var<storage, read_write> outputs : array<${type.toString()}>;
struct Metadata {
subgroup_size : array<u32, ${wgThreads}>,
subgroup_invocation_id : array<u32, ${wgThreads}>,
}
@group(0) @binding(2)
var<storage, read_write> metadata : Metadata;
@compute @workgroup_size(${t.params.wgSize[0]}, ${t.params.wgSize[1]}, ${t.params.wgSize[2]})
fn main(
@builtin(local_invocation_index) lid : u32,
@builtin(subgroup_invocation_id) id : u32,
) {
// Record the actual subgroup size for this invocation.
// Note: subgroup_size builtin is always a power-of-2 and might be larger
// if the subgroup is not full.
let ballot = subgroupBallot(true);
var size = countOneBits(ballot.x);
size += countOneBits(ballot.y);
size += countOneBits(ballot.z);
size += countOneBits(ballot.w);
metadata.subgroup_size[lid] = size;
// Record subgroup invocation id for this invocation.
metadata.subgroup_invocation_id[lid] = id;
outputs[lid] = ${t.params.operation}(inputs[lid]);
}`;
let fillValue = 2;
let numUints = wgThreads * numEles;
if (scalarType === Type.f32) {
fillValue = numberToFloatBits(fillValue, kFloat32Format);
} else if (scalarType === Type.f16) {
const f16 = numberToFloatBits(fillValue, kFloat16Format);
fillValue = f16 | (f16 << 16);
numUints = Math.ceil(numUints / 2);
}
await runComputeTest(
t,
wgsl,
[t.params.wgSize[0], t.params.wgSize[1], t.params.wgSize[2]],
numUints,
new Uint32Array([...iterRange(numUints, x => fillValue)]),
(metadata: Uint32Array, output: Uint32Array) => {
return checkMultiplication(metadata, output, type, t.params.operation);
}
);
});
g.test('fragment').unimplemented();
/**
* Performs correctness checking for predicated multiplications
*
* Assumes the shader performs a predicated subgroup multiplication with the
* subgroup_invocation_id as the data.
*
* @param metadata An array containing subgroup sizes and subgroup invocation ids
* @param output An array containing the output results
* @param operation The type of multiplication
* @param filter A functor that mirrors the predication in the shader
*/
function checkPredicatedMultiplication(
metadata: Uint32Array,
output: Uint32Array,
operation: 'subgroupMul' | 'subgroupExclusiveMul',
filter: (id: number, size: number) => boolean
): Error | undefined {
for (let i = 0; i < output.length; i++) {
const size = metadata[i];
const id = metadata[output.length + i];
let expected = 1;
if (filter(id, size)) {
const bound = operation === 'subgroupMul' ? size : id;
for (let j = 0; j < bound; j++) {
if (filter(j, size)) {
expected *= (j % 4) + 1;
}
}
} else {
expected = 999;
}
if (expected !== output[i]) {
return new Error(`Invocation ${i}: incorrect result
- expected: ${expected}
- got: ${output[i]}`);
}
}
return undefined;
}
g.test('compute,split')
.desc('Tests that only active invocations contribute to the operation')
.params(u =>
u
.combine('case', keysOf(kPredicateCases))
.beginSubcases()
.combine('operation', kOperations)
.combine('wgSize', kWGSizes)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(async t => {
const testcase = kPredicateCases[t.params.case];
const outputUintsPerElement = 1;
const inputData = new Uint32Array([0]); // no input data
const wgThreads = t.params.wgSize[0] * t.params.wgSize[1] * t.params.wgSize[2];
const wgsl = `
enable subgroups;
@group(0) @binding(0)
var<storage> input : array<u32>;
@group(0) @binding(1)
var<storage, read_write> outputs : array<u32>;
struct Metadata {
subgroup_size : array<u32, ${wgThreads}>,
subgroup_invocation_id : array<u32, ${wgThreads}>,
}
@group(0) @binding(2)
var<storage, read_write> metadata : Metadata;
@compute @workgroup_size(${t.params.wgSize[0]}, ${t.params.wgSize[1]}, ${t.params.wgSize[2]})
fn main(
@builtin(local_invocation_index) lid : u32,
@builtin(subgroup_invocation_id) id : u32,
) {
_ = input[0];
// Record the actual subgroup size for this invocation.
// Note: subgroup_size builtin is always a power-of-2 and might be larger
// if the subgroup is not full.
let ballot = subgroupBallot(true);
var subgroupSize = countOneBits(ballot.x);
subgroupSize += countOneBits(ballot.y);
subgroupSize += countOneBits(ballot.z);
subgroupSize += countOneBits(ballot.w);
metadata.subgroup_size[lid] = subgroupSize;
// Record subgroup invocation id for this invocation.
metadata.subgroup_invocation_id[lid] = id;
if ${testcase.cond} {
outputs[lid] = ${t.params.operation}((id % 4) + 1);
} else {
return;
}
}`;
await runComputeTest(
t,
wgsl,
[t.params.wgSize[0], t.params.wgSize[1], t.params.wgSize[2]],
outputUintsPerElement,
inputData,
(metadata: Uint32Array, output: Uint32Array) => {
return checkPredicatedMultiplication(metadata, output, t.params.operation, testcase.filter);
}
);
});

417
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/subgroup_util.ts Normal file
View File

@ -0,0 +1,417 @@
import { assert, iterRange } from '../../../../../../common/util/util.js';
import { Float16Array } from '../../../../../../external/petamoriken/float16/float16.js';
import { GPUTest } from '../../../../../gpu_test.js';
import { FPInterval } from '../../../../../util/floating_point.js';
import { sparseScalarF16Range, sparseScalarF32Range } from '../../../../../util/math.js';
import { PRNG } from '../../../../../util/prng.js';
export const kNumCases = 1000;
export const kStride = 128;
export const kWGSizes = [
[4, 1, 1],
[8, 1, 1],
[16, 1, 1],
[32, 1, 1],
[64, 1, 1],
[128, 1, 1],
[256, 1, 1],
[1, 4, 1],
[1, 8, 1],
[1, 16, 1],
[1, 32, 1],
[1, 64, 1],
[1, 128, 1],
[1, 256, 1],
[1, 1, 4],
[1, 1, 8],
[1, 1, 16],
[1, 1, 32],
[1, 1, 64],
[3, 3, 3],
[4, 4, 4],
[16, 16, 1],
[16, 1, 16],
[1, 16, 16],
[15, 3, 3],
[3, 15, 3],
[3, 3, 15],
] as const;
export const kPredicateCases = {
every_even: {
cond: `id % 2 == 0`,
filter: (id: number, size: number) => {
return id % 2 === 0;
},
},
every_odd: {
cond: `id % 2 == 1`,
filter: (id: number, size: number) => {
return id % 2 === 1;
},
},
lower_half: {
cond: `id < subgroupSize / 2`,
filter: (id: number, size: number) => {
return id < Math.floor(size / 2);
},
},
upper_half: {
cond: `id >= subgroupSize / 2`,
filter: (id: number, size: number) => {
return id >= Math.floor(size / 2);
},
},
first_two: {
cond: `id == 0 || id == 1`,
filter: (id: number) => {
return id === 0 || id === 1;
},
},
};
/**
* Check the accuracy of the reduction operation.
*
* @param metadata An array containing subgroup ids for each invocation
* @param output An array containing the results of the reduction for each invocation
* @param indices An array of two values containing the indices of the interesting values in the input
* @param values An array of two values containing the interesting values in the input
* @param identity The identity for the operation
* @param intervalGen A functor to generate an appropriate FPInterval for a binary operation
*/
function checkAccuracy(
metadata: Uint32Array,
output: Float32Array | Float16Array,
indices: number[],
values: number[],
identity: number,
intervalGen: (x: number | FPInterval, y: number | FPInterval) => FPInterval
): undefined | Error {
const subgroupIdIdx1 = metadata[indices[0]];
const subgroupIdIdx2 = metadata[indices[1]];
for (let i = 0; i < output.length; i++) {
const subgroupId = metadata[i];
const v1 = subgroupId === subgroupIdIdx1 ? values[0] : identity;
const v2 = subgroupId === subgroupIdIdx2 ? values[1] : identity;
const interval = intervalGen(v1, v2);
if (!interval.contains(output[i])) {
return new Error(`Invocation ${i}, subgroup id ${subgroupId}: incorrect result
- interval: ${interval.toString()}
- output: ${output[i]}`);
}
}
return undefined;
}
/**
* Run a floating-point accuracy subgroup test.
*
* @param t The base test
* @param seed A seed for the PRNG
* @param wgSize An array for the workgroup size
* @param operation The subgroup operation
* @param type The type (f16 or f32)
* @param identity The identity for the operation
* @param intervalGen A functor to generate an appropriate FPInterval for a binary operation
*/
export async function runAccuracyTest(
t: GPUTest,
seed: number,
wgSize: number[],
operation: string,
type: 'f16' | 'f32',
identity: number,
intervalGen: (x: number | FPInterval, y: number | FPInterval) => FPInterval
) {
assert(seed < kNumCases);
const prng = new PRNG(seed);
// Compatibility mode has lower workgroup limits.
const wgThreads = wgSize[0] * wgSize[1] * wgSize[2];
const {
maxComputeInvocationsPerWorkgroup,
maxComputeWorkgroupSizeX,
maxComputeWorkgroupSizeY,
maxComputeWorkgroupSizeZ,
} = t.device.limits;
t.skipIf(
maxComputeInvocationsPerWorkgroup < wgThreads ||
maxComputeWorkgroupSizeX < wgSize[0] ||
maxComputeWorkgroupSizeY < wgSize[1] ||
maxComputeWorkgroupSizeZ < wgSize[2],
'Workgroup size too large'
);
// Bias half the cases to lower indices since most subgroup sizes are <= 64.
let indexLimit = kStride;
if (seed < kNumCases / 4) {
indexLimit = 16;
} else if (seed < kNumCases / 2) {
indexLimit = 64;
}
// Ensure two distinct indices are picked.
const idx1 = prng.uniformInt(indexLimit);
let idx2 = prng.uniformInt(indexLimit - 1);
if (idx1 === idx2) {
idx2++;
}
assert(idx2 < indexLimit);
// Select two random values.
const range = type === 'f16' ? sparseScalarF16Range() : sparseScalarF32Range();
const numVals = range.length;
const val1 = range[prng.uniformInt(numVals)];
const val2 = range[prng.uniformInt(numVals)];
const extraEnables = type === 'f16' ? `enable f16;\nenable subgroups_f16;` : ``;
const wgsl = `
enable subgroups;
${extraEnables}
@group(0) @binding(0)
var<storage> inputs : array<${type}>;
@group(0) @binding(1)
var<storage, read_write> outputs : array<${type}>;
struct Metadata {
subgroup_id : array<u32, ${kStride}>,
}
@group(0) @binding(2)
var<storage, read_write> metadata : Metadata;
@compute @workgroup_size(${wgSize[0]}, ${wgSize[1]}, ${wgSize[2]})
fn main(
@builtin(local_invocation_index) lid : u32,
) {
metadata.subgroup_id[lid] = subgroupBroadcast(lid, 0);
outputs[lid] = ${operation}(inputs[lid]);
}`;
const inputData =
type === 'f16'
? new Float16Array([
...iterRange(kStride, x => {
if (x === idx1) return val1;
if (x === idx2) return val2;
return identity;
}),
])
: new Float32Array([
...iterRange(kStride, x => {
if (x === idx1) return val1;
if (x === idx2) return val2;
return identity;
}),
]);
const inputBuffer = t.makeBufferWithContents(
inputData,
GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE
);
t.trackForCleanup(inputBuffer);
const outputBuffer = t.makeBufferWithContents(
new Float32Array([...iterRange(kStride, x => 0)]),
GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE
);
t.trackForCleanup(outputBuffer);
const numMetadata = kStride;
const metadataBuffer = t.makeBufferWithContents(
new Uint32Array([...iterRange(numMetadata, x => 0)]),
GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE
);
const pipeline = t.device.createComputePipeline({
layout: 'auto',
compute: {
module: t.device.createShaderModule({
code: wgsl,
}),
entryPoint: 'main',
},
});
const bg = t.device.createBindGroup({
layout: pipeline.getBindGroupLayout(0),
entries: [
{
binding: 0,
resource: {
buffer: inputBuffer,
},
},
{
binding: 1,
resource: {
buffer: outputBuffer,
},
},
{
binding: 2,
resource: {
buffer: metadataBuffer,
},
},
],
});
const encoder = t.device.createCommandEncoder();
const pass = encoder.beginComputePass();
pass.setPipeline(pipeline);
pass.setBindGroup(0, bg);
pass.dispatchWorkgroups(1, 1, 1);
pass.end();
t.queue.submit([encoder.finish()]);
const metadataReadback = await t.readGPUBufferRangeTyped(metadataBuffer, {
srcByteOffset: 0,
type: Uint32Array,
typedLength: numMetadata,
method: 'copy',
});
const metadata = metadataReadback.data;
let output: Float16Array | Float32Array;
if (type === 'f16') {
const outputReadback = await t.readGPUBufferRangeTyped(outputBuffer, {
srcByteOffset: 0,
type: Float16Array,
typedLength: kStride,
method: 'copy',
});
output = outputReadback.data;
} else {
const outputReadback = await t.readGPUBufferRangeTyped(outputBuffer, {
srcByteOffset: 0,
type: Float32Array,
typedLength: kStride,
method: 'copy',
});
output = outputReadback.data;
}
t.expectOK(checkAccuracy(metadata, output, [idx1, idx2], [val1, val2], identity, intervalGen));
}
/**
* Runs compute shader subgroup test
*
* The test makes the following assumptions:
* * group(0) binding(0) is a storage buffer for input data
* * group(0) binding(1) is an output storage buffer for outputUintsPerElement * wgSize uints
* * group(0) binding(2) is an output storage buffer for 2 * wgSize uints
*
* @param t The base test
* @param wgsl The shader code
* @param outputUintsPerElement number of uints output per invocation
* @param inputData the input data
* @param checkFunction a functor that takes the output storage buffer data to check result validity
*/
export async function runComputeTest(
t: GPUTest,
wgsl: string,
wgSize: number[],
outputUintsPerElement: number,
inputData: Uint32Array,
checkFunction: (metadata: Uint32Array, output: Uint32Array) => Error | undefined
) {
// Compatibility mode has lower workgroup limits.
const wgThreads = wgSize[0] * wgSize[1] * wgSize[2];
const {
maxComputeInvocationsPerWorkgroup,
maxComputeWorkgroupSizeX,
maxComputeWorkgroupSizeY,
maxComputeWorkgroupSizeZ,
} = t.device.limits;
t.skipIf(
maxComputeInvocationsPerWorkgroup < wgThreads ||
maxComputeWorkgroupSizeX < wgSize[0] ||
maxComputeWorkgroupSizeY < wgSize[1] ||
maxComputeWorkgroupSizeZ < wgSize[2],
'Workgroup size too large'
);
const inputBuffer = t.makeBufferWithContents(
inputData,
GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE
);
t.trackForCleanup(inputBuffer);
const outputUints = outputUintsPerElement * wgThreads;
const outputBuffer = t.makeBufferWithContents(
new Uint32Array([...iterRange(outputUints, x => 999)]),
GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE
);
t.trackForCleanup(outputBuffer);
const numMetadata = 2 * wgThreads;
const metadataBuffer = t.makeBufferWithContents(
new Uint32Array([...iterRange(numMetadata, x => 999)]),
GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE
);
const pipeline = t.device.createComputePipeline({
layout: 'auto',
compute: {
module: t.device.createShaderModule({
code: wgsl,
}),
},
});
const bg = t.device.createBindGroup({
layout: pipeline.getBindGroupLayout(0),
entries: [
{
binding: 0,
resource: {
buffer: inputBuffer,
},
},
{
binding: 1,
resource: {
buffer: outputBuffer,
},
},
{
binding: 2,
resource: {
buffer: metadataBuffer,
},
},
],
});
const encoder = t.device.createCommandEncoder();
const pass = encoder.beginComputePass();
pass.setPipeline(pipeline);
pass.setBindGroup(0, bg);
pass.dispatchWorkgroups(1, 1, 1);
pass.end();
t.queue.submit([encoder.finish()]);
const metadataReadback = await t.readGPUBufferRangeTyped(metadataBuffer, {
srcByteOffset: 0,
type: Uint32Array,
typedLength: numMetadata,
method: 'copy',
});
const metadata = metadataReadback.data;
const outputReadback = await t.readGPUBufferRangeTyped(outputBuffer, {
srcByteOffset: 0,
type: Uint32Array,
typedLength: outputUints,
method: 'copy',
});
const output = outputReadback.data;
t.expectOK(checkFunction(metadata, output));
}

4
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/textureGather.spec.ts
View File

@ -119,6 +119,7 @@ Parameters:
const calls: TextureCall<vec2>[] = generateTextureBuiltinInputs2D(50, {
method: samplePoints,
textureBuiltin: 'textureGather',
sampler,
descriptor,
offset,
@ -304,6 +305,7 @@ Parameters:
const calls: TextureCall<vec2>[] = generateTextureBuiltinInputs2D(50, {
method: samplePoints,
textureBuiltin: 'textureGather',
sampler,
descriptor,
arrayIndex: { num: texture.depthOrArrayLayers, type: A },
@ -486,6 +488,7 @@ Parameters:
const calls: TextureCall<vec2>[] = generateTextureBuiltinInputs2D(50, {
method: samplePoints,
textureBuiltin: 'textureGather',
sampler,
descriptor,
offset,
@ -654,6 +657,7 @@ Parameters:
const calls: TextureCall<vec2>[] = generateTextureBuiltinInputs2D(50, {
method: samplePoints,
textureBuiltin: 'textureGather',
sampler,
descriptor,
arrayIndex: { num: texture.depthOrArrayLayers, type: A },

2
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/textureGatherCompare.spec.ts
View File

@ -107,6 +107,7 @@ Parameters:
const calls: TextureCall<vec2>[] = generateTextureBuiltinInputs2D(50, {
method: samplePoints,
textureBuiltin: 'textureGatherCompare',
sampler,
descriptor,
arrayIndex: { num: texture.depthOrArrayLayers, type: A },
@ -284,6 +285,7 @@ Parameters:
const calls: TextureCall<vec2>[] = generateTextureBuiltinInputs2D(50, {
method: samplePoints,
textureBuiltin: 'textureGatherCompare',
sampler,
descriptor,
offset,

4
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/textureLoad.spec.ts
View File

@ -471,6 +471,9 @@ Parameters:
.combine('C', ['i32', 'u32'] as const)
.combine('L', ['i32', 'u32'] as const)
)
.beforeAllSubcases(t =>
t.skipIf(typeof VideoFrame === 'undefined', 'VideoFrames are not supported')
)
.fn(async t => {
const { samplePoints, C, L } = t.params;
@ -483,6 +486,7 @@ Parameters:
size,
usage: GPUTextureUsage.COPY_DST,
};
const { texels, videoFrame } = createVideoFrameWithRandomDataAndGetTexels(descriptor.size);
const texture = t.device.importExternalTexture({ source: videoFrame });

6
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/textureSampleBaseClampToEdge.spec.ts
View File

@ -61,6 +61,12 @@ Parameters:
.combine('addressModeV', ['clamp-to-edge', 'repeat', 'mirror-repeat'] as const)
.combine('minFilter', ['nearest', 'linear'] as const)
)
.beforeAllSubcases(t =>
t.skipIf(
t.params.textureType === 'texture_external' && typeof VideoFrame === 'undefined',
'VideoFrames are not supported'
)
)
.fn(async t => {
const { textureType, samplePoints, addressModeU, addressModeV, minFilter } = t.params;

162
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/texture_utils.ts
View File

@ -569,8 +569,13 @@ export interface TextureCall<T extends Dimensionality> extends TextureCallArgs<T
}
const isBuiltinComparison = (builtin: TextureBuiltin) => builtin === 'textureGatherCompare';
const isBuiltinGather = (builtin: TextureBuiltin) =>
const isBuiltinGather = (builtin: TextureBuiltin | undefined) =>
builtin === 'textureGather' || builtin === 'textureGatherCompare';
const builtinNeedsSampler = (builtin: TextureBuiltin) =>
builtin.startsWith('textureSample') || builtin.startsWith('textureGather');
const isCubeViewDimension = (viewDescriptor?: GPUTextureViewDescriptor) =>
viewDescriptor?.dimension === 'cube' || viewDescriptor?.dimension === 'cube-array';
const s_u32 = new Uint32Array(1);
const s_f32 = new Float32Array(s_u32.buffer);
@ -784,10 +789,7 @@ export function softwareTextureReadMipLevel<T extends Dimensionality>(
sampler?.addressModeW ?? 'clamp-to-edge',
];
const isCube =
texture.viewDescriptor.dimension === 'cube' ||
texture.viewDescriptor.dimension === 'cube-array';
const isCube = isCubeViewDimension(texture.viewDescriptor);
const arrayIndexMult = isCube ? 6 : 1;
const numLayers = textureSize[2] / arrayIndexMult;
assert(numLayers % 1 === 0);
@ -1009,7 +1011,8 @@ export function softwareTextureReadLevel<T extends Dimensionality>(
return softwareTextureReadMipLevel<T>(call, texture, sampler, mipLevel);
}
switch (sampler.mipmapFilter) {
const effectiveMipmapFilter = isBuiltinGather(call.builtin) ? 'nearest' : sampler.mipmapFilter;
switch (effectiveMipmapFilter) {
case 'linear': {
const clampedMipLevel = clamp(mipLevel, { min: 0, max: maxLevel });
const baseMipLevel = Math.floor(clampedMipLevel);
@ -1308,7 +1311,7 @@ export async function checkCallResults<T extends Dimensionality>(
? getMaxFractionalDiffForTextureFormat(texture.descriptor.format)
: 0;
for (let callIdx = 0; callIdx < calls.length /*&& errs.length === 0*/; callIdx++) {
for (let callIdx = 0; callIdx < calls.length; callIdx++) {
const call = calls[callIdx];
const gotRGBA = results[callIdx];
const expectRGBA = softwareTextureReadLevel(t, call, texture, sampler, call.mipLevel ?? 0);
@ -1356,7 +1359,11 @@ export async function checkCallResults<T extends Dimensionality>(
return { absDiff, relDiff, ulpDiff };
});
const fix5 = (n: number) => n.toFixed(5);
const isFloatType = (format: GPUTextureFormat) => {
const info = kTextureFormatInfo[format];
return info.color?.type === 'float' || info.depth?.type === 'depth';
};
const fix5 = (n: number) => (isFloatType(format) ? n.toFixed(5) : n.toString());
const fix5v = (arr: number[]) => arr.map(v => fix5(v)).join(', ');
const rgbaToArray = (p: PerTexelComponent<number>): number[] =>
rgbaComponentsToCheck.map(component => p[component]!);
@ -1366,7 +1373,34 @@ export async function checkCallResults<T extends Dimensionality>(
errs.push(`result was not as expected:
size: [${size.width}, ${size.height}, ${size.depthOrArrayLayers}]
mipCount: ${texture.descriptor.mipLevelCount ?? 1}
call: ${desc} // #${callIdx}
call: ${desc} // #${callIdx}`);
if (isCubeViewDimension(texture.viewDescriptor)) {
const coord = convertCubeCoordToNormalized3DTextureCoord(call.coords as vec3);
const faceNdx = Math.floor(coord[2] * 6);
errs.push(` : as 3D texture coord: (${coord[0]}, ${coord[1]}, ${coord[2]})`);
for (let mipLevel = 0; mipLevel < (texture.descriptor.mipLevelCount ?? 1); ++mipLevel) {
const mipSize = virtualMipSize(
texture.descriptor.dimension ?? '2d',
texture.descriptor.size,
mipLevel
);
const t = coord.slice(0, 2).map((v, i) => (v * mipSize[i]).toFixed(3));
errs.push(
` : as texel coord mip level[${mipLevel}]: (${t[0]}, ${t[1]}), face: ${faceNdx}(${kFaceNames[faceNdx]})`
);
}
} else {
for (let mipLevel = 0; mipLevel < (texture.descriptor.mipLevelCount ?? 1); ++mipLevel) {
const mipSize = virtualMipSize(
texture.descriptor.dimension ?? '2d',
texture.descriptor.size,
mipLevel
);
const t = call.coords!.map((v, i) => (v * mipSize[i]).toFixed(3));
errs.push(` : as texel coord @ mip level[${mipLevel}]: (${t.join(', ')})`);
}
}
errs.push(`\
got: ${fix5v(rgbaToArray(gotRGBA))}
expected: ${fix5v(rgbaToArray(expectRGBA))}
max diff: ${maxFractionalDiff}
@ -1410,9 +1444,13 @@ export async function checkCallResults<T extends Dimensionality>(
errs.push(' sample points:');
errs.push(layoutTwoColumns(expectedSamplePoints, gotSamplePoints).join('\n'));
errs.push('', '');
}
}
}
// This path is slow so if we took it, don't report the other errors. One is enough
// to fail the test.
break;
} // if (sampler)
} // if (bad)
} // for cellNdx
return errs.length > 0 ? new Error(errs.join('\n')) : undefined;
}
@ -2138,7 +2176,7 @@ async function identifySamplePoints<T extends Dimensionality>(
run: (texels: TexelView[]) => Promise<PerTexelComponent<number>>
) {
const info = texture.descriptor;
const isCube = texture.viewDescriptor.dimension === 'cube';
const isCube = isCubeViewDimension(texture.viewDescriptor);
const mipLevelCount = texture.descriptor.mipLevelCount ?? 1;
const mipLevelSize = range(mipLevelCount, mipLevel =>
virtualMipSize(texture.descriptor.dimension ?? '2d', texture.descriptor.size, mipLevel)
@ -2514,9 +2552,76 @@ function generateTextureBuiltinInputsImpl<T extends Dimensionality>(
// Linux, AMD Radeon Pro WX 3200: 256
// MacOS, M1 Mac: 256
const kSubdivisionsPerTexel = 4;
// When filtering is nearest then we want to avoid edges of texels
//
// U
// |
// +---+---+---+---+---+---+---+---+
// | | A | B | | | | | |
// +---+---+---+---+---+---+---+---+
//
// Above, coordinate U could sample either A or B
//
// U
// |
// +---+---+---+---+---+---+---+---+
// | | A | B | C | | | | |
// +---+---+---+---+---+---+---+---+
//
// For textureGather we want to avoid texel centers
// as for coordinate U could either gather A,B or B,C.
const avoidEdgeCase =
!args.sampler || args.sampler.minFilter === 'nearest' || isBuiltinGather(args.textureBuiltin!);
const edgeRemainder = args.textureBuiltin === 'textureGather' ? kSubdivisionsPerTexel / 2 : 0;
!args.sampler || args.sampler.minFilter === 'nearest' || isBuiltinGather(args.textureBuiltin);
const edgeRemainder = isBuiltinGather(args.textureBuiltin) ? kSubdivisionsPerTexel / 2 : 0;
// textureGather issues for 2d/3d textures
//
// If addressModeU is repeat, then on an 8x1 texture, u = 0.01 or u = 0.99
// would gather these texels
//
// +---+---+---+---+---+---+---+---+
// | * | | | | | | | * |
// +---+---+---+---+---+---+---+---+
//
// If addressModeU is clamp-to-edge or mirror-repeat,
// then on an 8x1 texture, u = 0.01 would gather this texel
//
// +---+---+---+---+---+---+---+---+
// | * | | | | | | | |
// +---+---+---+---+---+---+---+---+
//
// and 0.99 would gather this texel
//
// +---+---+---+---+---+---+---+---+
// | | | | | | | | * |
// +---+---+---+---+---+---+---+---+
//
// This means we have to if addressMode is not `repeat`, we
// need to avoid the edge of the texture.
//
// Note: we don't have these specific issues with cube maps
// as they ignore addressMode
const euclideanModulo = (n: number, m: number) => ((n % m) + m) % m;
const addressMode: GPUAddressMode[] =
args.textureBuiltin === 'textureSampleBaseClampToEdge'
? ['clamp-to-edge', 'clamp-to-edge', 'clamp-to-edge']
: [
args.sampler?.addressModeU ?? 'clamp-to-edge',
args.sampler?.addressModeV ?? 'clamp-to-edge',
args.sampler?.addressModeW ?? 'clamp-to-edge',
];
const avoidTextureEdge = (axis: number, textureDimensionUnits: number, v: number) => {
assert(isBuiltinGather(args.textureBuiltin));
if (addressMode[axis] === 'repeat') {
return v;
}
const inside = euclideanModulo(v, textureDimensionUnits);
const outside = v - inside;
return outside + clamp(inside, { min: 1, max: textureDimensionUnits - 1 });
};
const numComponents = isDepthOrStencilTextureFormat(descriptor.format) ? 1 : 4;
return coords.map((c, i) => {
const mipLevel = args.mipLevel
@ -2531,10 +2636,11 @@ function generateTextureBuiltinInputsImpl<T extends Dimensionality>(
const v1 = Math.floor(v * q[i]);
// If it's nearest or textureGather and we're on the edge of a texel then move us off the edge
// since the edge could choose one texel or another.
const isEdgeCase = v1 % kSubdivisionsPerTexel === edgeRemainder;
const v2 = isEdgeCase && avoidEdgeCase ? v1 + 1 : v1;
const isTexelEdgeCase = Math.abs(v1 % kSubdivisionsPerTexel) === edgeRemainder;
const v2 = isTexelEdgeCase && avoidEdgeCase ? v1 + 1 : v1;
const v3 = isBuiltinGather(args.textureBuiltin) ? avoidTextureEdge(i, q[i], v2) : v2;
// Convert back to texture coords
return v2 / q[i];
return v3 / q[i];
}) as T;
return {
@ -2948,9 +3054,8 @@ export function generateSamplePointsCube(
//
const kSubdivisionsPerTexel = 4;
const avoidEdgeCase =
!args.sampler || args.sampler.minFilter === 'nearest' || isBuiltinGather(args.textureBuiltin!);
const edgeRemainder = isBuiltinGather(args.textureBuiltin!) ? kSubdivisionsPerTexel / 2 : 0;
!args.sampler || args.sampler.minFilter === 'nearest' || isBuiltinGather(args.textureBuiltin);
const edgeRemainder = isBuiltinGather(args.textureBuiltin) ? kSubdivisionsPerTexel / 2 : 0;
return coords.map((c, i) => {
const mipLevel = args.mipLevel
? quantizeMipLevel(makeRangeValue(args.mipLevel, i), args.sampler?.mipmapFilter ?? 'nearest')
@ -2978,10 +3083,10 @@ export function generateSamplePointsCube(
const v1 = Math.floor(v * q[i]);
// If it's nearest or textureGather and we're on the edge of a texel then move us off the edge
// since the edge could choose one texel or another.
const isEdgeCase = v1 % kSubdivisionsPerTexel === edgeRemainder;
const isEdgeCase = Math.abs(v1 % kSubdivisionsPerTexel) === edgeRemainder;
const v2 = isEdgeCase && avoidEdgeCase ? v1 + 1 : v1;
// Convert back to texture coords slightly off
return (v2 + 1 / 32) / q[i];
return (v2 + 1 / 16) / q[i];
}) as vec3;
const coords = convertNormalized3DTexCoordToCubeCoord(quantizedUVW);
@ -3065,17 +3170,14 @@ function buildBinnedCalls<T extends Dimensionality>(calls: TextureCall<T>[]) {
const data: number[] = [];
const prototype = calls[0];
if (prototype.builtin.startsWith('textureGather') && prototype['componentType']) {
if (isBuiltinGather(prototype.builtin) && prototype['componentType']) {
args.push(`/* component */ ${wgslExpr(prototype['component']!)}`);
}
// All texture builtins take a Texture
args.push('T');
if (
prototype.builtin.startsWith('textureSample') ||
prototype.builtin.startsWith('textureGather')
) {
if (builtinNeedsSampler(prototype.builtin)) {
// textureSample*() builtins take a sampler as the second argument
args.push('S');
}
@ -3152,11 +3254,11 @@ function binCalls<T extends Dimensionality>(calls: TextureCall<T>[]): number[][]
export function describeTextureCall<T extends Dimensionality>(call: TextureCall<T>): string {
const args: string[] = [];
if (call.builtin.startsWith('textureGather') && call.componentType) {
if (isBuiltinGather(call.builtin) && call.componentType) {
args.push(`component: ${wgslExprFor(call.component!, call.componentType)}`);
}
args.push('texture: T');
if (call.builtin.startsWith('textureSample') || call.builtin.startsWith('textureGather')) {
if (builtinNeedsSampler(call.builtin)) {
args.push('sampler: S');
}
for (const name of kTextureCallArgNames) {

6
dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/shader_io/fragment_builtins.spec.ts
View File

@ -1659,15 +1659,15 @@ enable subgroups;
const width = ${t.params.size[0]};
const height = ${t.params.size[1]};
@group(0) @binding(0) var<storage, read_write> var for_layout : u32;
@group(0) @binding(0) var<storage, read_write> for_layout : u32;
@fragment
fn fsMain(
_ = for_layout;
@builtin(position) pos : vec4f,
@builtin(subgroup_size) sg_size : u32,
) -> @location(0) vec4u {
_ = for_layout;
let ballot = countOneBits(subgroupBallot(true));
let ballotSize = ballot.x + ballot.y + ballot.z + ballot.w;

286
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/quadBroadcast.spec.ts Normal file
View File

@ -0,0 +1,286 @@
export const description = `
Validation tests for quadBroadcast
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import {
isConvertible,
Type,
elementTypeOf,
kAllScalarsAndVectors,
} from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = quadBroadcast(0, 0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
g.test('requires_subgroups_f16')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['shader-f16', 'subgroups' as GPUFeatureName];
if (t.params.enable) {
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const wgsl = `
enable f16;
enable subgroups;
${t.params.enable ? 'enable subgroups_f16;' : ''}
fn foo() {
_ = quadBroadcast(0h, 0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kArgumentTypes = objectsToRecord(kAllScalarsAndVectors);
const kStages: Record<string, string> = {
constant: `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = quadBroadcast(0, 0);
}`,
override: `
enable subgroups;
override o = quadBroadcast(0, 0);`,
runtime: `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = quadBroadcast(0, 0);
}`,
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage];
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}quadBroadcast(0, 0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
g.test('data_type')
.desc('Validates data parameter type')
.params(u => u.combine('type', keysOf(kArgumentTypes)))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kArgumentTypes[t.params.type];
if (type.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kArgumentTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = quadBroadcast(${type.create(0).wgsl()}, 0);
}`;
t.expectCompileResult(elementTypeOf(type) !== Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates data parameter type')
.params(u =>
u
.combine('dataType', keysOf(kArgumentTypes))
.combine('retType', keysOf(kArgumentTypes))
.filter(t => {
const retType = kArgumentTypes[t.retType];
const retEleTy = elementTypeOf(retType);
const dataType = kArgumentTypes[t.dataType];
const dataEleTy = elementTypeOf(dataType);
return (
retEleTy !== Type.abstractInt &&
retEleTy !== Type.abstractFloat &&
dataEleTy !== Type.abstractInt &&
dataEleTy !== Type.abstractFloat
);
})
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
if (dataType.requiresF16() || retType.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
let enables = `enable subgroups;\n`;
if (dataType.requiresF16() || retType.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = quadBroadcast(${dataType.create(0).wgsl()}, 0);
}`;
const expect = elementTypeOf(dataType) !== Type.bool && dataType === retType;
t.expectCompileResult(expect, wgsl);
});
g.test('id_type')
.desc('Validates id parameter type')
.params(u => u.combine('type', keysOf(kArgumentTypes)))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const type = kArgumentTypes[t.params.type];
const wgsl = `
enable subgroups;
@compute @workgroup_size(1)
fn main() {
_ = quadBroadcast(0, ${type.create(0).wgsl()});
}`;
const expect = isConvertible(type, Type.u32) || isConvertible(type, Type.i32);
t.expectCompileResult(expect, wgsl);
});
const kIdCases = {
const_decl: {
code: 'const_decl',
valid: true,
},
const_literal: {
code: '0',
valid: true,
},
const_expr: {
code: 'const_decl + 2',
valid: true,
},
let_decl: {
code: 'let_decl',
valid: false,
},
override_decl: {
code: 'override_decl',
valid: false,
},
var_func_decl: {
code: 'var_func_decl',
valid: false,
},
var_priv_decl: {
code: 'var_priv_decl',
valid: false,
},
};
g.test('id_constness')
.desc('Validates that id must be a const-expression')
.params(u => u.combine('value', keysOf(kIdCases)))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
override override_decl : u32;
var<private> var_priv_decl : u32;
fn foo() {
var var_func_decl : u32;
let let_decl = var_func_decl;
const const_decl = 0u;
_ = quadBroadcast(0, ${kIdCases[t.params.value].code});
}`;
t.expectCompileResult(kIdCases[t.params.value].valid, wgsl);
});
g.test('stage')
.desc('Validates it is only usable in correct stage')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = quadBroadcast(0, 0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

227
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/quadSwap.spec.ts Normal file
View File

@ -0,0 +1,227 @@
export const description = `
Validation tests for quadSwapX, quadSwapY, and quadSwapDiagonal.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import {
Type,
elementTypeOf,
kAllScalarsAndVectors,
isConvertible,
} from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
const kOps = ['quadSwapX', 'quadSwapY', 'quadSwapDiagonal'] as const;
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = ${t.params.op}(0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
g.test('requires_subgroups_f16')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['shader-f16', 'subgroups' as GPUFeatureName];
if (t.params.enable) {
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const wgsl = `
enable f16;
enable subgroups;
${t.params.enable ? 'enable subgroups_f16;' : ''}
fn foo() {
_ = ${t.params.op}(0h);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kStages: Record<string, (op: string) => string> = {
constant: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = ${op}(0);
}`;
},
override: (op: string) => {
return `
enable subgroups
override o = ${op}(0);`;
},
runtime: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = ${op}(0);
}`;
},
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage](t.params.op);
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}${t.params.op}(0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates data parameter type')
.params(u => u.combine('type', keysOf(kTypes)).combine('op', kOps))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.op}(${type.create(0).wgsl()});
}`;
const eleType = elementTypeOf(type);
t.expectCompileResult(eleType !== Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates return type')
.params(u =>
u
.combine('retType', keysOf(kTypes))
.filter(t => {
const type = kTypes[t.retType];
const eleType = elementTypeOf(type);
return eleType !== Type.abstractInt && eleType !== Type.abstractFloat;
})
.combine('op', kOps)
.combine('paramType', keysOf(kTypes))
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
if (retType.requiresF16() || paramType.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
let enables = `enable subgroups;\n`;
if (retType.requiresF16() || paramType.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = ${t.params.op}(${paramType.create(0).wgsl()});
}`;
// Can't just use isConvertible since functions must concretize the parameter
// type before examining the whole statement.
const eleParamType = elementTypeOf(paramType);
const eleRetType = elementTypeOf(retType);
let expect = paramType === retType && eleRetType !== Type.bool;
if (eleParamType === Type.abstractInt) {
expect = eleRetType === Type.i32 && isConvertible(paramType, retType);
} else if (eleParamType === Type.abstractFloat) {
expect = eleRetType === Type.f32 && isConvertible(paramType, retType);
}
t.expectCompileResult(expect, wgsl);
});
g.test('stage')
.desc('validates builtin is only usable in the correct stages')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = ${t.params.op}(0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

235
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupAdd.spec.ts Normal file
View File

@ -0,0 +1,235 @@
export const description = `
Validation tests for subgroupAdd and subgroupExclusiveAdd
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import { Type, elementTypeOf, kAllScalarsAndVectors } from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
const kBuiltins = ['subgroupAdd', 'subgroupExclusiveAdd'] as const;
const kStages: Record<string, (builtin: string) => string> = {
constant: (builtin: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = ${builtin}(0);
}`;
},
override: (builtin: string) => {
return `
enable subgroups;
override o = ${builtin}(0);`;
},
runtime: (builtin: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = ${builtin}(0);
}`;
},
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)).beginSubcases().combine('builtin', kBuiltins))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage](t.params.builtin);
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u =>
u
.combine('must_use', [true, false] as const)
.beginSubcases()
.combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}${t.params.builtin}(0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kArgumentTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates data parameter type')
.params(u =>
u.combine('type', keysOf(kArgumentTypes)).beginSubcases().combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kArgumentTypes[t.params.type];
if (type.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kArgumentTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.builtin}(${type.create(0).wgsl()});
}`;
t.expectCompileResult(elementTypeOf(type) !== Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates data parameter type')
.params(u =>
u
.combine('dataType', keysOf(kArgumentTypes))
.combine('retType', keysOf(kArgumentTypes))
.filter(t => {
const retType = kArgumentTypes[t.retType];
const retEleTy = elementTypeOf(retType);
const dataType = kArgumentTypes[t.dataType];
const dataEleTy = elementTypeOf(dataType);
return (
retEleTy !== Type.abstractInt &&
retEleTy !== Type.abstractFloat &&
dataEleTy !== Type.abstractInt &&
dataEleTy !== Type.abstractFloat
);
})
.beginSubcases()
.combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
if (dataType.requiresF16() || retType.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
let enables = `enable subgroups;\n`;
if (dataType.requiresF16() || retType.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = ${t.params.builtin}(${dataType.create(0).wgsl()});
}`;
const expect = elementTypeOf(dataType) !== Type.bool && dataType === retType;
t.expectCompileResult(expect, wgsl);
});
g.test('stage')
.desc('Validates it is only usable in correct stage')
.params(u =>
u
.combine('stage', ['compute', 'fragment', 'vertex'] as const)
.beginSubcases()
.combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = ${t.params.builtin}(0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});
const kInvalidTypeCases: Record<string, string> = {
array_u32: `array(1u,2u,3u)`,
array_f32: `array<f32, 4>()`,
struct_s: `S()`,
struct_t: `T(1, 1)`,
ptr_func: `&func_var`,
ptr_priv: `&priv_var`,
frexp_ret: `frexp(0)`,
};
g.test('invalid_types')
.desc('Tests that invalid non-plain types are rejected')
.params(u =>
u.combine('case', keysOf(kInvalidTypeCases)).beginSubcases().combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const val = kInvalidTypeCases[t.params.case];
const wgsl = `
enable subgroups;
struct S {
x : u32
}
struct T {
a : f32,
b : u32,
}
var<private> priv_var : f32;
fn foo() {
var func_var : vec4u;
_ = ${t.params.builtin}(${val});
}`;
t.expectCompileResult(false, wgsl);
});

186
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupAnyAll.spec.ts Normal file
View File

@ -0,0 +1,186 @@
export const description = `
Validation tests for subgroupAny and subgroupAll.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import { Type, elementTypeOf, kAllScalarsAndVectors } from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
const kOps = ['subgroupAny', 'subgroupAll'] as const;
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = ${t.params.op}(true);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kStages: Record<string, (op: string) => string> = {
constant: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = ${op}(true);
}`;
},
override: (op: string) => {
return `
enable subgroups
override o = select(0, 1, ${op}(true));`;
},
runtime: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = ${op}(true);
}`;
},
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage](t.params.op);
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}${t.params.op}(false);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates data parameter type')
.params(u => u.combine('type', keysOf(kTypes)).combine('op', kOps))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.op}(${type.create(0).wgsl()});
}`;
t.expectCompileResult(type === Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates return type')
.params(u =>
u
.combine('type', keysOf(kTypes))
.filter(t => {
const type = kTypes[t.type];
const eleType = elementTypeOf(type);
return eleType !== Type.abstractInt && eleType !== Type.abstractFloat;
})
.combine('op', kOps)
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${type.toString()} = ${t.params.op}(true);
}`;
t.expectCompileResult(type === Type.bool, wgsl);
});
g.test('stage')
.desc('validates builtin is only usable in the correct stages')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = ${t.params.op}(true);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

35
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupBallot.spec.ts
View File

@ -9,6 +9,22 @@ import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = subgroupBallot(true);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kStages: Record<string, string> = {
constant: `
enable subgroups;
@ -38,6 +54,23 @@ g.test('early_eval')
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}subgroupBallot(true);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kArgumentTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
@ -69,7 +102,7 @@ fn main() {
});
g.test('return_type')
.desc('Validates data parameter type')
.desc('Validates return type')
.params(u =>
u.combine('type', keysOf(kArgumentTypes)).filter(t => {
const type = kArgumentTypes[t.type];

204
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupBitwise.spec.ts Normal file
View File

@ -0,0 +1,204 @@
export const description = `
Validation tests for subgroupAnd, subgroupOr, and subgroupXor.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import {
Type,
elementTypeOf,
kAllScalarsAndVectors,
isConvertible,
} from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
const kOps = ['subgroupAnd', 'subgroupOr', 'subgroupXor'] as const;
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = ${t.params.op}(0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kStages: Record<string, (op: string) => string> = {
constant: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = ${op}(0);
}`;
},
override: (op: string) => {
return `
enable subgroups
override o = ${op}(0);`;
},
runtime: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = ${op}(0);
}`;
},
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage](t.params.op);
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}${t.params.op}(0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates data parameter type')
.params(u => u.combine('type', keysOf(kTypes)).combine('op', kOps))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.op}(${type.create(0).wgsl()});
}`;
const eleType = elementTypeOf(type);
const expect = isConvertible(eleType, Type.u32) || isConvertible(eleType, Type.i32);
t.expectCompileResult(expect, wgsl);
});
g.test('return_type')
.desc('Validates return type')
.params(u =>
u
.combine('retType', keysOf(kTypes))
.filter(t => {
const type = kTypes[t.retType];
const eleType = elementTypeOf(type);
return eleType !== Type.abstractInt && eleType !== Type.abstractFloat;
})
.combine('op', kOps)
.combine('paramType', keysOf(kTypes))
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
if (retType.requiresF16() || paramType.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
let enables = `enable subgroups;\n`;
if (retType.requiresF16() || paramType.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = ${t.params.op}(${paramType.create(0).wgsl()});
}`;
// Can't just use isConvertible since functions must concretize the parameter
// type before examining the whole statement.
const eleParamType = elementTypeOf(paramType);
const eleRetType = elementTypeOf(retType);
let expect = paramType === retType && (eleRetType === Type.i32 || eleRetType === Type.u32);
if (eleParamType === Type.abstractInt) {
expect = eleRetType === Type.i32 && isConvertible(paramType, retType);
}
t.expectCompileResult(expect, wgsl);
});
g.test('stage')
.desc('validates builtin is only usable in the correct stages')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = ${t.params.op}(0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

90
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupBroadcast.spec.ts
View File

@ -14,6 +14,44 @@ import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = subgroupBroadcast(0, 0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
g.test('requires_subgroups_f16')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['shader-f16', 'subgroups' as GPUFeatureName];
if (t.params.enable) {
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const wgsl = `
enable f16;
enable subgroups;
${t.params.enable ? 'enable subgroups_f16;' : ''}
fn foo() {
_ = subgroupBroadcast(0h, 0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kArgumentTypes = objectsToRecord(kAllScalarsAndVectors);
const kStages: Record<string, string> = {
@ -156,6 +194,58 @@ fn main() {
t.expectCompileResult(expect, wgsl);
});
const kIdCases = {
const_decl: {
code: 'const_decl',
valid: true,
},
const_literal: {
code: '0',
valid: true,
},
const_expr: {
code: 'const_decl + 2',
valid: true,
},
let_decl: {
code: 'let_decl',
valid: false,
},
override_decl: {
code: 'override_decl',
valid: false,
},
var_func_decl: {
code: 'var_func_decl',
valid: false,
},
var_priv_decl: {
code: 'var_priv_decl',
valid: false,
},
};
g.test('id_constness')
.desc('Validates that id must be a const-expression')
.params(u => u.combine('value', keysOf(kIdCases)))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
override override_decl : u32;
var<private> var_priv_decl : u32;
fn foo() {
var var_func_decl : u32;
let let_decl = var_func_decl;
const const_decl = 0u;
_ = subgroupBroadcast(0, ${kIdCases[t.params.value].code});
}`;
t.expectCompileResult(kIdCases[t.params.value].valid, wgsl);
});
g.test('stage')
.desc('Validates it is only usable in correct stage')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const))

210
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupBroadcastFirst.spec.ts Normal file
View File

@ -0,0 +1,210 @@
export const description = `
Validation tests for subgroupBroadcastFirst
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import { Type, elementTypeOf, kAllScalarsAndVectors } from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = subgroupBroadcastFirst(0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
g.test('requires_subgroups_f16')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['shader-f16', 'subgroups' as GPUFeatureName];
if (t.params.enable) {
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const wgsl = `
enable f16;
enable subgroups;
${t.params.enable ? 'enable subgroups_f16;' : ''}
fn foo() {
_ = subgroupBroadcastFirst(0h);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kArgumentTypes = objectsToRecord(kAllScalarsAndVectors);
const kStages: Record<string, string> = {
constant: `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = subgroupBroadcastFirst(0);
}`,
override: `
enable subgroups;
override o = subgroupBroadcastFirst(0);`,
runtime: `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = subgroupBroadcastFirst(0);
}`,
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage];
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}subgroupBroadcastFirst(0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
g.test('data_type')
.desc('Validates data parameter type')
.params(u => u.combine('type', keysOf(kArgumentTypes)))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kArgumentTypes[t.params.type];
if (type.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kArgumentTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = subgroupBroadcastFirst(${type.create(0).wgsl()});
}`;
t.expectCompileResult(elementTypeOf(type) !== Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates data parameter type')
.params(u =>
u
.combine('dataType', keysOf(kArgumentTypes))
.combine('retType', keysOf(kArgumentTypes))
.filter(t => {
const retType = kArgumentTypes[t.retType];
const retEleTy = elementTypeOf(retType);
const dataType = kArgumentTypes[t.dataType];
const dataEleTy = elementTypeOf(dataType);
return (
retEleTy !== Type.abstractInt &&
retEleTy !== Type.abstractFloat &&
dataEleTy !== Type.abstractInt &&
dataEleTy !== Type.abstractFloat
);
})
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
if (dataType.requiresF16() || retType.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
let enables = `enable subgroups;\n`;
if (dataType.requiresF16() || retType.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = subgroupBroadcastFirst(${dataType.create(0).wgsl()});
}`;
const expect = elementTypeOf(dataType) !== Type.bool && dataType === retType;
t.expectCompileResult(expect, wgsl);
});
g.test('stage')
.desc('Validates it is only usable in correct stage')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = subgroupBroadcastFirst(0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

175
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupElect.spec.ts Normal file
View File

@ -0,0 +1,175 @@
export const description = `
Validation tests for subgroupElect.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import { Type, elementTypeOf, kAllScalarsAndVectors } from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = subgroupElect();
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kStages: Record<string, string> = {
constant: `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = subgroupElect();
}`,
override: `
enable subgroups
override o = select(0, 1, subgroupElect());`,
runtime: `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = subgroupElect();
}`,
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage];
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}subgroupElect();
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates there are no valid data parameters')
.params(u => u.combine('type', keysOf(kTypes)))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = subgroupElect(${type.create(0).wgsl()});
}`;
t.expectCompileResult(false, wgsl);
});
g.test('return_type')
.desc('Validates return type')
.params(u =>
u.combine('type', keysOf(kTypes)).filter(t => {
const type = kTypes[t.type];
const eleType = elementTypeOf(type);
return eleType !== Type.abstractInt && eleType !== Type.abstractFloat;
})
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${type.toString()} = subgroupElect();
}`;
t.expectCompileResult(type === Type.bool, wgsl);
});
g.test('stage')
.desc('validates builtin is only usable in the correct stages')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = subgroupElect();
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

227
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupMinMax.spec.ts Normal file
View File

@ -0,0 +1,227 @@
export const description = `
Validation tests for subgroupMin and subgroupMax.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import {
Type,
elementTypeOf,
kAllScalarsAndVectors,
isConvertible,
} from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
const kOps = ['subgroupMin', 'subgroupMax'] as const;
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = ${t.params.op}(0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
g.test('requires_subgroups_f16')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['shader-f16', 'subgroups' as GPUFeatureName];
if (t.params.enable) {
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const wgsl = `
enable f16;
enable subgroups;
${t.params.enable ? 'enable subgroups_f16;' : ''}
fn foo() {
_ = ${t.params.op}(0h);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kStages: Record<string, (op: string) => string> = {
constant: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = ${op}(0);
}`;
},
override: (op: string) => {
return `
enable subgroups
override o = ${op}(0);`;
},
runtime: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = ${op}(0);
}`;
},
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage](t.params.op);
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}${t.params.op}(0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates data parameter type')
.params(u => u.combine('type', keysOf(kTypes)).combine('op', kOps))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.op}(${type.create(0).wgsl()});
}`;
const eleType = elementTypeOf(type);
t.expectCompileResult(eleType !== Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates return type')
.params(u =>
u
.combine('retType', keysOf(kTypes))
.filter(t => {
const type = kTypes[t.retType];
const eleType = elementTypeOf(type);
return eleType !== Type.abstractInt && eleType !== Type.abstractFloat;
})
.combine('op', kOps)
.combine('paramType', keysOf(kTypes))
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
if (retType.requiresF16() || paramType.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
let enables = `enable subgroups;\n`;
if (retType.requiresF16() || paramType.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = ${t.params.op}(${paramType.create(0).wgsl()});
}`;
// Can't just use isConvertible since functions must concretize the parameter
// type before examining the whole statement.
const eleParamType = elementTypeOf(paramType);
const eleRetType = elementTypeOf(retType);
let expect = paramType === retType && eleRetType !== Type.bool;
if (eleParamType === Type.abstractInt) {
expect = eleRetType === Type.i32 && isConvertible(paramType, retType);
} else if (eleParamType === Type.abstractFloat) {
expect = eleRetType === Type.f32 && isConvertible(paramType, retType);
}
t.expectCompileResult(expect, wgsl);
});
g.test('stage')
.desc('validates builtin is only usable in the correct stages')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = ${t.params.op}(0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

235
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupMul.spec.ts Normal file
View File

@ -0,0 +1,235 @@
export const description = `
Validation tests for subgroupMul and subgroupExclusiveMul
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import { Type, elementTypeOf, kAllScalarsAndVectors } from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
const kBuiltins = ['subgroupMul', 'subgroupExclusiveMul'] as const;
const kStages: Record<string, (builtin: string) => string> = {
constant: (builtin: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = ${builtin}(0);
}`;
},
override: (builtin: string) => {
return `
enable subgroups;
override o = ${builtin}(0);`;
},
runtime: (builtin: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = ${builtin}(0);
}`;
},
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)).beginSubcases().combine('builtin', kBuiltins))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage](t.params.builtin);
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u =>
u
.combine('must_use', [true, false] as const)
.beginSubcases()
.combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}${t.params.builtin}(0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kArgumentTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates data parameter type')
.params(u =>
u.combine('type', keysOf(kArgumentTypes)).beginSubcases().combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kArgumentTypes[t.params.type];
if (type.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kArgumentTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.builtin}(${type.create(0).wgsl()});
}`;
t.expectCompileResult(elementTypeOf(type) !== Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates data parameter type')
.params(u =>
u
.combine('dataType', keysOf(kArgumentTypes))
.combine('retType', keysOf(kArgumentTypes))
.filter(t => {
const retType = kArgumentTypes[t.retType];
const retEleTy = elementTypeOf(retType);
const dataType = kArgumentTypes[t.dataType];
const dataEleTy = elementTypeOf(dataType);
return (
retEleTy !== Type.abstractInt &&
retEleTy !== Type.abstractFloat &&
dataEleTy !== Type.abstractInt &&
dataEleTy !== Type.abstractFloat
);
})
.beginSubcases()
.combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
if (dataType.requiresF16() || retType.requiresF16()) {
features.push('subgroups-f16' as GPUFeatureName);
features.push('shader-f16');
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const dataType = kArgumentTypes[t.params.dataType];
const retType = kArgumentTypes[t.params.retType];
let enables = `enable subgroups;\n`;
if (dataType.requiresF16() || retType.requiresF16()) {
enables += `enable subgroups_f16;\nenable f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = ${t.params.builtin}(${dataType.create(0).wgsl()});
}`;
const expect = elementTypeOf(dataType) !== Type.bool && dataType === retType;
t.expectCompileResult(expect, wgsl);
});
g.test('stage')
.desc('Validates it is only usable in correct stage')
.params(u =>
u
.combine('stage', ['compute', 'fragment', 'vertex'] as const)
.beginSubcases()
.combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = ${t.params.builtin}(0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});
const kInvalidTypeCases: Record<string, string> = {
array_u32: `array(1u,2u,3u)`,
array_f32: `array<f32, 4>()`,
struct_s: `S()`,
struct_t: `T(1, 1)`,
ptr_func: `&func_var`,
ptr_priv: `&priv_var`,
frexp_ret: `frexp(0)`,
};
g.test('invalid_types')
.desc('Tests that invalid non-plain types are rejected')
.params(u =>
u.combine('case', keysOf(kInvalidTypeCases)).beginSubcases().combine('builtin', kBuiltins)
)
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const val = kInvalidTypeCases[t.params.case];
const wgsl = `
enable subgroups;
struct S {
x : u32
}
struct T {
a : f32,
b : u32,
}
var<private> priv_var : f32;
fn foo() {
var func_var : vec4u;
_ = ${t.params.builtin}(${val});
}`;
t.expectCompileResult(false, wgsl);
});

262
dom/webgpu/tests/cts/checkout/src/webgpu/shader/validation/expression/call/builtin/subgroupShuffle.spec.ts Normal file
View File

@ -0,0 +1,262 @@
export const description = `
Validation tests for subgroupShuffle, subgroupShuffleXor, subgroupShuffleUp, and subgroupShuffleDown.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { keysOf, objectsToRecord } from '../../../../../../common/util/data_tables.js';
import {
Type,
elementTypeOf,
kAllScalarsAndVectors,
isConvertible,
} from '../../../../../util/conversion.js';
import { ShaderValidationTest } from '../../../shader_validation_test.js';
export const g = makeTestGroup(ShaderValidationTest);
const kOps = [
'subgroupShuffle',
'subgroupShuffleXor',
'subgroupShuffleUp',
'subgroupShuffleDown',
] as const;
g.test('requires_subgroups')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
${t.params.enable ? 'enable subgroups;' : ''}
fn foo() {
_ = ${t.params.op}(0, 0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
g.test('requires_subgroups_f16')
.desc('Validates that the subgroups feature is required')
.params(u => u.combine('enable', [false, true] as const).combine('op', kOps))
.beforeAllSubcases(t => {
const features: GPUFeatureName[] = ['shader-f16', 'subgroups' as GPUFeatureName];
if (t.params.enable) {
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const wgsl = `
enable f16;
enable subgroups;
${t.params.enable ? 'enable subgroups_f16;' : ''}
fn foo() {
_ = ${t.params.op}(0h, 0);
}`;
t.expectCompileResult(t.params.enable, wgsl);
});
const kStages: Record<string, (op: string) => string> = {
constant: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
const x = ${op}(0, 0);
}`;
},
override: (op: string) => {
return `
enable subgroups
override o = ${op}(0, 0);`;
},
runtime: (op: string) => {
return `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
let x = ${op}(0, 0);
}`;
},
};
g.test('early_eval')
.desc('Ensures the builtin is not able to be compile time evaluated')
.params(u => u.combine('stage', keysOf(kStages)).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const code = kStages[t.params.stage](t.params.op);
t.expectCompileResult(t.params.stage === 'runtime', code);
});
g.test('must_use')
.desc('Tests that the builtin has the @must_use attribute')
.params(u => u.combine('must_use', [true, false] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const wgsl = `
enable subgroups;
@compute @workgroup_size(16)
fn main() {
${t.params.must_use ? '_ = ' : ''}${t.params.op}(0, 0);
}`;
t.expectCompileResult(t.params.must_use, wgsl);
});
const kTypes = objectsToRecord(kAllScalarsAndVectors);
g.test('data_type')
.desc('Validates data parameter type')
.params(u => u.combine('type', keysOf(kTypes)).combine('op', kOps))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.op}(${type.create(0).wgsl()}, 0);
}`;
const eleType = elementTypeOf(type);
t.expectCompileResult(eleType !== Type.bool, wgsl);
});
g.test('return_type')
.desc('Validates return type')
.params(u =>
u
.combine('retType', keysOf(kTypes))
.filter(t => {
const type = kTypes[t.retType];
const eleType = elementTypeOf(type);
return eleType !== Type.abstractInt && eleType !== Type.abstractFloat;
})
.combine('op', kOps)
.combine('paramType', keysOf(kTypes))
)
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
if (retType.requiresF16() || paramType.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const retType = kTypes[t.params.retType];
const paramType = kTypes[t.params.paramType];
let enables = `enable subgroups;\n`;
if (retType.requiresF16() || paramType.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
let res : ${retType.toString()} = ${t.params.op}(${paramType.create(0).wgsl()}, 0);
}`;
// Can't just use isConvertible since functions must concretize the parameter
// type before examining the whole statement.
const eleParamType = elementTypeOf(paramType);
const eleRetType = elementTypeOf(retType);
let expect = paramType === retType && eleRetType !== Type.bool;
if (eleParamType === Type.abstractInt) {
expect = eleRetType === Type.i32 && isConvertible(paramType, retType);
} else if (eleParamType === Type.abstractFloat) {
expect = eleRetType === Type.f32 && isConvertible(paramType, retType);
}
t.expectCompileResult(expect, wgsl);
});
g.test('param2_type')
.desc('Validates shuffle parameter type')
.params(u => u.combine('type', keysOf(kTypes)).combine('op', kOps))
.beforeAllSubcases(t => {
const features = ['subgroups' as GPUFeatureName];
const type = kTypes[t.params.type];
if (type.requiresF16()) {
features.push('shader-f16');
features.push('subgroups-f16' as GPUFeatureName);
}
t.selectDeviceOrSkipTestCase(features);
})
.fn(t => {
const type = kTypes[t.params.type];
let enables = `enable subgroups;\n`;
if (type.requiresF16()) {
enables += `enable f16;\nenable subgroups_f16;`;
}
const wgsl = `
${enables}
@compute @workgroup_size(1)
fn main() {
_ = ${t.params.op}(0, ${type.create(0).wgsl()});
}`;
const expect =
isConvertible(type, Type.u32) || (type === Type.i32 && t.params.op === 'subgroupShuffle');
t.expectCompileResult(expect, wgsl);
});
g.test('stage')
.desc('validates builtin is only usable in the correct stages')
.params(u => u.combine('stage', ['compute', 'fragment', 'vertex'] as const).combine('op', kOps))
.beforeAllSubcases(t => {
t.selectDeviceOrSkipTestCase('subgroups' as GPUFeatureName);
})
.fn(t => {
const compute = `
@compute @workgroup_size(1)
fn main() {
foo();
}`;
const fragment = `
@fragment
fn main() {
foo();
}`;
const vertex = `
@vertex
fn main() -> @builtin(position) vec4f {
foo();
return vec4f();
}`;
const entry = { compute, fragment, vertex }[t.params.stage];
const wgsl = `
enable subgroups;
fn foo() {
_ = ${t.params.op}(0, 0);
}
${entry}
`;
t.expectCompileResult(t.params.stage !== 'vertex', wgsl);
});

4
dom/webgpu/tests/cts/checkout/standalone/index.html
View File

@ -13,8 +13,8 @@
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Poppins&display=swap" rel="stylesheet">
<meta name="viewport" content="width=device-width" />
<!-- Chrome Origin Trial token for https://gpuweb.github.io (see dev_server.ts for localhost tokens) -->
<meta http-equiv="origin-trial" content="AmV1vLgjOQ01SlGnVhpoKXy7gLW+K/plXHwHKnYn4S4US98WaSesKBI+XSUMo95unQARyMGDvW70KsfyeYblZQ0AAABQeyJvcmlnaW4iOiJodHRwczovL2dwdXdlYi5naXRodWIuaW86NDQzIiwiZmVhdHVyZSI6IldlYkdQVSIsImV4cGlyeSI6MTY2MzcxODM5OX0=">
<!-- Chrome "WebGPU Subgroups Features" origin trial token for https://gpuweb.github.io (see dev_server.ts for localhost tokens) -->
<meta http-equiv="origin-trial" content="AiZbfNa6FSBMZg2Ak2xeb7upejmg3jb1Ll47edOTVs7fkZLvrV4jjPh7p4J7quB9Lx6Z7l0IDc97gpPKb4F6OQcAAABheyJvcmlnaW4iOiJodHRwczovL2dwdXdlYi5naXRodWIuaW86NDQzIiwiZmVhdHVyZSI6IldlYkdQVVN1Ymdyb3Vwc0ZlYXR1cmVzIiwiZXhwaXJ5IjoxNzM5OTIzMTk5fQ==">
<link rel="stylesheet" href="third_party/normalize.min.css" />
<script src="third_party/jquery/jquery-3.3.1.min.js"></script>
<style>

2
dom/webgpu/tests/cts/checkout_commit.txt
View File

@ -1 +1 @@
072d7b682e12996f3ac733ce55530aa619c54cc4
3d243847001f77fc98159169d654bc2d57e0dbde

1
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/operation/adapter/requestDevice/cts.https.html.ini
View File

@ -279,6 +279,7 @@
expected:
if os == "win": [OK, CRASH]
if os == "linux" and not debug: [OK, CRASH]
if os == "mac" and not debug: [OK, CRASH]
[:limit="maxBindGroups"]
[:limit="maxBindGroupsPlusVertexBuffers"]

28
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/operation/command_buffer/copyTextureToTexture/cts.https.html.ini
View File

@ -904,11 +904,8 @@
[:srcFormat="r32float";dstFormat="r32float";dimension="2d"]
expected:
if os == "win" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "win" and not debug: FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
if os == "mac": FAIL
if debug: [FAIL, TIMEOUT, NOTRUN]
if not debug: FAIL
[:srcFormat="r32float";dstFormat="r32float";dimension="3d"]
expected:
@ -1012,28 +1009,36 @@
if os == "mac" and debug: [TIMEOUT, NOTRUN]
[:srcFormat="rg16float";dstFormat="rg16float";dimension="1d"]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
[:srcFormat="rg16float";dstFormat="rg16float";dimension="2d"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
[:srcFormat="rg16float";dstFormat="rg16float";dimension="3d"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
[:srcFormat="rg16sint";dstFormat="rg16sint";dimension="1d"]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
[:srcFormat="rg16sint";dstFormat="rg16sint";dimension="2d"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
[:srcFormat="rg16sint";dstFormat="rg16sint";dimension="3d"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
[:srcFormat="rg16uint";dstFormat="rg16uint";dimension="1d"]
@ -1045,7 +1050,8 @@
[:srcFormat="rg16uint";dstFormat="rg16uint";dimension="3d"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
[:srcFormat="rg32float";dstFormat="rg32float";dimension="1d"]
expected:
@ -1246,6 +1252,8 @@
if os == "linux" and not debug: FAIL
[:srcFormat="rgba16uint";dstFormat="rgba16uint";dimension="1d"]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
[:srcFormat="rgba16uint";dstFormat="rgba16uint";dimension="2d"]
expected:

6
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/operation/memory_sync/buffer/multiple_buffers/cts.https.html.ini
View File

@ -608,12 +608,10 @@
expected:
if os == "win" and not debug: [PASS, FAIL]
if os == "linux": [PASS, FAIL]
if os == "mac" and not debug: [PASS, FAIL]
[:boundary="queue-op";readOp="storage-read";readContext="compute-pass-encoder";writeOp="write-buffer";writeContext="queue"]
expected:
if os == "win": [PASS, FAIL]
if os == "linux": [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
expected: [PASS, FAIL]
[:boundary="queue-op";readOp="storage-read";readContext="render-bundle-encoder";writeOp="b2b-copy";writeContext="command-encoder"]

6
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/operation/memory_sync/buffer/single_buffer/cts.https.html.ini
View File

@ -585,8 +585,8 @@
[:boundary="queue-op";readOp="storage-read";readContext="compute-pass-encoder";writeOp="storage";writeContext="compute-pass-encoder"]
expected:
if os == "linux" and not debug: [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
if os == "linux": [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[:boundary="queue-op";readOp="storage-read";readContext="compute-pass-encoder";writeOp="t2b-copy";writeContext="command-encoder"]
expected:
@ -627,7 +627,7 @@
[:boundary="queue-op";readOp="storage-read";readContext="render-pass-encoder";writeOp="write-buffer";writeContext="queue"]
expected:
if os == "win": [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[cts.https.html?q=webgpu:api,operation,memory_sync,buffer,single_buffer:ww:*]

40
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/operation/rendering/draw/cts.https.html.ini
View File

@ -80,8 +80,8 @@
[:first=0;count=0;first_instance=0;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
expected:
if os == "linux" and debug: [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
if os == "linux": [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[:first=0;count=0;first_instance=0;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=9]
expected:
@ -137,6 +137,7 @@
[:first=0;count=0;first_instance=0;instance_count=4;indexed=false;indirect=false;vertex_buffer_offset=32;index_buffer_offset="_undef_";base_vertex="_undef_"]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
[:first=0;count=0;first_instance=0;instance_count=4;indexed=false;indirect=true;vertex_buffer_offset=0;index_buffer_offset="_undef_";base_vertex="_undef_"]
expected: FAIL
@ -157,6 +158,7 @@
expected:
if os == "win" and not debug: [PASS, FAIL]
if os == "linux" and debug: [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[:first=0;count=0;first_instance=0;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=9]
expected:
@ -230,6 +232,7 @@
[:first=0;count=0;first_instance=2;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
[:first=0;count=0;first_instance=2;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=9]
expected:
@ -405,6 +408,7 @@
[:first=0;count=3;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
expected:
if os == "win" and not debug: [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
[:first=0;count=3;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
expected:
@ -459,6 +463,8 @@
expected: FAIL
[:first=0;count=3;first_instance=0;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=0]
expected:
if os == "linux" and not debug: [PASS, FAIL]
[:first=0;count=3;first_instance=0;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
@ -721,6 +727,8 @@
[:first=0;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=0;base_vertex=0]
[:first=0;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=0;base_vertex=9]
expected:
if os == "mac" and not debug: [PASS, FAIL]
[:first=0;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=16;base_vertex=0]
@ -1104,7 +1112,7 @@
[:first=3;count=0;first_instance=0;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=9]
expected:
if os == "linux" and debug: [PASS, FAIL]
if os == "linux": [PASS, FAIL]
[:first=3;count=0;first_instance=0;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=0;base_vertex=0]
@ -1141,6 +1149,8 @@
[:first=3;count=0;first_instance=0;instance_count=4;indexed=false;indirect=false;vertex_buffer_offset=0;index_buffer_offset="_undef_";base_vertex="_undef_"]
[:first=3;count=0;first_instance=0;instance_count=4;indexed=false;indirect=false;vertex_buffer_offset=32;index_buffer_offset="_undef_";base_vertex="_undef_"]
expected:
if os == "linux" and debug: [PASS, FAIL]
[:first=3;count=0;first_instance=0;instance_count=4;indexed=false;indirect=true;vertex_buffer_offset=0;index_buffer_offset="_undef_";base_vertex="_undef_"]
expected: FAIL
@ -1269,6 +1279,8 @@
if os == "linux" and not debug: [PASS, FAIL]
[:first=3;count=0;first_instance=2;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
expected:
if os == "linux" and not debug: [PASS, FAIL]
[:first=3;count=0;first_instance=2;instance_count=1;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
@ -1322,6 +1334,8 @@
expected: FAIL
[:first=3;count=0;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=0]
expected:
if os == "linux" and not debug: [PASS, FAIL]
[:first=3;count=0;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
expected:
@ -1330,6 +1344,7 @@
[:first=3;count=0;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
[:first=3;count=0;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=9]
@ -1348,6 +1363,7 @@
[:first=3;count=0;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=16;base_vertex=9]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "mac" and not debug: [PASS, FAIL]
[:first=3;count=0;first_instance=2;instance_count=4;indexed=true;indirect=true;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=0]
expected: FAIL
@ -1389,12 +1405,14 @@
if os == "linux" and not debug: [PASS, FAIL]
[:first=3;count=3;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
expected:
if os == "win" and debug: [PASS, FAIL]
[:first=3;count=3;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
if os == "mac" and not debug: [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[:first=3;count=3;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=9]
expected:
@ -1409,6 +1427,7 @@
[:first=3;count=3;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=16;base_vertex=0]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
if os == "mac" and not debug: [PASS, FAIL]
[:first=3;count=3;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=16;base_vertex=9]
@ -1439,7 +1458,7 @@
[:first=3;count=3;first_instance=0;instance_count=1;indexed=false;indirect=false;vertex_buffer_offset=0;index_buffer_offset="_undef_";base_vertex="_undef_"]
expected:
if os == "win" and not debug: [PASS, FAIL]
if os == "win": [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
[:first=3;count=3;first_instance=0;instance_count=1;indexed=false;indirect=false;vertex_buffer_offset=32;index_buffer_offset="_undef_";base_vertex="_undef_"]
@ -1514,6 +1533,7 @@
[:first=3;count=3;first_instance=0;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=0]
expected:
if os == "linux" and not debug: [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
[:first=3;count=3;first_instance=0;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
@ -1729,6 +1749,8 @@
[:first=3;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=0]
[:first=3;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
expected:
if os == "mac" and not debug: [PASS, FAIL]
[:first=3;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
expected:
@ -1743,7 +1765,7 @@
[:first=3;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=0;base_vertex=9]
expected:
if os == "mac" and debug: [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[:first=3;count=6;first_instance=0;instance_count=0;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=16;base_vertex=0]
@ -2002,10 +2024,16 @@
[:first=3;count=6;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=0]
[:first=3;count=6;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=0;base_vertex=9]
expected:
if os == "mac" and debug: [PASS, FAIL]
[:first=3;count=6;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=0]
expected:
if os == "mac" and not debug: [PASS, FAIL]
[:first=3;count=6;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=0;index_buffer_offset=16;base_vertex=9]
expected:
if os == "mac" and debug: [PASS, FAIL]
[:first=3;count=6;first_instance=2;instance_count=4;indexed=true;indirect=false;vertex_buffer_offset=32;index_buffer_offset=0;base_vertex=0]

12
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupSizeX/cts.https.html.ini
View File

@ -1,5 +1,7 @@
[cts.https.html?q=webgpu:api,validation,capability_checks,limits,maxComputeWorkgroupSizeX:createComputePipeline,at_over:*]
implementation-status: backlog
expected:
if os == "linux" and not debug: [OK, TIMEOUT]
[:limitTest="atDefault";testValueName="atLimit";async=false]
expected: FAIL
@ -25,6 +27,8 @@
[:limitTest="atMaximum";testValueName="overLimit";async=false]
[:limitTest="atMaximum";testValueName="overLimit";async=true]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="betweenDefaultAndMaximum";testValueName="atLimit";async=false]
expected: FAIL
@ -39,12 +43,20 @@
expected: FAIL
[:limitTest="overMaximum";testValueName="atLimit";async=false]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="overMaximum";testValueName="atLimit";async=true]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="overMaximum";testValueName="overLimit";async=false]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="overMaximum";testValueName="overLimit";async=true]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";async=false]
expected: FAIL

970
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupStorageSize/cts.https.html.ini
View File

File diff suppressed because it is too large Load Diff

87
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/capability_checks/limits/maxStorageBuffersPerShaderStage/cts.https.html.ini
View File

@ -2159,21 +2159,24 @@
[:limitTest="atDefault";testValueName="overLimit";visibility=2;type="read-only-storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=2;type="read-only-storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=2;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
@ -2201,147 +2204,168 @@
[:limitTest="atDefault";testValueName="overLimit";visibility=3;type="read-only-storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=3;type="read-only-storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=3;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=4;type="read-only-storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=4;type="read-only-storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=4;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=4;type="storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=4;type="storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=4;type="storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=5;type="read-only-storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=5;type="read-only-storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=5;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=6;type="read-only-storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=6;type="read-only-storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=6;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=6;type="storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=6;type="storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=6;type="storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=7;type="read-only-storage";order="backward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=7;type="read-only-storage";order="forward"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:limitTest="atDefault";testValueName="overLimit";visibility=7;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
@ -3457,50 +3481,62 @@
[:limitTest="underDefault";testValueName="atLimit";visibility=1;type="read-only-storage";order="backward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=1;type="read-only-storage";order="forward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=1;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=2;type="read-only-storage";order="backward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=2;type="read-only-storage";order="forward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=2;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=2;type="storage";order="backward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=2;type="storage";order="forward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=2;type="storage";order="shiftByHalf"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=3;type="read-only-storage";order="backward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=3;type="read-only-storage";order="forward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=3;type="read-only-storage";order="shiftByHalf"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=4;type="read-only-storage";order="backward"]
@ -3520,14 +3556,17 @@
[:limitTest="underDefault";testValueName="atLimit";visibility=4;type="storage";order="backward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=4;type="storage";order="forward"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=4;type="storage";order="shiftByHalf"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="underDefault";testValueName="atLimit";visibility=5;type="read-only-storage";order="backward"]

10
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/capability_checks/limits/maxVertexBuffers/cts.https.html.ini
View File

@ -68,11 +68,19 @@
[:limitTest="atDefault";testValueName="overLimit";encoderType="renderBundle"]
[:limitTest="atMaximum";testValueName="atLimit";encoderType="render"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="atMaximum";testValueName="atLimit";encoderType="renderBundle"]
expected:
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:limitTest="atMaximum";testValueName="overLimit";encoderType="render"]
expected: FAIL
expected:
if os == "win": FAIL
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:limitTest="atMaximum";testValueName="overLimit";encoderType="renderBundle"]
expected:

2
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/encoding/cmds/render/draw/cts.https.html.ini
View File

@ -21,6 +21,8 @@
expected: FAIL
[:bufferSizeInElements=100;bindingSizeInElements=10;drawIndexCount=11;drawType="drawIndexed"]
expected:
if os == "linux" and not debug: [PASS, FAIL]
[:bufferSizeInElements=100;bindingSizeInElements=10;drawIndexCount=11;drawType="drawIndexedIndirect"]
expected: FAIL

158
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/encoding/programmable/pipeline_bind_group_compat/cts.https.html.ini
View File

@ -1,279 +1,246 @@
[cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_binding_mismatch:*]
implementation-status: backlog
expected:
if os == "mac" and not debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:encoderType="compute%20pass";call="dispatch";callWithZero=false]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:encoderType="compute%20pass";call="dispatch";callWithZero=true]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="draw";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="draw";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexed";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexed";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexedIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexedIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="draw";callWithZero=false]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="draw";callWithZero=true]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, FAIL]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexed";callWithZero=false]
expected:
if os == "win": [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexed";callWithZero=true]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_resource_type_mismatch:*]
implementation-status: backlog
expected:
if os == "win" and debug: [OK, ERROR]
if os == "mac" and not debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:encoderType="compute%20pass";call="dispatch";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="compute%20pass";call="dispatch";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="compute%20pass";call="dispatchIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="draw";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="draw";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexed";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexed";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexedIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndexedIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20bundle";call="drawIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="draw";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="draw";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexed";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexed";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndexedIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndirect";callWithZero=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:encoderType="render%20pass";call="drawIndirect";callWithZero=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:bgl_visibility_mismatch:*]
@ -327,7 +294,7 @@
[:encoderType="render%20pass";call="draw";callWithZero=true]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "win": [PASS, FAIL]
if os == "linux" and not debug: [PASS, FAIL]
[:encoderType="render%20pass";call="drawIndexed";callWithZero=false]
@ -890,86 +857,77 @@
[cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:empty_bind_group_layouts_requires_empty_bind_groups,compute_pass:*]
implementation-status: backlog
expected:
if os == "mac" and not debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:bindGroupLayoutEntryCount=3;computeCommand="dispatch"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=3;computeCommand="dispatchIndirect"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=4;computeCommand="dispatch"]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=4;computeCommand="dispatchIndirect"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:empty_bind_group_layouts_requires_empty_bind_groups,render_pass:*]
implementation-status: backlog
expected:
if os == "mac" and not debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:bindGroupLayoutEntryCount=3;renderCommand="draw"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=3;renderCommand="drawIndexed"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=3;renderCommand="drawIndexedIndirect"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=3;renderCommand="drawIndirect"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=4;renderCommand="draw"]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=4;renderCommand="drawIndexed"]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=4;renderCommand="drawIndexedIndirect"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:bindGroupLayoutEntryCount=4;renderCommand="drawIndirect"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,encoding,programmable,pipeline_bind_group_compat:sampler_binding,render_pipeline:*]

1401
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/image_copy/layout_related/cts.https.html.ini
View File

File diff suppressed because it is too large Load Diff

303
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/queue/copyToTexture/CopyExternalImageToTexture/cts.https.html.ini
View File

@ -18,103 +18,260 @@
[cts.https.html?q=webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,format:*]
implementation-status: backlog
expected:
if os == "win" and not debug: [OK, TIMEOUT]
if os == "linux" and not debug: [OK, TIMEOUT]
[:format="astc-10x10-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-10x10-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-10x5-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-10x5-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-10x6-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-10x6-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-10x8-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-10x8-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-12x10-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-12x10-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-12x12-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-12x12-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-4x4-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-4x4-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-5x4-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-5x4-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-5x5-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-5x5-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-6x5-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-6x5-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-6x6-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-6x6-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-8x5-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-8x5-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-8x6-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-8x6-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-8x8-unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="astc-8x8-unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="bc1-rgba-unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc1-rgba-unorm-srgb"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc2-rgba-unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc2-rgba-unorm-srgb"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc3-rgba-unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc3-rgba-unorm-srgb"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc4-r-snorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc4-r-unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc5-rg-snorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc5-rg-unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc6h-rgb-float"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc6h-rgb-ufloat"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc7-rgba-unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bc7-rgba-unorm-srgb"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="bgra8unorm"]
expected: FAIL
@ -123,39 +280,94 @@
expected: FAIL
[:format="depth16unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="depth24plus"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="depth24plus-stencil8"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="depth32float"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="depth32float-stencil8"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="eac-r11snorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="eac-r11unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="eac-rg11snorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="eac-rg11unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="etc2-rgb8a1unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="etc2-rgb8a1unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="etc2-rgb8unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="etc2-rgb8unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="etc2-rgba8unorm"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="etc2-rgba8unorm-srgb"]
expected:
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:format="r16float"]
expected: FAIL
@ -188,7 +400,12 @@
expected: FAIL
[:format="rg11b10ufloat"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="rg16float"]
expected: FAIL
@ -221,13 +438,28 @@
expected: FAIL
[:format="rgb10a2uint"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="rgb10a2unorm"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="rgb9e5ufloat"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[:format="rgba16float"]
expected: FAIL
@ -239,13 +471,25 @@
expected: FAIL
[:format="rgba32float"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux": FAIL
if os == "mac": FAIL
[:format="rgba32sint"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux": FAIL
if os == "mac": FAIL
[:format="rgba32uint"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux": FAIL
if os == "mac": FAIL
[:format="rgba8sint"]
expected: FAIL
@ -263,7 +507,12 @@
expected: FAIL
[:format="stencil8"]
expected: FAIL
expected:
if os == "win" and debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: FAIL
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": FAIL
[cts.https.html?q=webgpu:api,validation,queue,copyToTexture,CopyExternalImageToTexture:destination_texture,mipLevel:*]

106
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/render_pass/render_pass_descriptor/cts.https.html.ini
View File

@ -35,21 +35,20 @@
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:attachments,mip_level_count:*]
implementation-status: backlog
expected:
if os == "mac" and not debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:mipLevelCount=1;baseMipLevel=0]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:mipLevelCount=1;baseMipLevel=3]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:mipLevelCount=2;baseMipLevel=0]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:attachments,one_color_attachment:*]
@ -74,41 +73,36 @@
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,depthSlice,bound_check:*]
implementation-status: backlog
expected:
if os == "mac" and debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:mipLevel=0]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:mipLevel=1]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:mipLevel=2]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:mipLevel=3]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:mipLevel=4]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,depthSlice,definedness:*]
@ -131,29 +125,37 @@
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,depthSlice,overlaps,diff_miplevel:*]
implementation-status: backlog
expected:
if os == "mac" and debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:sameMipLevel=false]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:sameMipLevel=true]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,depthSlice,overlaps,same_miplevel:*]
implementation-status: backlog
expected:
if os == "mac" and not debug: [OK, TIMEOUT]
[:sameDepthSlice=false]
expected: FAIL
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[:sameDepthSlice=true]
expected: FAIL
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,empty:*]
@ -365,17 +367,16 @@
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,limits,maxColorAttachments:*]
implementation-status: backlog
expected:
if os == "mac" and debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:colorAttachmentsCountVariant={"mult":1,"add":0}]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:colorAttachmentsCountVariant={"mult":1,"add":1}]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:color_attachments,non_multisampled:*]
@ -403,87 +404,84 @@
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:depth_stencil_attachment,depth_clear_value:*]
implementation-status: backlog
expected:
if os == "mac" and not debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:depthLoadOp="_undef_";depthClearValue="_undef_"]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="_undef_";depthClearValue=-1]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="_undef_";depthClearValue=0]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="_undef_";depthClearValue=0.5]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="_undef_";depthClearValue=1]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="_undef_";depthClearValue=1.5]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="clear";depthClearValue="_undef_"]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:depthLoadOp="clear";depthClearValue=-1]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:depthLoadOp="clear";depthClearValue=0]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="clear";depthClearValue=0.5]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="clear";depthClearValue=1]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="clear";depthClearValue=1.5]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[:depthLoadOp="load";depthClearValue="_undef_"]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="load";depthClearValue=-1]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="load";depthClearValue=0]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="load";depthClearValue=0.5]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="load";depthClearValue=1]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:depthLoadOp="load";depthClearValue=1.5]
expected:
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:depth_stencil_attachment,loadOp_storeOp_match_depthReadOnly_stencilReadOnly:*]
@ -527,13 +525,12 @@
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:depth_stencil_attachment,sample_counts_mismatch:*]
implementation-status: backlog
expected:
if os == "mac" and not debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: FAIL
if os == "mac" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:occlusionQuerySet,query_set_type:*]
@ -556,13 +553,12 @@
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,array_layer_count:*]
implementation-status: backlog
expected:
if os == "mac" and debug: [OK, TIMEOUT]
if os == "mac": [OK, TIMEOUT]
[:]
expected:
if os == "win": FAIL
if os == "linux": FAIL
if os == "mac" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and not debug: FAIL
if os == "mac": [FAIL, TIMEOUT, NOTRUN]
[cts.https.html?q=webgpu:api,validation,render_pass,render_pass_descriptor:resolveTarget,different_format:*]

102
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/api/validation/state/device_lost/destroy/cts.https.html.ini
View File

@ -1773,11 +1773,11 @@
[:format="r16uint";usageType="render";usageCopy="none";awaitLost=false]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:format="r16uint";usageType="render";usageCopy="none";awaitLost=true]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:format="r16uint";usageType="render";usageCopy="src";awaitLost=false]
expected:
@ -1797,11 +1797,11 @@
[:format="r16uint";usageType="texture";usageCopy="dst";awaitLost=false]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:format="r16uint";usageType="texture";usageCopy="dst";awaitLost=true]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:format="r16uint";usageType="texture";usageCopy="none";awaitLost=false]
@ -1809,17 +1809,17 @@
[:format="r16uint";usageType="texture";usageCopy="src";awaitLost=false]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:format="r16uint";usageType="texture";usageCopy="src";awaitLost=true]
[:format="r16uint";usageType="texture";usageCopy="src-dest";awaitLost=false]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:format="r16uint";usageType="texture";usageCopy="src-dest";awaitLost=true]
expected:
if os == "mac" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [PASS, TIMEOUT, NOTRUN]
[:format="r32float";usageType="render";usageCopy="dst";awaitLost=false]
expected:
@ -2121,32 +2121,32 @@
[:format="r32uint";usageType="storage";usageCopy="dst";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="dst";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="none";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="none";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="src";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="src";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="src-dest";awaitLost=false]
@ -2156,7 +2156,7 @@
[:format="r32uint";usageType="storage";usageCopy="src-dest";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="dst";awaitLost=false]
@ -2191,7 +2191,7 @@
[:format="r32uint";usageType="texture";usageCopy="src-dest";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="src-dest";awaitLost=true]
@ -2778,15 +2778,13 @@
[:format="rg32uint";usageType="storage";usageCopy="src";awaitLost=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux": [TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rg32uint";usageType="storage";usageCopy="src";awaitLost=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux": [TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
@ -5046,14 +5044,12 @@
[:format="r32float";usageType="texture";usageCopy="dst";awaitLost=false]
expected:
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32float";usageType="texture";usageCopy="dst";awaitLost=true]
expected:
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32float";usageType="texture";usageCopy="none";awaitLost=false]
@ -5068,26 +5064,22 @@
[:format="r32float";usageType="texture";usageCopy="src";awaitLost=false]
expected:
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32float";usageType="texture";usageCopy="src";awaitLost=true]
expected:
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32float";usageType="texture";usageCopy="src-dest";awaitLost=false]
expected:
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32float";usageType="texture";usageCopy="src-dest";awaitLost=true]
expected:
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32sint";usageType="render";usageCopy="dst";awaitLost=false]
@ -5252,32 +5244,32 @@
[:format="r32uint";usageType="storage";usageCopy="dst";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="dst";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="none";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="none";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="src";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="src";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="storage";usageCopy="src-dest";awaitLost=false]
@ -5292,42 +5284,42 @@
[:format="r32uint";usageType="texture";usageCopy="dst";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="dst";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="none";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="none";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="src";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="src";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="src-dest";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r32uint";usageType="texture";usageCopy="src-dest";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="r8sint";usageType="render";usageCopy="dst";awaitLost=false]
@ -5913,46 +5905,42 @@
[:format="rg32uint";usageType="texture";usageCopy="dst";awaitLost=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rg32uint";usageType="texture";usageCopy="dst";awaitLost=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rg32uint";usageType="texture";usageCopy="none";awaitLost=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rg32uint";usageType="texture";usageCopy="none";awaitLost=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rg32uint";usageType="texture";usageCopy="src";awaitLost=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rg32uint";usageType="texture";usageCopy="src";awaitLost=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "win": [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
@ -6237,12 +6225,12 @@
[:format="rgba16float";usageType="render";usageCopy="src-dest";awaitLost=false]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rgba16float";usageType="render";usageCopy="src-dest";awaitLost=true]
expected:
if os == "linux" and debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux": [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:format="rgba16float";usageType="storage";usageCopy="dst";awaitLost=false]

2
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/execution/expression/binary/f32_matrix_matrix_multiplication/cts.https.html.ini
View File

@ -182,6 +182,8 @@
[:inputSource="storage_rw";common_dim=4;x_rows=3;y_cols=2]
[:inputSource="storage_rw";common_dim=4;x_rows=3;y_cols=3]
expected:
if os == "win" and debug: [PASS, TIMEOUT, NOTRUN]
[:inputSource="storage_rw";common_dim=4;x_rows=3;y_cols=4]
expected:

8042
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/execution/expression/call/builtin/subgroupAdd/cts.https.html.ini Normal file
View File

File diff suppressed because it is too large Load Diff

8042
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/execution/expression/call/builtin/subgroupMul/cts.https.html.ini Normal file
View File

File diff suppressed because it is too large Load Diff

2
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/execution/memory_model/coherence/cts.https.html.ini
View File

@ -54,7 +54,7 @@
implementation-status:
if os == "win": backlog
expected:
if os == "win": CRASH
if os == "win" and not debug: CRASH
[:memType="atomic_storage";testType="inter_workgroup"]
[:memType="atomic_storage";testType="inter_workgroup";extraFlags="rmw_variant"]

8
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/execution/robust_access_vertex/cts.https.html.ini
View File

@ -321,15 +321,16 @@
[:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float32";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true]
expected:
if os == "linux" and debug: [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
[:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float32x2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false]
expected:
if os == "mac" and debug: [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float32x2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true]
expected:
if os == "mac" and debug: [PASS, FAIL]
if os == "mac": [PASS, FAIL]
[:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float32x2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false]
expected:
@ -344,6 +345,7 @@
[:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float32x2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false]
expected:
if os == "linux": [PASS, FAIL]
if os == "mac" and debug: [PASS, FAIL]
[:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float32x2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true]
expected:
@ -420,7 +422,7 @@
[:indexed=true;indirect=false;drawCallTestParameter="vertexCountInIndexBuffer";type="float32x2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false]
expected:
if os == "win" and debug: [PASS, FAIL]
if os == "win": [PASS, FAIL]
[:indexed=true;indirect=false;drawCallTestParameter="vertexCountInIndexBuffer";type="float32x2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true]

4
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/execution/shader_io/compute_builtins/cts.https.html.ini
View File

@ -8,7 +8,7 @@
[:method="mixed";dispatch="direct";groupSize={"x":3,"y":7,"z":5};numGroups={"x":13,"y":9,"z":11}]
expected:
if os == "linux" and debug: [PASS, FAIL]
if os == "linux": [PASS, FAIL]
[:method="mixed";dispatch="direct";groupSize={"x":8,"y":4,"z":2};numGroups={"x":1,"y":1,"z":1}]
expected:
@ -48,7 +48,7 @@
[:method="struct";dispatch="direct";groupSize={"x":1,"y":1,"z":1};numGroups={"x":1,"y":1,"z":1}]
expected:
if os == "linux" and not debug: [PASS, FAIL]
if os == "linux": [PASS, FAIL]
[:method="struct";dispatch="direct";groupSize={"x":1,"y":1,"z":1};numGroups={"x":8,"y":4,"z":2}]

966
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/quadBroadcast/cts.https.html.ini Normal file
View File

@ -0,0 +1,966 @@
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:data_type:*]
[:type="abstract-float"]
[:type="abstract-int"]
[:type="bool"]
[:type="f16"]
[:type="f32"]
[:type="i32"]
[:type="u32"]
[:type="vec2%3Cabstract-float%3E"]
[:type="vec2%3Cabstract-int%3E"]
[:type="vec2%3Cbool%3E"]
[:type="vec2%3Cf16%3E"]
[:type="vec2%3Cf32%3E"]
[:type="vec2%3Ci32%3E"]
[:type="vec2%3Cu32%3E"]
[:type="vec3%3Cabstract-float%3E"]
[:type="vec3%3Cabstract-int%3E"]
[:type="vec3%3Cbool%3E"]
[:type="vec3%3Cf16%3E"]
[:type="vec3%3Cf32%3E"]
[:type="vec3%3Ci32%3E"]
[:type="vec3%3Cu32%3E"]
[:type="vec4%3Cabstract-float%3E"]
[:type="vec4%3Cabstract-int%3E"]
[:type="vec4%3Cbool%3E"]
[:type="vec4%3Cf16%3E"]
[:type="vec4%3Cf32%3E"]
[:type="vec4%3Ci32%3E"]
[:type="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:early_eval:*]
[:stage="constant"]
[:stage="override"]
[:stage="runtime"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:id_constness:*]
[:value="const_decl"]
[:value="const_expr"]
[:value="const_literal"]
[:value="let_decl"]
[:value="override_decl"]
[:value="var_func_decl"]
[:value="var_priv_decl"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:id_type:*]
[:type="abstract-float"]
[:type="abstract-int"]
[:type="bool"]
[:type="f16"]
[:type="f32"]
[:type="i32"]
[:type="u32"]
[:type="vec2%3Cabstract-float%3E"]
[:type="vec2%3Cabstract-int%3E"]
[:type="vec2%3Cbool%3E"]
[:type="vec2%3Cf16%3E"]
[:type="vec2%3Cf32%3E"]
[:type="vec2%3Ci32%3E"]
[:type="vec2%3Cu32%3E"]
[:type="vec3%3Cabstract-float%3E"]
[:type="vec3%3Cabstract-int%3E"]
[:type="vec3%3Cbool%3E"]
[:type="vec3%3Cf16%3E"]
[:type="vec3%3Cf32%3E"]
[:type="vec3%3Ci32%3E"]
[:type="vec3%3Cu32%3E"]
[:type="vec4%3Cabstract-float%3E"]
[:type="vec4%3Cabstract-int%3E"]
[:type="vec4%3Cbool%3E"]
[:type="vec4%3Cf16%3E"]
[:type="vec4%3Cf32%3E"]
[:type="vec4%3Ci32%3E"]
[:type="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:must_use:*]
[:must_use=false]
[:must_use=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:requires_subgroups:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:requires_subgroups_f16:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:return_type:*]
[:dataType="bool";retType="bool"]
[:dataType="bool";retType="f16"]
[:dataType="bool";retType="f32"]
[:dataType="bool";retType="i32"]
[:dataType="bool";retType="u32"]
[:dataType="bool";retType="vec2%3Cbool%3E"]
[:dataType="bool";retType="vec2%3Cf16%3E"]
[:dataType="bool";retType="vec2%3Cf32%3E"]
[:dataType="bool";retType="vec2%3Ci32%3E"]
[:dataType="bool";retType="vec2%3Cu32%3E"]
[:dataType="bool";retType="vec3%3Cbool%3E"]
[:dataType="bool";retType="vec3%3Cf16%3E"]
[:dataType="bool";retType="vec3%3Cf32%3E"]
[:dataType="bool";retType="vec3%3Ci32%3E"]
[:dataType="bool";retType="vec3%3Cu32%3E"]
[:dataType="bool";retType="vec4%3Cbool%3E"]
[:dataType="bool";retType="vec4%3Cf16%3E"]
[:dataType="bool";retType="vec4%3Cf32%3E"]
[:dataType="bool";retType="vec4%3Ci32%3E"]
[:dataType="bool";retType="vec4%3Cu32%3E"]
[:dataType="f16";retType="bool"]
[:dataType="f16";retType="f16"]
[:dataType="f16";retType="f32"]
[:dataType="f16";retType="i32"]
[:dataType="f16";retType="u32"]
[:dataType="f16";retType="vec2%3Cbool%3E"]
[:dataType="f16";retType="vec2%3Cf16%3E"]
[:dataType="f16";retType="vec2%3Cf32%3E"]
[:dataType="f16";retType="vec2%3Ci32%3E"]
[:dataType="f16";retType="vec2%3Cu32%3E"]
[:dataType="f16";retType="vec3%3Cbool%3E"]
[:dataType="f16";retType="vec3%3Cf16%3E"]
[:dataType="f16";retType="vec3%3Cf32%3E"]
[:dataType="f16";retType="vec3%3Ci32%3E"]
[:dataType="f16";retType="vec3%3Cu32%3E"]
[:dataType="f16";retType="vec4%3Cbool%3E"]
[:dataType="f16";retType="vec4%3Cf16%3E"]
[:dataType="f16";retType="vec4%3Cf32%3E"]
[:dataType="f16";retType="vec4%3Ci32%3E"]
[:dataType="f16";retType="vec4%3Cu32%3E"]
[:dataType="f32";retType="bool"]
[:dataType="f32";retType="f16"]
[:dataType="f32";retType="f32"]
[:dataType="f32";retType="i32"]
[:dataType="f32";retType="u32"]
[:dataType="f32";retType="vec2%3Cbool%3E"]
[:dataType="f32";retType="vec2%3Cf16%3E"]
[:dataType="f32";retType="vec2%3Cf32%3E"]
[:dataType="f32";retType="vec2%3Ci32%3E"]
[:dataType="f32";retType="vec2%3Cu32%3E"]
[:dataType="f32";retType="vec3%3Cbool%3E"]
[:dataType="f32";retType="vec3%3Cf16%3E"]
[:dataType="f32";retType="vec3%3Cf32%3E"]
[:dataType="f32";retType="vec3%3Ci32%3E"]
[:dataType="f32";retType="vec3%3Cu32%3E"]
[:dataType="f32";retType="vec4%3Cbool%3E"]
[:dataType="f32";retType="vec4%3Cf16%3E"]
[:dataType="f32";retType="vec4%3Cf32%3E"]
[:dataType="f32";retType="vec4%3Ci32%3E"]
[:dataType="f32";retType="vec4%3Cu32%3E"]
[:dataType="i32";retType="bool"]
[:dataType="i32";retType="f16"]
[:dataType="i32";retType="f32"]
[:dataType="i32";retType="i32"]
[:dataType="i32";retType="u32"]
[:dataType="i32";retType="vec2%3Cbool%3E"]
[:dataType="i32";retType="vec2%3Cf16%3E"]
[:dataType="i32";retType="vec2%3Cf32%3E"]
[:dataType="i32";retType="vec2%3Ci32%3E"]
[:dataType="i32";retType="vec2%3Cu32%3E"]
[:dataType="i32";retType="vec3%3Cbool%3E"]
[:dataType="i32";retType="vec3%3Cf16%3E"]
[:dataType="i32";retType="vec3%3Cf32%3E"]
[:dataType="i32";retType="vec3%3Ci32%3E"]
[:dataType="i32";retType="vec3%3Cu32%3E"]
[:dataType="i32";retType="vec4%3Cbool%3E"]
[:dataType="i32";retType="vec4%3Cf16%3E"]
[:dataType="i32";retType="vec4%3Cf32%3E"]
[:dataType="i32";retType="vec4%3Ci32%3E"]
[:dataType="i32";retType="vec4%3Cu32%3E"]
[:dataType="u32";retType="bool"]
[:dataType="u32";retType="f16"]
[:dataType="u32";retType="f32"]
[:dataType="u32";retType="i32"]
[:dataType="u32";retType="u32"]
[:dataType="u32";retType="vec2%3Cbool%3E"]
[:dataType="u32";retType="vec2%3Cf16%3E"]
[:dataType="u32";retType="vec2%3Cf32%3E"]
[:dataType="u32";retType="vec2%3Ci32%3E"]
[:dataType="u32";retType="vec2%3Cu32%3E"]
[:dataType="u32";retType="vec3%3Cbool%3E"]
[:dataType="u32";retType="vec3%3Cf16%3E"]
[:dataType="u32";retType="vec3%3Cf32%3E"]
[:dataType="u32";retType="vec3%3Ci32%3E"]
[:dataType="u32";retType="vec3%3Cu32%3E"]
[:dataType="u32";retType="vec4%3Cbool%3E"]
[:dataType="u32";retType="vec4%3Cf16%3E"]
[:dataType="u32";retType="vec4%3Cf32%3E"]
[:dataType="u32";retType="vec4%3Ci32%3E"]
[:dataType="u32";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="bool"]
[:dataType="vec2%3Cbool%3E";retType="f16"]
[:dataType="vec2%3Cbool%3E";retType="f32"]
[:dataType="vec2%3Cbool%3E";retType="i32"]
[:dataType="vec2%3Cbool%3E";retType="u32"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="bool"]
[:dataType="vec2%3Cf16%3E";retType="f16"]
[:dataType="vec2%3Cf16%3E";retType="f32"]
[:dataType="vec2%3Cf16%3E";retType="i32"]
[:dataType="vec2%3Cf16%3E";retType="u32"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="bool"]
[:dataType="vec2%3Cf32%3E";retType="f16"]
[:dataType="vec2%3Cf32%3E";retType="f32"]
[:dataType="vec2%3Cf32%3E";retType="i32"]
[:dataType="vec2%3Cf32%3E";retType="u32"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="bool"]
[:dataType="vec2%3Ci32%3E";retType="f16"]
[:dataType="vec2%3Ci32%3E";retType="f32"]
[:dataType="vec2%3Ci32%3E";retType="i32"]
[:dataType="vec2%3Ci32%3E";retType="u32"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="bool"]
[:dataType="vec2%3Cu32%3E";retType="f16"]
[:dataType="vec2%3Cu32%3E";retType="f32"]
[:dataType="vec2%3Cu32%3E";retType="i32"]
[:dataType="vec2%3Cu32%3E";retType="u32"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="bool"]
[:dataType="vec3%3Cbool%3E";retType="f16"]
[:dataType="vec3%3Cbool%3E";retType="f32"]
[:dataType="vec3%3Cbool%3E";retType="i32"]
[:dataType="vec3%3Cbool%3E";retType="u32"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="bool"]
[:dataType="vec3%3Cf16%3E";retType="f16"]
[:dataType="vec3%3Cf16%3E";retType="f32"]
[:dataType="vec3%3Cf16%3E";retType="i32"]
[:dataType="vec3%3Cf16%3E";retType="u32"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="bool"]
[:dataType="vec3%3Cf32%3E";retType="f16"]
[:dataType="vec3%3Cf32%3E";retType="f32"]
[:dataType="vec3%3Cf32%3E";retType="i32"]
[:dataType="vec3%3Cf32%3E";retType="u32"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="bool"]
[:dataType="vec3%3Ci32%3E";retType="f16"]
[:dataType="vec3%3Ci32%3E";retType="f32"]
[:dataType="vec3%3Ci32%3E";retType="i32"]
[:dataType="vec3%3Ci32%3E";retType="u32"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="bool"]
[:dataType="vec3%3Cu32%3E";retType="f16"]
[:dataType="vec3%3Cu32%3E";retType="f32"]
[:dataType="vec3%3Cu32%3E";retType="i32"]
[:dataType="vec3%3Cu32%3E";retType="u32"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="bool"]
[:dataType="vec4%3Cbool%3E";retType="f16"]
[:dataType="vec4%3Cbool%3E";retType="f32"]
[:dataType="vec4%3Cbool%3E";retType="i32"]
[:dataType="vec4%3Cbool%3E";retType="u32"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="bool"]
[:dataType="vec4%3Cf16%3E";retType="f16"]
[:dataType="vec4%3Cf16%3E";retType="f32"]
[:dataType="vec4%3Cf16%3E";retType="i32"]
[:dataType="vec4%3Cf16%3E";retType="u32"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="bool"]
[:dataType="vec4%3Cf32%3E";retType="f16"]
[:dataType="vec4%3Cf32%3E";retType="f32"]
[:dataType="vec4%3Cf32%3E";retType="i32"]
[:dataType="vec4%3Cf32%3E";retType="u32"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="bool"]
[:dataType="vec4%3Ci32%3E";retType="f16"]
[:dataType="vec4%3Ci32%3E";retType="f32"]
[:dataType="vec4%3Ci32%3E";retType="i32"]
[:dataType="vec4%3Ci32%3E";retType="u32"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="bool"]
[:dataType="vec4%3Cu32%3E";retType="f16"]
[:dataType="vec4%3Cu32%3E";retType="f32"]
[:dataType="vec4%3Cu32%3E";retType="i32"]
[:dataType="vec4%3Cu32%3E";retType="u32"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,quadBroadcast:stage:*]
[:stage="compute"]
[:stage="fragment"]
[:stage="vertex"]

3612
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/quadSwap/cts.https.html.ini Normal file
View File

File diff suppressed because it is too large Load Diff

896
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupAdd/cts.https.html.ini Normal file
View File

@ -0,0 +1,896 @@
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAdd:data_type:*]
[:type="abstract-float"]
[:type="abstract-int"]
[:type="bool"]
[:type="f16"]
[:type="f32"]
[:type="i32"]
[:type="u32"]
[:type="vec2%3Cabstract-float%3E"]
[:type="vec2%3Cabstract-int%3E"]
[:type="vec2%3Cbool%3E"]
[:type="vec2%3Cf16%3E"]
[:type="vec2%3Cf32%3E"]
[:type="vec2%3Ci32%3E"]
[:type="vec2%3Cu32%3E"]
[:type="vec3%3Cabstract-float%3E"]
[:type="vec3%3Cabstract-int%3E"]
[:type="vec3%3Cbool%3E"]
[:type="vec3%3Cf16%3E"]
[:type="vec3%3Cf32%3E"]
[:type="vec3%3Ci32%3E"]
[:type="vec3%3Cu32%3E"]
[:type="vec4%3Cabstract-float%3E"]
[:type="vec4%3Cabstract-int%3E"]
[:type="vec4%3Cbool%3E"]
[:type="vec4%3Cf16%3E"]
[:type="vec4%3Cf32%3E"]
[:type="vec4%3Ci32%3E"]
[:type="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAdd:early_eval:*]
[:stage="constant"]
[:stage="override"]
[:stage="runtime"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAdd:invalid_types:*]
[:case="array_f32"]
[:case="array_u32"]
[:case="frexp_ret"]
[:case="ptr_func"]
[:case="ptr_priv"]
[:case="struct_s"]
[:case="struct_t"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAdd:must_use:*]
[:must_use=false]
[:must_use=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAdd:return_type:*]
[:dataType="bool";retType="bool"]
[:dataType="bool";retType="f16"]
[:dataType="bool";retType="f32"]
[:dataType="bool";retType="i32"]
[:dataType="bool";retType="u32"]
[:dataType="bool";retType="vec2%3Cbool%3E"]
[:dataType="bool";retType="vec2%3Cf16%3E"]
[:dataType="bool";retType="vec2%3Cf32%3E"]
[:dataType="bool";retType="vec2%3Ci32%3E"]
[:dataType="bool";retType="vec2%3Cu32%3E"]
[:dataType="bool";retType="vec3%3Cbool%3E"]
[:dataType="bool";retType="vec3%3Cf16%3E"]
[:dataType="bool";retType="vec3%3Cf32%3E"]
[:dataType="bool";retType="vec3%3Ci32%3E"]
[:dataType="bool";retType="vec3%3Cu32%3E"]
[:dataType="bool";retType="vec4%3Cbool%3E"]
[:dataType="bool";retType="vec4%3Cf16%3E"]
[:dataType="bool";retType="vec4%3Cf32%3E"]
[:dataType="bool";retType="vec4%3Ci32%3E"]
[:dataType="bool";retType="vec4%3Cu32%3E"]
[:dataType="f16";retType="bool"]
[:dataType="f16";retType="f16"]
[:dataType="f16";retType="f32"]
[:dataType="f16";retType="i32"]
[:dataType="f16";retType="u32"]
[:dataType="f16";retType="vec2%3Cbool%3E"]
[:dataType="f16";retType="vec2%3Cf16%3E"]
[:dataType="f16";retType="vec2%3Cf32%3E"]
[:dataType="f16";retType="vec2%3Ci32%3E"]
[:dataType="f16";retType="vec2%3Cu32%3E"]
[:dataType="f16";retType="vec3%3Cbool%3E"]
[:dataType="f16";retType="vec3%3Cf16%3E"]
[:dataType="f16";retType="vec3%3Cf32%3E"]
[:dataType="f16";retType="vec3%3Ci32%3E"]
[:dataType="f16";retType="vec3%3Cu32%3E"]
[:dataType="f16";retType="vec4%3Cbool%3E"]
[:dataType="f16";retType="vec4%3Cf16%3E"]
[:dataType="f16";retType="vec4%3Cf32%3E"]
[:dataType="f16";retType="vec4%3Ci32%3E"]
[:dataType="f16";retType="vec4%3Cu32%3E"]
[:dataType="f32";retType="bool"]
[:dataType="f32";retType="f16"]
[:dataType="f32";retType="f32"]
[:dataType="f32";retType="i32"]
[:dataType="f32";retType="u32"]
[:dataType="f32";retType="vec2%3Cbool%3E"]
[:dataType="f32";retType="vec2%3Cf16%3E"]
[:dataType="f32";retType="vec2%3Cf32%3E"]
[:dataType="f32";retType="vec2%3Ci32%3E"]
[:dataType="f32";retType="vec2%3Cu32%3E"]
[:dataType="f32";retType="vec3%3Cbool%3E"]
[:dataType="f32";retType="vec3%3Cf16%3E"]
[:dataType="f32";retType="vec3%3Cf32%3E"]
[:dataType="f32";retType="vec3%3Ci32%3E"]
[:dataType="f32";retType="vec3%3Cu32%3E"]
[:dataType="f32";retType="vec4%3Cbool%3E"]
[:dataType="f32";retType="vec4%3Cf16%3E"]
[:dataType="f32";retType="vec4%3Cf32%3E"]
[:dataType="f32";retType="vec4%3Ci32%3E"]
[:dataType="f32";retType="vec4%3Cu32%3E"]
[:dataType="i32";retType="bool"]
[:dataType="i32";retType="f16"]
[:dataType="i32";retType="f32"]
[:dataType="i32";retType="i32"]
[:dataType="i32";retType="u32"]
[:dataType="i32";retType="vec2%3Cbool%3E"]
[:dataType="i32";retType="vec2%3Cf16%3E"]
[:dataType="i32";retType="vec2%3Cf32%3E"]
[:dataType="i32";retType="vec2%3Ci32%3E"]
[:dataType="i32";retType="vec2%3Cu32%3E"]
[:dataType="i32";retType="vec3%3Cbool%3E"]
[:dataType="i32";retType="vec3%3Cf16%3E"]
[:dataType="i32";retType="vec3%3Cf32%3E"]
[:dataType="i32";retType="vec3%3Ci32%3E"]
[:dataType="i32";retType="vec3%3Cu32%3E"]
[:dataType="i32";retType="vec4%3Cbool%3E"]
[:dataType="i32";retType="vec4%3Cf16%3E"]
[:dataType="i32";retType="vec4%3Cf32%3E"]
[:dataType="i32";retType="vec4%3Ci32%3E"]
[:dataType="i32";retType="vec4%3Cu32%3E"]
[:dataType="u32";retType="bool"]
[:dataType="u32";retType="f16"]
[:dataType="u32";retType="f32"]
[:dataType="u32";retType="i32"]
[:dataType="u32";retType="u32"]
[:dataType="u32";retType="vec2%3Cbool%3E"]
[:dataType="u32";retType="vec2%3Cf16%3E"]
[:dataType="u32";retType="vec2%3Cf32%3E"]
[:dataType="u32";retType="vec2%3Ci32%3E"]
[:dataType="u32";retType="vec2%3Cu32%3E"]
[:dataType="u32";retType="vec3%3Cbool%3E"]
[:dataType="u32";retType="vec3%3Cf16%3E"]
[:dataType="u32";retType="vec3%3Cf32%3E"]
[:dataType="u32";retType="vec3%3Ci32%3E"]
[:dataType="u32";retType="vec3%3Cu32%3E"]
[:dataType="u32";retType="vec4%3Cbool%3E"]
[:dataType="u32";retType="vec4%3Cf16%3E"]
[:dataType="u32";retType="vec4%3Cf32%3E"]
[:dataType="u32";retType="vec4%3Ci32%3E"]
[:dataType="u32";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="bool"]
[:dataType="vec2%3Cbool%3E";retType="f16"]
[:dataType="vec2%3Cbool%3E";retType="f32"]
[:dataType="vec2%3Cbool%3E";retType="i32"]
[:dataType="vec2%3Cbool%3E";retType="u32"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="bool"]
[:dataType="vec2%3Cf16%3E";retType="f16"]
[:dataType="vec2%3Cf16%3E";retType="f32"]
[:dataType="vec2%3Cf16%3E";retType="i32"]
[:dataType="vec2%3Cf16%3E";retType="u32"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="bool"]
[:dataType="vec2%3Cf32%3E";retType="f16"]
[:dataType="vec2%3Cf32%3E";retType="f32"]
[:dataType="vec2%3Cf32%3E";retType="i32"]
[:dataType="vec2%3Cf32%3E";retType="u32"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="bool"]
[:dataType="vec2%3Ci32%3E";retType="f16"]
[:dataType="vec2%3Ci32%3E";retType="f32"]
[:dataType="vec2%3Ci32%3E";retType="i32"]
[:dataType="vec2%3Ci32%3E";retType="u32"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="bool"]
[:dataType="vec2%3Cu32%3E";retType="f16"]
[:dataType="vec2%3Cu32%3E";retType="f32"]
[:dataType="vec2%3Cu32%3E";retType="i32"]
[:dataType="vec2%3Cu32%3E";retType="u32"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="bool"]
[:dataType="vec3%3Cbool%3E";retType="f16"]
[:dataType="vec3%3Cbool%3E";retType="f32"]
[:dataType="vec3%3Cbool%3E";retType="i32"]
[:dataType="vec3%3Cbool%3E";retType="u32"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="bool"]
[:dataType="vec3%3Cf16%3E";retType="f16"]
[:dataType="vec3%3Cf16%3E";retType="f32"]
[:dataType="vec3%3Cf16%3E";retType="i32"]
[:dataType="vec3%3Cf16%3E";retType="u32"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="bool"]
[:dataType="vec3%3Cf32%3E";retType="f16"]
[:dataType="vec3%3Cf32%3E";retType="f32"]
[:dataType="vec3%3Cf32%3E";retType="i32"]
[:dataType="vec3%3Cf32%3E";retType="u32"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="bool"]
[:dataType="vec3%3Ci32%3E";retType="f16"]
[:dataType="vec3%3Ci32%3E";retType="f32"]
[:dataType="vec3%3Ci32%3E";retType="i32"]
[:dataType="vec3%3Ci32%3E";retType="u32"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="bool"]
[:dataType="vec3%3Cu32%3E";retType="f16"]
[:dataType="vec3%3Cu32%3E";retType="f32"]
[:dataType="vec3%3Cu32%3E";retType="i32"]
[:dataType="vec3%3Cu32%3E";retType="u32"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="bool"]
[:dataType="vec4%3Cbool%3E";retType="f16"]
[:dataType="vec4%3Cbool%3E";retType="f32"]
[:dataType="vec4%3Cbool%3E";retType="i32"]
[:dataType="vec4%3Cbool%3E";retType="u32"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="bool"]
[:dataType="vec4%3Cf16%3E";retType="f16"]
[:dataType="vec4%3Cf16%3E";retType="f32"]
[:dataType="vec4%3Cf16%3E";retType="i32"]
[:dataType="vec4%3Cf16%3E";retType="u32"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="bool"]
[:dataType="vec4%3Cf32%3E";retType="f16"]
[:dataType="vec4%3Cf32%3E";retType="f32"]
[:dataType="vec4%3Cf32%3E";retType="i32"]
[:dataType="vec4%3Cf32%3E";retType="u32"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="bool"]
[:dataType="vec4%3Ci32%3E";retType="f16"]
[:dataType="vec4%3Ci32%3E";retType="f32"]
[:dataType="vec4%3Ci32%3E";retType="i32"]
[:dataType="vec4%3Ci32%3E";retType="u32"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="bool"]
[:dataType="vec4%3Cu32%3E";retType="f16"]
[:dataType="vec4%3Cu32%3E";retType="f32"]
[:dataType="vec4%3Cu32%3E";retType="i32"]
[:dataType="vec4%3Cu32%3E";retType="u32"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAdd:stage:*]
[:stage="compute"]
[:stage="fragment"]
[:stage="vertex"]

242
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupAnyAll/cts.https.html.ini Normal file
View File

@ -0,0 +1,242 @@
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:data_type:*]
[:type="abstract-float";op="subgroupAll"]
[:type="abstract-float";op="subgroupAny"]
[:type="abstract-int";op="subgroupAll"]
[:type="abstract-int";op="subgroupAny"]
[:type="bool";op="subgroupAll"]
[:type="bool";op="subgroupAny"]
[:type="f16";op="subgroupAll"]
[:type="f16";op="subgroupAny"]
[:type="f32";op="subgroupAll"]
[:type="f32";op="subgroupAny"]
[:type="i32";op="subgroupAll"]
[:type="i32";op="subgroupAny"]
[:type="u32";op="subgroupAll"]
[:type="u32";op="subgroupAny"]
[:type="vec2%3Cabstract-float%3E";op="subgroupAll"]
[:type="vec2%3Cabstract-float%3E";op="subgroupAny"]
[:type="vec2%3Cabstract-int%3E";op="subgroupAll"]
[:type="vec2%3Cabstract-int%3E";op="subgroupAny"]
[:type="vec2%3Cbool%3E";op="subgroupAll"]
[:type="vec2%3Cbool%3E";op="subgroupAny"]
[:type="vec2%3Cf16%3E";op="subgroupAll"]
[:type="vec2%3Cf16%3E";op="subgroupAny"]
[:type="vec2%3Cf32%3E";op="subgroupAll"]
[:type="vec2%3Cf32%3E";op="subgroupAny"]
[:type="vec2%3Ci32%3E";op="subgroupAll"]
[:type="vec2%3Ci32%3E";op="subgroupAny"]
[:type="vec2%3Cu32%3E";op="subgroupAll"]
[:type="vec2%3Cu32%3E";op="subgroupAny"]
[:type="vec3%3Cabstract-float%3E";op="subgroupAll"]
[:type="vec3%3Cabstract-float%3E";op="subgroupAny"]
[:type="vec3%3Cabstract-int%3E";op="subgroupAll"]
[:type="vec3%3Cabstract-int%3E";op="subgroupAny"]
[:type="vec3%3Cbool%3E";op="subgroupAll"]
[:type="vec3%3Cbool%3E";op="subgroupAny"]
[:type="vec3%3Cf16%3E";op="subgroupAll"]
[:type="vec3%3Cf16%3E";op="subgroupAny"]
[:type="vec3%3Cf32%3E";op="subgroupAll"]
[:type="vec3%3Cf32%3E";op="subgroupAny"]
[:type="vec3%3Ci32%3E";op="subgroupAll"]
[:type="vec3%3Ci32%3E";op="subgroupAny"]
[:type="vec3%3Cu32%3E";op="subgroupAll"]
[:type="vec3%3Cu32%3E";op="subgroupAny"]
[:type="vec4%3Cabstract-float%3E";op="subgroupAll"]
[:type="vec4%3Cabstract-float%3E";op="subgroupAny"]
[:type="vec4%3Cabstract-int%3E";op="subgroupAll"]
[:type="vec4%3Cabstract-int%3E";op="subgroupAny"]
[:type="vec4%3Cbool%3E";op="subgroupAll"]
[:type="vec4%3Cbool%3E";op="subgroupAny"]
[:type="vec4%3Cf16%3E";op="subgroupAll"]
[:type="vec4%3Cf16%3E";op="subgroupAny"]
[:type="vec4%3Cf32%3E";op="subgroupAll"]
[:type="vec4%3Cf32%3E";op="subgroupAny"]
[:type="vec4%3Ci32%3E";op="subgroupAll"]
[:type="vec4%3Ci32%3E";op="subgroupAny"]
[:type="vec4%3Cu32%3E";op="subgroupAll"]
[:type="vec4%3Cu32%3E";op="subgroupAny"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:early_eval:*]
[:stage="constant";op="subgroupAll"]
[:stage="constant";op="subgroupAny"]
[:stage="override";op="subgroupAll"]
[:stage="override";op="subgroupAny"]
[:stage="runtime";op="subgroupAll"]
[:stage="runtime";op="subgroupAny"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:must_use:*]
[:must_use=false;op="subgroupAll"]
[:must_use=false;op="subgroupAny"]
[:must_use=true;op="subgroupAll"]
[:must_use=true;op="subgroupAny"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:requires_subgroups:*]
[:enable=false;op="subgroupAll"]
[:enable=false;op="subgroupAny"]
[:enable=true;op="subgroupAll"]
[:enable=true;op="subgroupAny"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:return_type:*]
[:type="bool";op="subgroupAll"]
[:type="bool";op="subgroupAny"]
[:type="f16";op="subgroupAll"]
[:type="f16";op="subgroupAny"]
[:type="f32";op="subgroupAll"]
[:type="f32";op="subgroupAny"]
[:type="i32";op="subgroupAll"]
[:type="i32";op="subgroupAny"]
[:type="u32";op="subgroupAll"]
[:type="u32";op="subgroupAny"]
[:type="vec2%3Cbool%3E";op="subgroupAll"]
[:type="vec2%3Cbool%3E";op="subgroupAny"]
[:type="vec2%3Cf16%3E";op="subgroupAll"]
[:type="vec2%3Cf16%3E";op="subgroupAny"]
[:type="vec2%3Cf32%3E";op="subgroupAll"]
[:type="vec2%3Cf32%3E";op="subgroupAny"]
[:type="vec2%3Ci32%3E";op="subgroupAll"]
[:type="vec2%3Ci32%3E";op="subgroupAny"]
[:type="vec2%3Cu32%3E";op="subgroupAll"]
[:type="vec2%3Cu32%3E";op="subgroupAny"]
[:type="vec3%3Cbool%3E";op="subgroupAll"]
[:type="vec3%3Cbool%3E";op="subgroupAny"]
[:type="vec3%3Cf16%3E";op="subgroupAll"]
[:type="vec3%3Cf16%3E";op="subgroupAny"]
[:type="vec3%3Cf32%3E";op="subgroupAll"]
[:type="vec3%3Cf32%3E";op="subgroupAny"]
[:type="vec3%3Ci32%3E";op="subgroupAll"]
[:type="vec3%3Ci32%3E";op="subgroupAny"]
[:type="vec3%3Cu32%3E";op="subgroupAll"]
[:type="vec3%3Cu32%3E";op="subgroupAny"]
[:type="vec4%3Cbool%3E";op="subgroupAll"]
[:type="vec4%3Cbool%3E";op="subgroupAny"]
[:type="vec4%3Cf16%3E";op="subgroupAll"]
[:type="vec4%3Cf16%3E";op="subgroupAny"]
[:type="vec4%3Cf32%3E";op="subgroupAll"]
[:type="vec4%3Cf32%3E";op="subgroupAny"]
[:type="vec4%3Ci32%3E";op="subgroupAll"]
[:type="vec4%3Ci32%3E";op="subgroupAny"]
[:type="vec4%3Cu32%3E";op="subgroupAll"]
[:type="vec4%3Cu32%3E";op="subgroupAny"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupAnyAll:stage:*]
[:stage="compute";op="subgroupAll"]
[:stage="compute";op="subgroupAny"]
[:stage="fragment";op="subgroupAll"]
[:stage="fragment";op="subgroupAny"]
[:stage="vertex";op="subgroupAll"]
[:stage="vertex";op="subgroupAny"]

12
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupBallot/cts.https.html.ini
View File

@ -64,6 +64,18 @@
[:stage="runtime"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBallot:must_use:*]
[:must_use=false]
[:must_use=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBallot:requires_subgroups:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBallot:return_type:*]
[:type="bool"]

3598
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupBitwise/cts.https.html.ini Normal file
View File

File diff suppressed because it is too large Load Diff

28
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupBroadcast/cts.https.html.ini
View File

@ -64,6 +64,22 @@
[:stage="runtime"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:id_constness:*]
[:value="const_decl"]
[:value="const_expr"]
[:value="const_literal"]
[:value="let_decl"]
[:value="override_decl"]
[:value="var_func_decl"]
[:value="var_priv_decl"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:id_type:*]
[:type="abstract-float"]
@ -128,6 +144,18 @@
[:must_use=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:requires_subgroups:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:requires_subgroups_f16:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcast:return_type:*]
[:dataType="bool";retType="bool"]

892
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupBroadcastFirst/cts.https.html.ini Normal file
View File

@ -0,0 +1,892 @@
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:data_type:*]
[:type="abstract-float"]
[:type="abstract-int"]
[:type="bool"]
[:type="f16"]
[:type="f32"]
[:type="i32"]
[:type="u32"]
[:type="vec2%3Cabstract-float%3E"]
[:type="vec2%3Cabstract-int%3E"]
[:type="vec2%3Cbool%3E"]
[:type="vec2%3Cf16%3E"]
[:type="vec2%3Cf32%3E"]
[:type="vec2%3Ci32%3E"]
[:type="vec2%3Cu32%3E"]
[:type="vec3%3Cabstract-float%3E"]
[:type="vec3%3Cabstract-int%3E"]
[:type="vec3%3Cbool%3E"]
[:type="vec3%3Cf16%3E"]
[:type="vec3%3Cf32%3E"]
[:type="vec3%3Ci32%3E"]
[:type="vec3%3Cu32%3E"]
[:type="vec4%3Cabstract-float%3E"]
[:type="vec4%3Cabstract-int%3E"]
[:type="vec4%3Cbool%3E"]
[:type="vec4%3Cf16%3E"]
[:type="vec4%3Cf32%3E"]
[:type="vec4%3Ci32%3E"]
[:type="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:early_eval:*]
[:stage="constant"]
[:stage="override"]
[:stage="runtime"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:must_use:*]
[:must_use=false]
[:must_use=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:requires_subgroups:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:requires_subgroups_f16:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:return_type:*]
[:dataType="bool";retType="bool"]
[:dataType="bool";retType="f16"]
[:dataType="bool";retType="f32"]
[:dataType="bool";retType="i32"]
[:dataType="bool";retType="u32"]
[:dataType="bool";retType="vec2%3Cbool%3E"]
[:dataType="bool";retType="vec2%3Cf16%3E"]
[:dataType="bool";retType="vec2%3Cf32%3E"]
[:dataType="bool";retType="vec2%3Ci32%3E"]
[:dataType="bool";retType="vec2%3Cu32%3E"]
[:dataType="bool";retType="vec3%3Cbool%3E"]
[:dataType="bool";retType="vec3%3Cf16%3E"]
[:dataType="bool";retType="vec3%3Cf32%3E"]
[:dataType="bool";retType="vec3%3Ci32%3E"]
[:dataType="bool";retType="vec3%3Cu32%3E"]
[:dataType="bool";retType="vec4%3Cbool%3E"]
[:dataType="bool";retType="vec4%3Cf16%3E"]
[:dataType="bool";retType="vec4%3Cf32%3E"]
[:dataType="bool";retType="vec4%3Ci32%3E"]
[:dataType="bool";retType="vec4%3Cu32%3E"]
[:dataType="f16";retType="bool"]
[:dataType="f16";retType="f16"]
[:dataType="f16";retType="f32"]
[:dataType="f16";retType="i32"]
[:dataType="f16";retType="u32"]
[:dataType="f16";retType="vec2%3Cbool%3E"]
[:dataType="f16";retType="vec2%3Cf16%3E"]
[:dataType="f16";retType="vec2%3Cf32%3E"]
[:dataType="f16";retType="vec2%3Ci32%3E"]
[:dataType="f16";retType="vec2%3Cu32%3E"]
[:dataType="f16";retType="vec3%3Cbool%3E"]
[:dataType="f16";retType="vec3%3Cf16%3E"]
[:dataType="f16";retType="vec3%3Cf32%3E"]
[:dataType="f16";retType="vec3%3Ci32%3E"]
[:dataType="f16";retType="vec3%3Cu32%3E"]
[:dataType="f16";retType="vec4%3Cbool%3E"]
[:dataType="f16";retType="vec4%3Cf16%3E"]
[:dataType="f16";retType="vec4%3Cf32%3E"]
[:dataType="f16";retType="vec4%3Ci32%3E"]
[:dataType="f16";retType="vec4%3Cu32%3E"]
[:dataType="f32";retType="bool"]
[:dataType="f32";retType="f16"]
[:dataType="f32";retType="f32"]
[:dataType="f32";retType="i32"]
[:dataType="f32";retType="u32"]
[:dataType="f32";retType="vec2%3Cbool%3E"]
[:dataType="f32";retType="vec2%3Cf16%3E"]
[:dataType="f32";retType="vec2%3Cf32%3E"]
[:dataType="f32";retType="vec2%3Ci32%3E"]
[:dataType="f32";retType="vec2%3Cu32%3E"]
[:dataType="f32";retType="vec3%3Cbool%3E"]
[:dataType="f32";retType="vec3%3Cf16%3E"]
[:dataType="f32";retType="vec3%3Cf32%3E"]
[:dataType="f32";retType="vec3%3Ci32%3E"]
[:dataType="f32";retType="vec3%3Cu32%3E"]
[:dataType="f32";retType="vec4%3Cbool%3E"]
[:dataType="f32";retType="vec4%3Cf16%3E"]
[:dataType="f32";retType="vec4%3Cf32%3E"]
[:dataType="f32";retType="vec4%3Ci32%3E"]
[:dataType="f32";retType="vec4%3Cu32%3E"]
[:dataType="i32";retType="bool"]
[:dataType="i32";retType="f16"]
[:dataType="i32";retType="f32"]
[:dataType="i32";retType="i32"]
[:dataType="i32";retType="u32"]
[:dataType="i32";retType="vec2%3Cbool%3E"]
[:dataType="i32";retType="vec2%3Cf16%3E"]
[:dataType="i32";retType="vec2%3Cf32%3E"]
[:dataType="i32";retType="vec2%3Ci32%3E"]
[:dataType="i32";retType="vec2%3Cu32%3E"]
[:dataType="i32";retType="vec3%3Cbool%3E"]
[:dataType="i32";retType="vec3%3Cf16%3E"]
[:dataType="i32";retType="vec3%3Cf32%3E"]
[:dataType="i32";retType="vec3%3Ci32%3E"]
[:dataType="i32";retType="vec3%3Cu32%3E"]
[:dataType="i32";retType="vec4%3Cbool%3E"]
[:dataType="i32";retType="vec4%3Cf16%3E"]
[:dataType="i32";retType="vec4%3Cf32%3E"]
[:dataType="i32";retType="vec4%3Ci32%3E"]
[:dataType="i32";retType="vec4%3Cu32%3E"]
[:dataType="u32";retType="bool"]
[:dataType="u32";retType="f16"]
[:dataType="u32";retType="f32"]
[:dataType="u32";retType="i32"]
[:dataType="u32";retType="u32"]
[:dataType="u32";retType="vec2%3Cbool%3E"]
[:dataType="u32";retType="vec2%3Cf16%3E"]
[:dataType="u32";retType="vec2%3Cf32%3E"]
[:dataType="u32";retType="vec2%3Ci32%3E"]
[:dataType="u32";retType="vec2%3Cu32%3E"]
[:dataType="u32";retType="vec3%3Cbool%3E"]
[:dataType="u32";retType="vec3%3Cf16%3E"]
[:dataType="u32";retType="vec3%3Cf32%3E"]
[:dataType="u32";retType="vec3%3Ci32%3E"]
[:dataType="u32";retType="vec3%3Cu32%3E"]
[:dataType="u32";retType="vec4%3Cbool%3E"]
[:dataType="u32";retType="vec4%3Cf16%3E"]
[:dataType="u32";retType="vec4%3Cf32%3E"]
[:dataType="u32";retType="vec4%3Ci32%3E"]
[:dataType="u32";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="bool"]
[:dataType="vec2%3Cbool%3E";retType="f16"]
[:dataType="vec2%3Cbool%3E";retType="f32"]
[:dataType="vec2%3Cbool%3E";retType="i32"]
[:dataType="vec2%3Cbool%3E";retType="u32"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="bool"]
[:dataType="vec2%3Cf16%3E";retType="f16"]
[:dataType="vec2%3Cf16%3E";retType="f32"]
[:dataType="vec2%3Cf16%3E";retType="i32"]
[:dataType="vec2%3Cf16%3E";retType="u32"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="bool"]
[:dataType="vec2%3Cf32%3E";retType="f16"]
[:dataType="vec2%3Cf32%3E";retType="f32"]
[:dataType="vec2%3Cf32%3E";retType="i32"]
[:dataType="vec2%3Cf32%3E";retType="u32"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="bool"]
[:dataType="vec2%3Ci32%3E";retType="f16"]
[:dataType="vec2%3Ci32%3E";retType="f32"]
[:dataType="vec2%3Ci32%3E";retType="i32"]
[:dataType="vec2%3Ci32%3E";retType="u32"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="bool"]
[:dataType="vec2%3Cu32%3E";retType="f16"]
[:dataType="vec2%3Cu32%3E";retType="f32"]
[:dataType="vec2%3Cu32%3E";retType="i32"]
[:dataType="vec2%3Cu32%3E";retType="u32"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="bool"]
[:dataType="vec3%3Cbool%3E";retType="f16"]
[:dataType="vec3%3Cbool%3E";retType="f32"]
[:dataType="vec3%3Cbool%3E";retType="i32"]
[:dataType="vec3%3Cbool%3E";retType="u32"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="bool"]
[:dataType="vec3%3Cf16%3E";retType="f16"]
[:dataType="vec3%3Cf16%3E";retType="f32"]
[:dataType="vec3%3Cf16%3E";retType="i32"]
[:dataType="vec3%3Cf16%3E";retType="u32"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="bool"]
[:dataType="vec3%3Cf32%3E";retType="f16"]
[:dataType="vec3%3Cf32%3E";retType="f32"]
[:dataType="vec3%3Cf32%3E";retType="i32"]
[:dataType="vec3%3Cf32%3E";retType="u32"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="bool"]
[:dataType="vec3%3Ci32%3E";retType="f16"]
[:dataType="vec3%3Ci32%3E";retType="f32"]
[:dataType="vec3%3Ci32%3E";retType="i32"]
[:dataType="vec3%3Ci32%3E";retType="u32"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="bool"]
[:dataType="vec3%3Cu32%3E";retType="f16"]
[:dataType="vec3%3Cu32%3E";retType="f32"]
[:dataType="vec3%3Cu32%3E";retType="i32"]
[:dataType="vec3%3Cu32%3E";retType="u32"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="bool"]
[:dataType="vec4%3Cbool%3E";retType="f16"]
[:dataType="vec4%3Cbool%3E";retType="f32"]
[:dataType="vec4%3Cbool%3E";retType="i32"]
[:dataType="vec4%3Cbool%3E";retType="u32"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="bool"]
[:dataType="vec4%3Cf16%3E";retType="f16"]
[:dataType="vec4%3Cf16%3E";retType="f32"]
[:dataType="vec4%3Cf16%3E";retType="i32"]
[:dataType="vec4%3Cf16%3E";retType="u32"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="bool"]
[:dataType="vec4%3Cf32%3E";retType="f16"]
[:dataType="vec4%3Cf32%3E";retType="f32"]
[:dataType="vec4%3Cf32%3E";retType="i32"]
[:dataType="vec4%3Cf32%3E";retType="u32"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="bool"]
[:dataType="vec4%3Ci32%3E";retType="f16"]
[:dataType="vec4%3Ci32%3E";retType="f32"]
[:dataType="vec4%3Ci32%3E";retType="i32"]
[:dataType="vec4%3Ci32%3E";retType="u32"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="bool"]
[:dataType="vec4%3Cu32%3E";retType="f16"]
[:dataType="vec4%3Cu32%3E";retType="f32"]
[:dataType="vec4%3Cu32%3E";retType="i32"]
[:dataType="vec4%3Cu32%3E";retType="u32"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupBroadcastFirst:stage:*]
[:stage="compute"]
[:stage="fragment"]
[:stage="vertex"]

126
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupElect/cts.https.html.ini Normal file
View File

@ -0,0 +1,126 @@
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupElect:data_type:*]
[:type="abstract-float"]
[:type="abstract-int"]
[:type="bool"]
[:type="f16"]
[:type="f32"]
[:type="i32"]
[:type="u32"]
[:type="vec2%3Cabstract-float%3E"]
[:type="vec2%3Cabstract-int%3E"]
[:type="vec2%3Cbool%3E"]
[:type="vec2%3Cf16%3E"]
[:type="vec2%3Cf32%3E"]
[:type="vec2%3Ci32%3E"]
[:type="vec2%3Cu32%3E"]
[:type="vec3%3Cabstract-float%3E"]
[:type="vec3%3Cabstract-int%3E"]
[:type="vec3%3Cbool%3E"]
[:type="vec3%3Cf16%3E"]
[:type="vec3%3Cf32%3E"]
[:type="vec3%3Ci32%3E"]
[:type="vec3%3Cu32%3E"]
[:type="vec4%3Cabstract-float%3E"]
[:type="vec4%3Cabstract-int%3E"]
[:type="vec4%3Cbool%3E"]
[:type="vec4%3Cf16%3E"]
[:type="vec4%3Cf32%3E"]
[:type="vec4%3Ci32%3E"]
[:type="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupElect:early_eval:*]
[:stage="constant"]
[:stage="override"]
[:stage="runtime"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupElect:must_use:*]
[:must_use=false]
[:must_use=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupElect:requires_subgroups:*]
[:enable=false]
[:enable=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupElect:return_type:*]
[:type="bool"]
[:type="f16"]
[:type="f32"]
[:type="i32"]
[:type="u32"]
[:type="vec2%3Cbool%3E"]
[:type="vec2%3Cf16%3E"]
[:type="vec2%3Cf32%3E"]
[:type="vec2%3Ci32%3E"]
[:type="vec2%3Cu32%3E"]
[:type="vec3%3Cbool%3E"]
[:type="vec3%3Cf16%3E"]
[:type="vec3%3Cf32%3E"]
[:type="vec3%3Ci32%3E"]
[:type="vec3%3Cu32%3E"]
[:type="vec4%3Cbool%3E"]
[:type="vec4%3Cf16%3E"]
[:type="vec4%3Cf32%3E"]
[:type="vec4%3Ci32%3E"]
[:type="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupElect:stage:*]
[:stage="compute"]
[:stage="fragment"]
[:stage="vertex"]

2412
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupMinMax/cts.https.html.ini Normal file
View File

File diff suppressed because it is too large Load Diff

896
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupMul/cts.https.html.ini Normal file
View File

@ -0,0 +1,896 @@
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupMul:data_type:*]
[:type="abstract-float"]
[:type="abstract-int"]
[:type="bool"]
[:type="f16"]
[:type="f32"]
[:type="i32"]
[:type="u32"]
[:type="vec2%3Cabstract-float%3E"]
[:type="vec2%3Cabstract-int%3E"]
[:type="vec2%3Cbool%3E"]
[:type="vec2%3Cf16%3E"]
[:type="vec2%3Cf32%3E"]
[:type="vec2%3Ci32%3E"]
[:type="vec2%3Cu32%3E"]
[:type="vec3%3Cabstract-float%3E"]
[:type="vec3%3Cabstract-int%3E"]
[:type="vec3%3Cbool%3E"]
[:type="vec3%3Cf16%3E"]
[:type="vec3%3Cf32%3E"]
[:type="vec3%3Ci32%3E"]
[:type="vec3%3Cu32%3E"]
[:type="vec4%3Cabstract-float%3E"]
[:type="vec4%3Cabstract-int%3E"]
[:type="vec4%3Cbool%3E"]
[:type="vec4%3Cf16%3E"]
[:type="vec4%3Cf32%3E"]
[:type="vec4%3Ci32%3E"]
[:type="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupMul:early_eval:*]
[:stage="constant"]
[:stage="override"]
[:stage="runtime"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupMul:invalid_types:*]
[:case="array_f32"]
[:case="array_u32"]
[:case="frexp_ret"]
[:case="ptr_func"]
[:case="ptr_priv"]
[:case="struct_s"]
[:case="struct_t"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupMul:must_use:*]
[:must_use=false]
[:must_use=true]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupMul:return_type:*]
[:dataType="bool";retType="bool"]
[:dataType="bool";retType="f16"]
[:dataType="bool";retType="f32"]
[:dataType="bool";retType="i32"]
[:dataType="bool";retType="u32"]
[:dataType="bool";retType="vec2%3Cbool%3E"]
[:dataType="bool";retType="vec2%3Cf16%3E"]
[:dataType="bool";retType="vec2%3Cf32%3E"]
[:dataType="bool";retType="vec2%3Ci32%3E"]
[:dataType="bool";retType="vec2%3Cu32%3E"]
[:dataType="bool";retType="vec3%3Cbool%3E"]
[:dataType="bool";retType="vec3%3Cf16%3E"]
[:dataType="bool";retType="vec3%3Cf32%3E"]
[:dataType="bool";retType="vec3%3Ci32%3E"]
[:dataType="bool";retType="vec3%3Cu32%3E"]
[:dataType="bool";retType="vec4%3Cbool%3E"]
[:dataType="bool";retType="vec4%3Cf16%3E"]
[:dataType="bool";retType="vec4%3Cf32%3E"]
[:dataType="bool";retType="vec4%3Ci32%3E"]
[:dataType="bool";retType="vec4%3Cu32%3E"]
[:dataType="f16";retType="bool"]
[:dataType="f16";retType="f16"]
[:dataType="f16";retType="f32"]
[:dataType="f16";retType="i32"]
[:dataType="f16";retType="u32"]
[:dataType="f16";retType="vec2%3Cbool%3E"]
[:dataType="f16";retType="vec2%3Cf16%3E"]
[:dataType="f16";retType="vec2%3Cf32%3E"]
[:dataType="f16";retType="vec2%3Ci32%3E"]
[:dataType="f16";retType="vec2%3Cu32%3E"]
[:dataType="f16";retType="vec3%3Cbool%3E"]
[:dataType="f16";retType="vec3%3Cf16%3E"]
[:dataType="f16";retType="vec3%3Cf32%3E"]
[:dataType="f16";retType="vec3%3Ci32%3E"]
[:dataType="f16";retType="vec3%3Cu32%3E"]
[:dataType="f16";retType="vec4%3Cbool%3E"]
[:dataType="f16";retType="vec4%3Cf16%3E"]
[:dataType="f16";retType="vec4%3Cf32%3E"]
[:dataType="f16";retType="vec4%3Ci32%3E"]
[:dataType="f16";retType="vec4%3Cu32%3E"]
[:dataType="f32";retType="bool"]
[:dataType="f32";retType="f16"]
[:dataType="f32";retType="f32"]
[:dataType="f32";retType="i32"]
[:dataType="f32";retType="u32"]
[:dataType="f32";retType="vec2%3Cbool%3E"]
[:dataType="f32";retType="vec2%3Cf16%3E"]
[:dataType="f32";retType="vec2%3Cf32%3E"]
[:dataType="f32";retType="vec2%3Ci32%3E"]
[:dataType="f32";retType="vec2%3Cu32%3E"]
[:dataType="f32";retType="vec3%3Cbool%3E"]
[:dataType="f32";retType="vec3%3Cf16%3E"]
[:dataType="f32";retType="vec3%3Cf32%3E"]
[:dataType="f32";retType="vec3%3Ci32%3E"]
[:dataType="f32";retType="vec3%3Cu32%3E"]
[:dataType="f32";retType="vec4%3Cbool%3E"]
[:dataType="f32";retType="vec4%3Cf16%3E"]
[:dataType="f32";retType="vec4%3Cf32%3E"]
[:dataType="f32";retType="vec4%3Ci32%3E"]
[:dataType="f32";retType="vec4%3Cu32%3E"]
[:dataType="i32";retType="bool"]
[:dataType="i32";retType="f16"]
[:dataType="i32";retType="f32"]
[:dataType="i32";retType="i32"]
[:dataType="i32";retType="u32"]
[:dataType="i32";retType="vec2%3Cbool%3E"]
[:dataType="i32";retType="vec2%3Cf16%3E"]
[:dataType="i32";retType="vec2%3Cf32%3E"]
[:dataType="i32";retType="vec2%3Ci32%3E"]
[:dataType="i32";retType="vec2%3Cu32%3E"]
[:dataType="i32";retType="vec3%3Cbool%3E"]
[:dataType="i32";retType="vec3%3Cf16%3E"]
[:dataType="i32";retType="vec3%3Cf32%3E"]
[:dataType="i32";retType="vec3%3Ci32%3E"]
[:dataType="i32";retType="vec3%3Cu32%3E"]
[:dataType="i32";retType="vec4%3Cbool%3E"]
[:dataType="i32";retType="vec4%3Cf16%3E"]
[:dataType="i32";retType="vec4%3Cf32%3E"]
[:dataType="i32";retType="vec4%3Ci32%3E"]
[:dataType="i32";retType="vec4%3Cu32%3E"]
[:dataType="u32";retType="bool"]
[:dataType="u32";retType="f16"]
[:dataType="u32";retType="f32"]
[:dataType="u32";retType="i32"]
[:dataType="u32";retType="u32"]
[:dataType="u32";retType="vec2%3Cbool%3E"]
[:dataType="u32";retType="vec2%3Cf16%3E"]
[:dataType="u32";retType="vec2%3Cf32%3E"]
[:dataType="u32";retType="vec2%3Ci32%3E"]
[:dataType="u32";retType="vec2%3Cu32%3E"]
[:dataType="u32";retType="vec3%3Cbool%3E"]
[:dataType="u32";retType="vec3%3Cf16%3E"]
[:dataType="u32";retType="vec3%3Cf32%3E"]
[:dataType="u32";retType="vec3%3Ci32%3E"]
[:dataType="u32";retType="vec3%3Cu32%3E"]
[:dataType="u32";retType="vec4%3Cbool%3E"]
[:dataType="u32";retType="vec4%3Cf16%3E"]
[:dataType="u32";retType="vec4%3Cf32%3E"]
[:dataType="u32";retType="vec4%3Ci32%3E"]
[:dataType="u32";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="bool"]
[:dataType="vec2%3Cbool%3E";retType="f16"]
[:dataType="vec2%3Cbool%3E";retType="f32"]
[:dataType="vec2%3Cbool%3E";retType="i32"]
[:dataType="vec2%3Cbool%3E";retType="u32"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="bool"]
[:dataType="vec2%3Cf16%3E";retType="f16"]
[:dataType="vec2%3Cf16%3E";retType="f32"]
[:dataType="vec2%3Cf16%3E";retType="i32"]
[:dataType="vec2%3Cf16%3E";retType="u32"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="bool"]
[:dataType="vec2%3Cf32%3E";retType="f16"]
[:dataType="vec2%3Cf32%3E";retType="f32"]
[:dataType="vec2%3Cf32%3E";retType="i32"]
[:dataType="vec2%3Cf32%3E";retType="u32"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="bool"]
[:dataType="vec2%3Ci32%3E";retType="f16"]
[:dataType="vec2%3Ci32%3E";retType="f32"]
[:dataType="vec2%3Ci32%3E";retType="i32"]
[:dataType="vec2%3Ci32%3E";retType="u32"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="bool"]
[:dataType="vec2%3Cu32%3E";retType="f16"]
[:dataType="vec2%3Cu32%3E";retType="f32"]
[:dataType="vec2%3Cu32%3E";retType="i32"]
[:dataType="vec2%3Cu32%3E";retType="u32"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec2%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="bool"]
[:dataType="vec3%3Cbool%3E";retType="f16"]
[:dataType="vec3%3Cbool%3E";retType="f32"]
[:dataType="vec3%3Cbool%3E";retType="i32"]
[:dataType="vec3%3Cbool%3E";retType="u32"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="bool"]
[:dataType="vec3%3Cf16%3E";retType="f16"]
[:dataType="vec3%3Cf16%3E";retType="f32"]
[:dataType="vec3%3Cf16%3E";retType="i32"]
[:dataType="vec3%3Cf16%3E";retType="u32"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="bool"]
[:dataType="vec3%3Cf32%3E";retType="f16"]
[:dataType="vec3%3Cf32%3E";retType="f32"]
[:dataType="vec3%3Cf32%3E";retType="i32"]
[:dataType="vec3%3Cf32%3E";retType="u32"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="bool"]
[:dataType="vec3%3Ci32%3E";retType="f16"]
[:dataType="vec3%3Ci32%3E";retType="f32"]
[:dataType="vec3%3Ci32%3E";retType="i32"]
[:dataType="vec3%3Ci32%3E";retType="u32"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="bool"]
[:dataType="vec3%3Cu32%3E";retType="f16"]
[:dataType="vec3%3Cu32%3E";retType="f32"]
[:dataType="vec3%3Cu32%3E";retType="i32"]
[:dataType="vec3%3Cu32%3E";retType="u32"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec3%3Cu32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="bool"]
[:dataType="vec4%3Cbool%3E";retType="f16"]
[:dataType="vec4%3Cbool%3E";retType="f32"]
[:dataType="vec4%3Cbool%3E";retType="i32"]
[:dataType="vec4%3Cbool%3E";retType="u32"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cbool%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="bool"]
[:dataType="vec4%3Cf16%3E";retType="f16"]
[:dataType="vec4%3Cf16%3E";retType="f32"]
[:dataType="vec4%3Cf16%3E";retType="i32"]
[:dataType="vec4%3Cf16%3E";retType="u32"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf16%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="bool"]
[:dataType="vec4%3Cf32%3E";retType="f16"]
[:dataType="vec4%3Cf32%3E";retType="f32"]
[:dataType="vec4%3Cf32%3E";retType="i32"]
[:dataType="vec4%3Cf32%3E";retType="u32"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cf32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="bool"]
[:dataType="vec4%3Ci32%3E";retType="f16"]
[:dataType="vec4%3Ci32%3E";retType="f32"]
[:dataType="vec4%3Ci32%3E";retType="i32"]
[:dataType="vec4%3Ci32%3E";retType="u32"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Ci32%3E";retType="vec4%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="bool"]
[:dataType="vec4%3Cu32%3E";retType="f16"]
[:dataType="vec4%3Cu32%3E";retType="f32"]
[:dataType="vec4%3Cu32%3E";retType="i32"]
[:dataType="vec4%3Cu32%3E";retType="u32"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec2%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec3%3Cu32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cbool%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf16%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cf32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Ci32%3E"]
[:dataType="vec4%3Cu32%3E";retType="vec4%3Cu32%3E"]
[cts.https.html?q=webgpu:shader,validation,expression,call,builtin,subgroupMul:stage:*]
[:stage="compute"]
[:stage="fragment"]
[:stage="vertex"]

5038
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/shader/validation/expression/call/builtin/subgroupShuffle/cts.https.html.ini Normal file
View File

File diff suppressed because it is too large Load Diff

64
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/web_platform/copyToTexture/ImageBitmap/cts.https.html.ini
View File

@ -1141,16 +1141,32 @@
if os == "mac": [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rg16float";dstPremultiplied=false]
expected: [TIMEOUT, NOTRUN]
expected:
if os == "win": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rg16float";dstPremultiplied=true]
expected: [TIMEOUT, NOTRUN]
expected:
if os == "win": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rg32float";dstPremultiplied=false]
expected: [TIMEOUT, NOTRUN]
expected:
if os == "win": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rg32float";dstPremultiplied=true]
expected: [TIMEOUT, NOTRUN]
expected:
if os == "win": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rg8unorm";dstPremultiplied=false]
expected:
@ -1185,10 +1201,18 @@
expected: [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rgba8unorm";dstPremultiplied=false]
expected: [TIMEOUT, NOTRUN]
expected:
if os == "win": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rgba8unorm";dstPremultiplied=true]
expected: [TIMEOUT, NOTRUN]
expected:
if os == "win": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac": [TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=false;dstFormat="rgba8unorm-srgb";dstPremultiplied=false]
expected: [TIMEOUT, NOTRUN]
@ -1234,6 +1258,7 @@
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=true;dstFormat="r16float";dstPremultiplied=true]
expected:
@ -1249,6 +1274,7 @@
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=true;dstFormat="r32float";dstPremultiplied=true]
expected:
@ -1256,6 +1282,7 @@
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=true;dstFormat="r8unorm";dstPremultiplied=false]
expected:
@ -1319,6 +1346,7 @@
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
if os == "mac" and not debug: [PASS, TIMEOUT, NOTRUN]
[:alpha="premultiply";orientation="flipY";colorSpaceConversion="none";srcFlipYInCopy=true;dstFormat="rgb10a2unorm";dstPremultiplied=false]
expected:
@ -1432,6 +1460,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="r16float";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1439,6 +1468,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="r16float";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1446,6 +1476,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="r32float";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1453,6 +1484,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="r32float";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1460,6 +1492,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="r8unorm";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1467,6 +1500,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="r8unorm";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1474,6 +1508,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rg16float";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1481,6 +1516,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rg16float";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1488,6 +1524,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rg32float";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1495,6 +1532,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rg32float";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1502,6 +1540,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rg8unorm";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1509,6 +1548,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rg8unorm";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1566,6 +1606,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rgba8unorm";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1573,6 +1614,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=false;dstFormat="rgba8unorm";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1610,6 +1652,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="bgra8unorm-srgb";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1617,6 +1660,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="bgra8unorm-srgb";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1708,7 +1752,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="rgb10a2unorm";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1717,7 +1761,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="rgb10a2unorm";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: FAIL
if os == "win" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [FAIL, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1726,6 +1770,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="rgba16float";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1733,6 +1778,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="rgba16float";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1740,6 +1786,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="rgba32float";dstPremultiplied=false]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]
@ -1747,6 +1794,7 @@
[:alpha="premultiply";orientation="none";colorSpaceConversion="default";srcFlipYInCopy=true;dstFormat="rgba32float";dstPremultiplied=true]
expected:
if os == "win" and debug: [TIMEOUT, NOTRUN]
if os == "win" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
if os == "mac" and debug: [TIMEOUT, NOTRUN]

9
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/web_platform/copyToTexture/canvas/cts.https.html.ini
View File

@ -1248,7 +1248,8 @@
[:canvasType="offscreen";contextName="webgl";dstColorFormat="rg8unorm";srcPremultiplied=false;dstAlphaMode="opaque";srcDoFlipYDuringCopy=false]
expected:
if os == "linux": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:canvasType="offscreen";contextName="webgl";dstColorFormat="rg8unorm";srcPremultiplied=false;dstAlphaMode="opaque";srcDoFlipYDuringCopy=true]
expected:
@ -1257,11 +1258,13 @@
[:canvasType="offscreen";contextName="webgl";dstColorFormat="rg8unorm";srcPremultiplied=false;dstAlphaMode="premultiplied";srcDoFlipYDuringCopy=false]
expected:
if os == "linux": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:canvasType="offscreen";contextName="webgl";dstColorFormat="rg8unorm";srcPremultiplied=false;dstAlphaMode="premultiplied";srcDoFlipYDuringCopy=true]
expected:
if os == "linux": [TIMEOUT, NOTRUN]
if os == "linux" and debug: [TIMEOUT, NOTRUN]
if os == "linux" and not debug: [PASS, TIMEOUT, NOTRUN]
[:canvasType="offscreen";contextName="webgl";dstColorFormat="rg8unorm";srcPremultiplied=true;dstAlphaMode="opaque";srcDoFlipYDuringCopy=false]
expected:

12
testing/web-platform/mozilla/meta/webgpu/cts/webgpu/web_platform/copyToTexture/image/cts.https.html.ini
View File

@ -81,10 +81,18 @@
expected: FAIL
[:srcDoFlipYDuringCopy=false;dstColorFormat="rgba16float";dstPremultiplied=false]
expected: FAIL
expected:
if os == "win": FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
if os == "mac": FAIL
[:srcDoFlipYDuringCopy=false;dstColorFormat="rgba16float";dstPremultiplied=true]
expected: FAIL
expected:
if os == "win": FAIL
if os == "linux" and debug: [FAIL, TIMEOUT, NOTRUN]
if os == "linux" and not debug: FAIL
if os == "mac": FAIL
[:srcDoFlipYDuringCopy=false;dstColorFormat="rgba32float";dstPremultiplied=false]
expected:

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/adapter/info.worker.js.ini
View File

@ -1,3 +0,0 @@
[info.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/adapter/requestAdapter.worker.js.ini
View File

@ -1,3 +0,0 @@
[requestAdapter.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/adapter/requestAdapterInfo.worker.js.ini
View File

@ -1,3 +0,0 @@
[requestAdapterInfo.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/adapter/requestDevice.worker.js.ini
View File

@ -1,3 +0,0 @@
[requestDevice.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/buffers/map.worker.js.ini
View File

@ -1,3 +0,0 @@
[map.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/buffers/map_ArrayBuffer.worker.js.ini
View File

@ -1,3 +0,0 @@
[map_ArrayBuffer.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/buffers/map_detach.worker.js.ini
View File

@ -1,3 +0,0 @@
[map_detach.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/buffers/map_oom.worker.js.ini
View File

@ -1,3 +0,0 @@
[map_oom.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/buffers/threading.worker.js.ini
View File

@ -1,3 +0,0 @@
[threading.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/basic.worker.js.ini
View File

@ -1,3 +0,0 @@
[basic.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/clearBuffer.worker.js.ini
View File

@ -1,3 +0,0 @@
[clearBuffer.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/copyBufferToBuffer.worker.js.ini
View File

@ -1,3 +0,0 @@
[copyBufferToBuffer.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/copyTextureToTexture.worker.js.ini
View File

@ -1,3 +0,0 @@
[copyTextureToTexture.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/image_copy.worker.js.ini
View File

@ -1,3 +0,0 @@
[image_copy.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/programmable/state_tracking.worker.js.ini
View File

@ -1,3 +0,0 @@
[state_tracking.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/queries/occlusionQuery.worker.js.ini
View File

@ -1,3 +0,0 @@
[occlusionQuery.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/render/dynamic_state.worker.js.ini
View File

@ -1,3 +0,0 @@
[dynamic_state.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/command_buffer/render/state_tracking.worker.js.ini
View File

@ -1,3 +0,0 @@
[state_tracking.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/compute/basic.worker.js.ini
View File

@ -1,3 +0,0 @@
[basic.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/compute_pipeline/entry_point_name.worker.js.ini
View File

@ -1,3 +0,0 @@
[entry_point_name.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/compute_pipeline/overrides.worker.js.ini
View File

@ -1,3 +0,0 @@
[overrides.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/device/lost.worker.js.ini
View File

@ -1,3 +0,0 @@
[lost.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/labels.worker.js.ini
View File

@ -1,3 +0,0 @@
[labels.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/memory_sync/buffer/multiple_buffers.worker.js.ini
View File

@ -1,3 +0,0 @@
[multiple_buffers.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/memory_sync/buffer/single_buffer.worker.js.ini
View File

@ -1,3 +0,0 @@
[single_buffer.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/memory_sync/texture/readonly_depth_stencil.worker.js.ini
View File

@ -1,3 +0,0 @@
[readonly_depth_stencil.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/memory_sync/texture/same_subresource.worker.js.ini
View File

@ -1,3 +0,0 @@
[same_subresource.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/onSubmittedWorkDone.worker.js.ini
View File

@ -1,3 +0,0 @@
[onSubmittedWorkDone.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/pipeline/default_layout.worker.js.ini
View File

@ -1,3 +0,0 @@
[default_layout.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/queue/writeBuffer.worker.js.ini
View File

@ -1,3 +0,0 @@
[writeBuffer.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/reflection.worker.js.ini
View File

@ -1,3 +0,0 @@
[reflection.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pass/clear_value.worker.js.ini
View File

@ -1,3 +0,0 @@
[clear_value.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pass/resolve.worker.js.ini
View File

@ -1,3 +0,0 @@
[resolve.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pass/storeOp.worker.js.ini
View File

@ -1,3 +0,0 @@
[storeOp.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pass/storeop2.worker.js.ini
View File

@ -1,3 +0,0 @@
[storeop2.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pipeline/culling_tests.worker.js.ini
View File

@ -1,3 +0,0 @@
[culling_tests.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pipeline/overrides.worker.js.ini
View File

@ -1,3 +0,0 @@
[overrides.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pipeline/pipeline_output_targets.worker.js.ini
View File

@ -1,3 +0,0 @@
[pipeline_output_targets.worker.html]
implementation-status: backlog
expected: SKIP

3
testing/web-platform/mozilla/meta/webgpu/cts/webworker/api/operation/render_pipeline/primitive_topology.worker.js.ini
View File

@ -1,3 +0,0 @@
[primitive_topology.worker.html]
implementation-status: backlog
expected: SKIP

Some files were not shown because too many files have changed in this diff Show More