Cold-Air-Networks/mirror-webgpu-cts
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

trackForCleanup all buffers and textures (#3821)

Browse source
This commit is contained in:
Kai Ninomiya 2024-06-27 16:03:07 -07:00 committed by GitHub
parent 7f49bfcbc7
commit 0e85eda95e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
190 changed files with 1357 additions and 1671 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
.eslintrc.json
View file

@ -43,6 +43,16 @@
// This selector disallows any call to any method called "createQuerySet"
// that is not directly inside a call to some method called "trackForCleanup".
"selector": ":not(CallExpression[callee.property.name=\"trackForCleanup\"]) > CallExpression > MemberExpression > Identifier[name=\"createQuerySet\"]"
},
{
"message": "createBuffer must be immediately tracked using trackForCleanup (or use createBufferTracked).",
// Similar to above.
"selector": ":not(CallExpression[callee.property.name=\"trackForCleanup\"]) > CallExpression > MemberExpression > Identifier[name=\"createBuffer\"]"
},
{
"message": "createTexture must be immediately tracked using trackForCleanup (or use createTextureTracked).",
// Similar to above.
"selector": ":not(CallExpression[callee.property.name=\"trackForCleanup\"]) > CallExpression > MemberExpression > Identifier[name=\"createTexture\"]"
}
],

1
docs/helper_index.txt
View file

@ -46,7 +46,6 @@ Whenever a new generally-useful helper is added, it should be indexed here.
- {@link webgpu/capability_info}: Structured information about texture formats, binding types, etc.
- {@link webgpu/constants}:
Constant values (needed anytime a WebGPU constant is needed outside of a test function).
- {@link webgpu/util/buffer}: Helpers for GPUBuffers.
- {@link webgpu/util/texture}: Helpers for GPUTextures.
- {@link webgpu/util/unions}: Helpers for various union typedefs in the WebGPU spec.
- {@link webgpu/util/math}: Helpers for common math operations.

50
src/stress/adapter/device_allocation.spec.ts
View file

@ -30,7 +30,7 @@ const kAdapterTypes = keysOf(kAdapterTypeOptions);
* queue. Does not submit the commands in order to make sure that all resources are
* kept alive until the device is destroyed.
*/
async function createDeviceAndComputeCommands(adapter: GPUAdapter) {
async function createDeviceAndComputeCommands(t: Fixture, adapter: GPUAdapter) {
// Constants are computed such that per run, this function should allocate roughly 2G
// worth of data. This should be sufficient as we run these creation functions many
// times. If the data backing the created objects is not recycled we should OOM.
@ -66,10 +66,12 @@ async function createDeviceAndComputeCommands(adapter: GPUAdapter) {
},
});
for (let bindgroupIndex = 0; bindgroupIndex < kNumBindgroups; ++bindgroupIndex) {
const buffer = device.createBuffer({
size: kBufferSize,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
});
const buffer = t.trackForCleanup(
device.createBuffer({
size: kBufferSize,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
})
);
device.queue.writeBuffer(buffer, 0, kBufferData, 0, kBufferData.length);
const bindgroup = device.createBindGroup({
layout: pipeline.getBindGroupLayout(0),
@ -97,7 +99,7 @@ async function createDeviceAndComputeCommands(adapter: GPUAdapter) {
* queue. Does not submit the commands in order to make sure that all resources are
* kept alive until the device is destroyed.
*/
async function createDeviceAndRenderCommands(adapter: GPUAdapter) {
async function createDeviceAndRenderCommands(t: Fixture, adapter: GPUAdapter) {
// Constants are computed such that per run, this function should allocate roughly 2G
// worth of data. This should be sufficient as we run these creation functions many
// times. If the data backing the created objects is not recycled we should OOM.
@ -154,20 +156,24 @@ async function createDeviceAndRenderCommands(adapter: GPUAdapter) {
},
});
for (let bindgroupIndex = 0; bindgroupIndex < kNumBindgroups; ++bindgroupIndex) {
const buffer = device.createBuffer({
size: kSize * kSize * 4,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
});
const buffer = t.trackForCleanup(
device.createBuffer({
size: kSize * kSize * 4,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
})
);
device.queue.writeBuffer(buffer, 0, kBufferData, 0, kBufferData.length);
const bindgroup = device.createBindGroup({
layout: pipeline.getBindGroupLayout(0),
entries: [{ binding: 0, resource: { buffer } }],
});
const texture = device.createTexture({
size: [kSize, kSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
});
const texture = t.trackForCleanup(
device.createTexture({
size: [kSize, kSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
})
);
const encoder = device.createCommandEncoder();
const pass = encoder.beginRenderPass({
@ -193,7 +199,7 @@ async function createDeviceAndRenderCommands(adapter: GPUAdapter) {
* Creates a device and a large number of buffers which are immediately written to. The
* buffers are expected to be kept alive until they or the device are destroyed.
*/
async function createDeviceAndBuffers(adapter: GPUAdapter) {
async function createDeviceAndBuffers(t: Fixture, adapter: GPUAdapter) {
// Currently we just allocate 2G of memory using 512MB blocks. We may be able to
// increase this to hit OOM instead, but on integrated GPUs on Metal, this can cause
// kernel panics at the moment, and it can greatly increase the time needed.
@ -204,10 +210,12 @@ async function createDeviceAndBuffers(adapter: GPUAdapter) {
const device: GPUDevice = await adapter.requestDevice();
const buffers = [];
for (let memory = 0; memory < kTotalMemorySize; memory += kMemoryBlockSize) {
const buffer = device.createBuffer({
size: kMemoryBlockSize,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
});
const buffer = t.trackForCleanup(
device.createBuffer({
size: kMemoryBlockSize,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
})
);
// Write out to the buffer to make sure that it has backing memory.
device.queue.writeBuffer(buffer, 0, kMemoryBlockData, 0, kMemoryBlockData.length);
@ -258,7 +266,7 @@ objects are recycled over a very large number of iterations.`
const deviceList = [];
const objectLists = [];
for (let i = 0; i < kNumDevices; ++i) {
const { device, objects } = await kFunctions[i % kFunctions.length](adapter);
const { device, objects } = await kFunctions[i % kFunctions.length](t, adapter);
t.expect(objects.length > 0, 'unable to allocate any objects');
deviceList.push(device);
objectLists.push(objects);

4
src/stress/device/bind_group_allocation.spec.ts
View file

@ -11,7 +11,7 @@ g.test('coexisting')
.desc(`Tests allocation of many coexisting GPUBindGroup objects.`)
.fn(t => {
const kNumGroups = 1_000_000;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 64,
usage: GPUBufferUsage.STORAGE,
});
@ -43,7 +43,7 @@ iterations.`
)
.fn(t => {
const kNumGroups = 5_000_000;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 64,
usage: GPUBufferUsage.STORAGE,
});

18
src/stress/memory/oom.spec.ts
View file

@ -11,7 +11,7 @@ import { exhaustVramUntilUnder64MB } from '../../webgpu/util/memory.js';
export const g = makeTestGroup(GPUTest);
function createBufferWithMapState(
device: GPUDevice,
t: GPUTest,
size: number,
mapState: GPUBufferMapState,
mode: GPUMapModeFlags,
@ -19,7 +19,7 @@ function createBufferWithMapState(
) {
const mappable = mapState === 'unmapped';
if (!mappable && !mappedAtCreation) {
return device.createBuffer({
return t.createBufferTracked({
size,
usage: GPUBufferUsage.UNIFORM,
mappedAtCreation,
@ -28,14 +28,14 @@ function createBufferWithMapState(
let buffer: GPUBuffer;
switch (mode) {
case GPUMapMode.READ:
buffer = device.createBuffer({
buffer = t.createBufferTracked({
size,
usage: GPUBufferUsage.MAP_READ,
mappedAtCreation,
});
break;
case GPUMapMode.WRITE:
buffer = device.createBuffer({
buffer = t.createBufferTracked({
size,
usage: GPUBufferUsage.MAP_WRITE,
mappedAtCreation,
@ -54,7 +54,7 @@ function createBufferWithMapState(
g.test('vram_oom')
.desc(`Tests that we can allocate buffers until we run out of VRAM.`)
.fn(async t => {
await exhaustVramUntilUnder64MB(t.device);
await exhaustVramUntilUnder64MB(t);
});
g.test('map_after_vram_oom')
@ -100,9 +100,7 @@ mapAsync on it should reject and produce a validation error. `
// this case, we don't do any validations on the OOM buffer.
try {
t.device.pushErrorScope('out-of-memory');
const buffer = t.trackForCleanup(
createBufferWithMapState(t.device, kSize, mapState, mode, mappedAtCreation)
);
const buffer = createBufferWithMapState(t, kSize, mapState, mode, mappedAtCreation);
if (await t.device.popErrorScope()) {
errorBuffer = buffer;
break;
@ -115,9 +113,7 @@ mapAsync on it should reject and produce a validation error. `
}
} else {
t.device.pushErrorScope('out-of-memory');
const buffer = t.trackForCleanup(
createBufferWithMapState(t.device, kSize, mapState, mode, mappedAtCreation)
);
const buffer = createBufferWithMapState(t, kSize, mapState, mode, mappedAtCreation);
if (await t.device.popErrorScope()) {
errorBuffer = buffer;
break;

14
src/stress/render/render_pass.spec.ts
View file

@ -40,7 +40,7 @@ a single render pass for every output fragment, with each pass executing a one-v
entryPoint: 'fmain',
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [kSize, kSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
@ -92,12 +92,12 @@ pass does a single draw call, with one pass per output fragment.`
}
`,
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [kWidth, kHeight],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
});
const depthTarget = t.device.createTexture({
const depthTarget = t.createTextureTracked({
size: [kWidth, kHeight],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
format: 'depth24plus-stencil8',
@ -194,7 +194,7 @@ buffer.`
entryPoint: 'fmain',
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [kSize, kSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
@ -212,7 +212,7 @@ buffer.`
const pass = encoder.beginRenderPass(renderPassDescriptor);
pass.setPipeline(pipeline);
range(kSize * kSize, i => {
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.UNIFORM,
mappedAtCreation: true,
@ -265,7 +265,7 @@ render pass with a single pipeline, and one draw call per fragment of the output
entryPoint: 'fmain',
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [kSize, kSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
@ -326,7 +326,7 @@ call which draws multiple vertices for each fragment of a large output texture.`
entryPoint: 'fmain',
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',

6
src/stress/render/vertex_buffers.spec.ts
View file

@ -9,7 +9,7 @@ export const g = makeTestGroup(GPUTest);
function createHugeVertexBuffer(t: GPUTest, size: number) {
const kBufferSize = size * size * 8;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: kBufferSize,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
});
@ -48,7 +48,7 @@ function createHugeVertexBuffer(t: GPUTest, size: number) {
pass.dispatchWorkgroups(size);
pass.end();
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
size: kBufferSize,
usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
});
@ -101,7 +101,7 @@ g.test('many')
entryPoint: 'fmain',
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [kSize, kSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',

4
src/stress/shaders/non_halting.spec.ts
View file

@ -97,7 +97,7 @@ device loss.`
},
],
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [1, 1],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
@ -169,7 +169,7 @@ device loss.`
},
],
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [1, 1],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',

4
src/stress/shaders/slow.spec.ts
View file

@ -89,7 +89,7 @@ g.test('vertex')
},
],
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [3, 3],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
@ -161,7 +161,7 @@ g.test('fragment')
},
],
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [3, 3],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',

26
src/webgpu/api/operation/adapter/requestAdapter.spec.ts
View file

@ -27,7 +27,7 @@ const powerPreferenceModes: Array<GPUPowerPreference | undefined> = [
];
const forceFallbackOptions: Array<boolean | undefined> = [undefined, false, true];
async function testAdapter(adapter: GPUAdapter | null) {
async function testAdapter(t: Fixture, adapter: GPUAdapter | null) {
assert(adapter !== null, 'Failed to get adapter.');
const device = await adapter.requestDevice();
@ -54,15 +54,19 @@ async function testAdapter(adapter: GPUAdapter | null) {
const kNumElements = 64;
const kBufferSize = kNumElements * 4;
const buffer = device.createBuffer({
size: kBufferSize,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
});
const buffer = t.trackForCleanup(
device.createBuffer({
size: kBufferSize,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
})
);
const resultBuffer = device.createBuffer({
size: kBufferSize,
usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
});
const resultBuffer = t.trackForCleanup(
device.createBuffer({
size: kBufferSize,
usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
})
);
const bindGroup = device.createBindGroup({
layout: pipeline.getBindGroupLayout(0),
@ -113,12 +117,12 @@ g.test('requestAdapter')
return;
}
await testAdapter(adapter);
await testAdapter(t, adapter);
});
g.test('requestAdapter_no_parameters')
.desc(`request adapter with no parameters`)
.fn(async t => {
const adapter = await getGPU(t.rec).requestAdapter();
await testAdapter(adapter);
await testAdapter(t, adapter);
});

16
src/webgpu/api/operation/buffers/map.spec.ts
View file

@ -85,7 +85,7 @@ g.test('mapAsync,write')
const { size, range } = t.params;
const [rangeOffset, rangeSize] = reifyMapRange(size, range);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
@ -123,7 +123,7 @@ second mapped range were not altered.`
const [rangeOffset1, rangeSize1] = reifyMapRange(size, range1);
const [rangeOffset2, rangeSize2] = reifyMapRange(size, range2);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
mappedAtCreation,
size,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
@ -186,7 +186,7 @@ map-read and check the read-back result.`
const { size, range } = t.params;
const [rangeOffset, rangeSize] = reifyMapRange(size, range);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
mappedAtCreation: true,
size,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
@ -265,7 +265,7 @@ g.test('mapAsync,read,typedArrayAccess')
float64Expected[3] = Number.MAX_VALUE;
float64Expected[4] = Number.MIN_VALUE;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
mappedAtCreation: true,
size,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
@ -306,7 +306,7 @@ then expectContents (which does copyBufferToBuffer + map-read) to ensure the con
const { size, range, mappable } = t.params;
const [, rangeSize] = reifyMapRange(size, range);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
mappedAtCreation: true,
size,
usage: GPUBufferUsage.COPY_SRC | (mappable ? GPUBufferUsage.MAP_WRITE : 0),
@ -333,7 +333,7 @@ still present in the mapped buffer.`
const { size, range, mappedAtCreation } = t.params;
const [rangeOffset, rangeSize] = reifyMapRange(size, range);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
mappedAtCreation,
size,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
@ -385,7 +385,7 @@ g.test('mappedAtCreation,mapState')
let buffer: GPUBuffer;
t.expectValidationError(() => {
buffer = t.device.createBuffer({
buffer = t.createBufferTracked({
mappedAtCreation: true,
size,
usage,
@ -437,7 +437,7 @@ g.test('mapAsync,mapState')
let buffer: GPUBuffer;
t.expectValidationError(() => {
buffer = t.device.createBuffer({
buffer = t.createBufferTracked({
mappedAtCreation: false,
size,
usage,

12
src/webgpu/api/operation/buffers/map_detach.spec.ts
View file

@ -52,11 +52,13 @@ g.test('while_mapped')
assert(adapter !== null);
device = await adapter.requestDevice();
}
const buffer = device.createBuffer({
size: 4,
usage,
mappedAtCreation,
});
const buffer = t.trackForCleanup(
device.createBuffer({
size: 4,
usage,
mappedAtCreation,
})
);
if (mapMode !== undefined) {
if (mappedAtCreation) {

2
src/webgpu/api/operation/buffers/map_oom.spec.ts
View file

@ -34,7 +34,7 @@ g.test('mappedAtCreation')
.fn(t => {
const { oom, usage, size } = t.params;
const f = () => t.device.createBuffer({ mappedAtCreation: true, size, usage });
const f = () => t.createBufferTracked({ mappedAtCreation: true, size, usage });
if (oom) {
// getMappedRange is normally valid on OOM buffers, but this one fails because the

14
src/webgpu/api/operation/command_buffer/basic.spec.ts
View file

@ -17,7 +17,7 @@ g.test('empty').fn(t => {
g.test('b2t2b').fn(t => {
const data = new Uint32Array([0x01020304]);
const src = t.device.createBuffer({
const src = t.createBufferTracked({
mappedAtCreation: true,
size: 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
@ -25,12 +25,12 @@ g.test('b2t2b').fn(t => {
memcpy({ src: data }, { dst: src.getMappedRange() });
src.unmap();
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
const mid = t.device.createTexture({
const mid = t.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'rgba8uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
@ -55,7 +55,7 @@ g.test('b2t2b').fn(t => {
g.test('b2t2t2b').fn(t => {
const data = new Uint32Array([0x01020304]);
const src = t.device.createBuffer({
const src = t.createBufferTracked({
mappedAtCreation: true,
size: 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
@ -63,7 +63,7 @@ g.test('b2t2t2b').fn(t => {
memcpy({ src: data }, { dst: src.getMappedRange() });
src.unmap();
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
@ -73,8 +73,8 @@ g.test('b2t2t2b').fn(t => {
format: 'rgba8uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
};
const mid1 = t.device.createTexture(midDesc);
const mid2 = t.device.createTexture(midDesc);
const mid1 = t.createTextureTracked(midDesc);
const mid2 = t.createTextureTracked(midDesc);
const encoder = t.device.createCommandEncoder();
encoder.copyBufferToTexture(

6
src/webgpu/api/operation/command_buffer/copyBufferToBuffer.spec.ts
View file

@ -34,11 +34,10 @@ g.test('single')
const src = t.makeBufferWithContents(srcData, GPUBufferUsage.COPY_SRC);
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: dstBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
t.trackForCleanup(dst);
const encoder = t.device.createCommandEncoder();
encoder.copyBufferToBuffer(src, srcOffset, dst, dstOffset, copySize);
@ -92,11 +91,10 @@ g.test('copy_order')
const src = t.makeBufferWithContents(srcData, GPUBufferUsage.COPY_SRC);
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: srcData.length * 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
t.trackForCleanup(dst);
const encoder = t.device.createCommandEncoder();
encoder.copyBufferToBuffer(src, 0, dst, 0, 16);

91
src/webgpu/api/operation/command_buffer/copyTextureToTexture.spec.ts
View file

@ -22,7 +22,6 @@ import {
isRegularTextureFormat,
} from '../../../format_info.js';
import { GPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { makeBufferWithContents } from '../../../util/buffer.js';
import { checkElementsEqual } from '../../../util/check_contents.js';
import { align } from '../../../util/math.js';
import { physicalMipSize } from '../../../util/texture/base.js';
@ -99,8 +98,7 @@ class F extends TextureTestMixin(GPUTest) {
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
mipLevelCount,
};
const srcTexture = this.device.createTexture(srcTextureDesc);
this.trackForCleanup(srcTexture);
const srcTexture = this.createTextureTracked(srcTextureDesc);
const dstTextureDesc: GPUTextureDescriptor = {
dimension,
size: dstTextureSize,
@ -108,8 +106,7 @@ class F extends TextureTestMixin(GPUTest) {
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | extraTextureUsageFlags,
mipLevelCount,
};
const dstTexture = this.device.createTexture(dstTextureDesc);
this.trackForCleanup(dstTexture);
const dstTexture = this.createTextureTracked(dstTextureDesc);
// Fill the whole subresource of srcTexture at srcCopyLevel with initialSrcData.
const initialSrcData = this.GetInitialDataPerMipLevel(
@ -215,7 +212,7 @@ class F extends TextureTestMixin(GPUTest) {
// compare by rendering. We need the expected texture to match
// the dstTexture so we'll create a texture where we supply
// all of the data in JavaScript.
const expectedTexture = this.device.createTexture({
const expectedTexture = this.createTextureTracked({
size: [dstTexture.width, dstTexture.height, dstTexture.depthOrArrayLayers],
mipLevelCount: dstTexture.mipLevelCount,
format: dstTexture.format,
@ -273,8 +270,7 @@ class F extends TextureTestMixin(GPUTest) {
size: dstBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
};
const dstBuffer = this.device.createBuffer(dstBufferDesc);
this.trackForCleanup(dstBuffer);
const dstBuffer = this.createBufferTracked(dstBufferDesc);
{
const encoder = this.device.createCommandEncoder();
@ -436,11 +432,10 @@ class F extends TextureTestMixin(GPUTest) {
}),
kBufferSizeAlignment
);
const outputBuffer = this.device.createBuffer({
const outputBuffer = this.createBufferTracked({
size: outputBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
this.trackForCleanup(outputBuffer);
const encoder = this.device.createCommandEncoder();
encoder.copyTextureToBuffer(
{
@ -545,8 +540,7 @@ class F extends TextureTestMixin(GPUTest) {
for (let i = 1; i < totalCopyArrayLayers; ++i) {
uniformBufferData[(kMinDynamicBufferOffsetAlignment / 4) * i] = i;
}
const uniformBuffer = makeBufferWithContents(
this.device,
const uniformBuffer = this.makeBufferWithContents(
uniformBufferData,
GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM
);
@ -626,13 +620,11 @@ class F extends TextureTestMixin(GPUTest) {
});
const bindGroup = this.GetBindGroupForT2TCopyWithDepthTests(bindGroupLayout, copySize[2]);
const outputColorTexture = this.trackForCleanup(
this.device.createTexture({
format: 'rgba8unorm',
size: copySize,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
})
);
const outputColorTexture = this.createTextureTracked({
format: 'rgba8unorm',
size: copySize,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
});
const hasStencil = kTextureFormatInfo[destinationTexture.format].stencil;
const encoder = this.device.createCommandEncoder();
for (let dstCopyLayer = 0; dstCopyLayer < copySize[2]; ++dstCopyLayer) {
@ -1287,28 +1279,24 @@ g.test('copy_depth_stencil')
srcTextureSize.height >> srcCopyLevel,
srcTextureSize.depthOrArrayLayers - Math.max(srcCopyBaseArrayLayer, dstCopyBaseArrayLayer),
];
const sourceTexture = t.trackForCleanup(
t.device.createTexture({
format,
size: srcTextureSize,
usage:
GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
mipLevelCount: srcCopyLevel + 1,
})
);
const destinationTexture = t.trackForCleanup(
t.device.createTexture({
format,
size: [
copySize[0] << dstCopyLevel,
copySize[1] << dstCopyLevel,
srcTextureSize.depthOrArrayLayers,
] as const,
usage:
GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
mipLevelCount: dstCopyLevel + 1,
})
);
const sourceTexture = t.createTextureTracked({
format,
size: srcTextureSize,
usage:
GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
mipLevelCount: srcCopyLevel + 1,
});
const destinationTexture = t.createTextureTracked({
format,
size: [
copySize[0] << dstCopyLevel,
copySize[1] << dstCopyLevel,
srcTextureSize.depthOrArrayLayers,
] as const,
usage:
GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
mipLevelCount: dstCopyLevel + 1,
});
let initialStencilData: undefined | Uint8Array = undefined;
if (kTextureFormatInfo[format].stencil) {
@ -1384,7 +1372,7 @@ g.test('copy_multisampled_color')
const kColorFormat = 'rgba8unorm';
const kSampleCount = 4;
const sourceTexture = t.device.createTexture({
const sourceTexture = t.createTextureTracked({
format: kColorFormat,
size: textureSize,
usage:
@ -1393,8 +1381,7 @@ g.test('copy_multisampled_color')
GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: kSampleCount,
});
t.trackForCleanup(sourceTexture);
const destinationTexture = t.device.createTexture({
const destinationTexture = t.createTextureTracked({
format: kColorFormat,
size: textureSize,
usage:
@ -1403,7 +1390,6 @@ g.test('copy_multisampled_color')
GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: kSampleCount,
});
t.trackForCleanup(destinationTexture);
// Initialize sourceTexture with a draw call.
const renderPipelineForInit = t.device.createRenderPipeline({
@ -1526,12 +1512,11 @@ g.test('copy_multisampled_color')
},
],
});
const expectedOutputTexture = t.device.createTexture({
const expectedOutputTexture = t.createTextureTracked({
format: kColorFormat,
size: textureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
t.trackForCleanup(expectedOutputTexture);
const validationEncoder = t.device.createCommandEncoder();
const renderPassForValidation = validationEncoder.beginRenderPass({
colorAttachments: [
@ -1575,20 +1560,18 @@ g.test('copy_multisampled_depth')
const kDepthFormat = 'depth24plus';
const kSampleCount = 4;
const sourceTexture = t.device.createTexture({
const sourceTexture = t.createTextureTracked({
format: kDepthFormat,
size: textureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: kSampleCount,
});
t.trackForCleanup(sourceTexture);
const destinationTexture = t.device.createTexture({
const destinationTexture = t.createTextureTracked({
format: kDepthFormat,
size: textureSize,
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: kSampleCount,
});
t.trackForCleanup(destinationTexture);
const vertexState: GPUVertexState = {
module: t.device.createShaderModule({
@ -1676,19 +1659,17 @@ g.test('copy_multisampled_depth')
count: kSampleCount,
},
});
const multisampledColorTexture = t.device.createTexture({
const multisampledColorTexture = t.createTextureTracked({
format: kColorFormat,
size: textureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: kSampleCount,
});
t.trackForCleanup(multisampledColorTexture);
const colorTextureAsResolveTarget = t.device.createTexture({
const colorTextureAsResolveTarget = t.createTextureTracked({
format: kColorFormat,
size: textureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
t.trackForCleanup(colorTextureAsResolveTarget);
const encoderForVerify = t.device.createCommandEncoder();
const renderPassForVerify = encoderForVerify.beginRenderPass({

43
src/webgpu/api/operation/command_buffer/image_copy.spec.ts
View file

@ -60,7 +60,6 @@ import {
isCompressedTextureFormat,
} from '../../../format_info.js';
import { GPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { makeBufferWithContents } from '../../../util/buffer.js';
import { checkElementsEqual } from '../../../util/check_contents.js';
import { align } from '../../../util/math.js';
import { physicalMipSizeFromTexture } from '../../../util/texture/base.js';
@ -440,7 +439,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
actualTexture.height,
actualTexture.depthOrArrayLayers,
] as const;
const expectedTexture = this.device.createTexture({
const expectedTexture = this.createTextureTracked({
label: 'expectedTexture',
size,
dimension: actualTexture.dimension,
@ -448,7 +447,6 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
mipLevelCount: actualTexture.mipLevelCount,
usage: actualTexture.usage,
});
this.trackForCleanup(expectedTexture);
const mipLevel = mipLevelOrUndefined || 0;
const fullMipLevelTextureCopyLayout = getTextureCopyLayout(
@ -646,14 +644,13 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
checkMethod: CheckMethod;
changeBeforePass?: ChangeBeforePass;
}): void {
const texture = this.device.createTexture({
const texture = this.createTextureTracked({
size: textureSize as [number, number, number],
format,
dimension,
mipLevelCount: mipLevel + 1,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});
this.trackForCleanup(texture);
const data = dataGenerator.generateView(dataSize);
@ -745,14 +742,13 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
initialDataOffset: number,
mipLevel: number
): void {
const srcTexture = this.device.createTexture({
const srcTexture = this.createTextureTracked({
size: textureSize,
usage:
GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
format,
mipLevelCount: mipLevel + 1,
});
this.trackForCleanup(srcTexture);
const copySize = [textureSize[0] >> mipLevel, textureSize[1] >> mipLevel, textureSize[2]];
const initialData = dataGenerator.generateView(
@ -775,11 +771,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
break;
case 'CopyB2T':
{
const stagingBuffer = makeBufferWithContents(
this.device,
initialData,
GPUBufferUsage.COPY_SRC
);
const stagingBuffer = this.makeBufferWithContents(initialData, GPUBufferUsage.COPY_SRC);
const encoder = this.device.createCommandEncoder();
encoder.copyBufferToTexture(
{ buffer: stagingBuffer, offset: initialDataOffset, bytesPerRow, rowsPerImage },
@ -813,14 +805,13 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
offset: number,
mipLevel: number
): void {
const srcTexture = this.device.createTexture({
const srcTexture = this.createTextureTracked({
size: textureSize,
usage:
GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
format,
mipLevelCount: mipLevel + 1,
});
this.trackForCleanup(srcTexture);
// Initialize srcTexture with queue.writeTexture()
const copySize = [textureSize[0] >> mipLevel, textureSize[1] >> mipLevel, textureSize[2]];
@ -845,11 +836,10 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
}),
kBufferSizeAlignment
);
const outputBuffer = this.device.createBuffer({
const outputBuffer = this.createBufferTracked({
size: outputBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
this.trackForCleanup(outputBuffer);
const encoder = this.device.createCommandEncoder();
encoder.copyTextureToBuffer(
{ texture: srcTexture, aspect: 'stencil-only', mipLevel },
@ -897,8 +887,7 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
for (let i = 1; i < stencilBitCount; ++i) {
uniformBufferData[(kMinDynamicBufferOffsetAlignment / 4) * i] = i;
}
const uniformBuffer = makeBufferWithContents(
this.device,
const uniformBuffer = this.makeBufferWithContents(
uniformBufferData,
GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM
);
@ -1011,12 +1000,11 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
copyFromOutputTextureLayout.mipSize[1],
1,
];
const outputTexture = this.device.createTexture({
const outputTexture = this.createTextureTracked({
format: 'r8unorm',
size: outputTextureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
this.trackForCleanup(outputTexture);
for (
let stencilTextureLayer = 0;
@ -1068,11 +1056,10 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
// Check outputTexture by copying the content of outputTexture into outputStagingBuffer and
// checking all the data in outputStagingBuffer.
const outputStagingBuffer = this.device.createBuffer({
const outputStagingBuffer = this.createBufferTracked({
size: copyFromOutputTextureLayout.byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
this.trackForCleanup(outputStagingBuffer);
encoder.copyTextureToBuffer(
{
texture: outputTexture,
@ -1117,12 +1104,11 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
): void {
assert(!!kTextureFormatInfo[depthFormat].depth);
const inputTexture = this.device.createTexture({
const inputTexture = this.createTextureTracked({
size: copySize,
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
format: 'r32float',
});
this.trackForCleanup(inputTexture);
this.queue.writeTexture(
{ texture: inputTexture },
initialData,
@ -1237,12 +1223,11 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
}
createUniformBufferAndBindGroupEntryForBaseArrayLayer(z: number) {
const buffer = this.device.createBuffer({
const buffer = this.createBufferTracked({
usage: GPUBufferUsage.UNIFORM,
size: 4,
mappedAtCreation: true,
});
this.trackForCleanup(buffer);
new Uint32Array(buffer.getMappedRange()).set([z]);
buffer.unmap();
return {
@ -1290,13 +1275,12 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
}
// Initialize the depth aspect of the source texture
const depthTexture = this.device.createTexture({
const depthTexture = this.createTextureTracked({
format,
size: [copySize[0] << mipLevel, copySize[1] << mipLevel, copySize[2]] as const,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
mipLevelCount: mipLevel + 1,
});
this.trackForCleanup(depthTexture);
this.initializeDepthAspectWithRendering(depthTexture, format, copySize, mipLevel, initialData);
// Copy the depth aspect of the texture into the destination buffer.
@ -1314,11 +1298,10 @@ class ImageCopyTest extends TextureTestMixin(GPUTest) {
dataPaddingInBytes,
kBufferSizeAlignment
);
const destinationBuffer = this.device.createBuffer({
const destinationBuffer = this.createBufferTracked({
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
size: destinationBufferSize,
});
this.trackForCleanup(destinationBuffer);
const copyEncoder = this.device.createCommandEncoder();
copyEncoder.copyTextureToBuffer(
{

20
src/webgpu/api/operation/command_buffer/queries/occlusionQuery.spec.ts
View file

@ -253,12 +253,6 @@ class QueryStarterRenderBundle implements QueryStarter {
}
class OcclusionQueryTest extends GPUTest {
createBuffer(desc: GPUBufferDescriptor) {
return this.trackForCleanup(this.device.createBuffer(desc));
}
createTexture(desc: GPUTextureDescriptor) {
return this.trackForCleanup(this.device.createTexture(desc));
}
createVertexBuffer(data: TypedArrayBufferView) {
return this.makeBufferWithContents(data, GPUBufferUsage.VERTEX);
}
@ -291,26 +285,26 @@ class OcclusionQueryTest extends GPUTest {
const queryResolveBufferOffset =
bufferOffset === 'non-zero' ? kRequiredQueryBufferOffsetAlignment : 0;
const queryResolveBuffer = this.createBuffer({
const queryResolveBuffer = this.createBufferTracked({
size: numQueries * 8 + queryResolveBufferOffset,
usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
});
const readBuffer = this.createBuffer({
const readBuffer = this.createBufferTracked({
size: numQueries * kBytesPerQuery,
usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
});
const vertexBuffer = this.createSingleTriangleVertexBuffer(0);
const renderTargetTexture = this.createTexture({
const renderTargetTexture = this.createTextureTracked({
format: 'rgba8unorm',
size: kTextureSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
const multisampleRenderTarget = sampleCount
? this.createTexture({
? this.createTextureTracked({
size: kTextureSize,
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
@ -319,7 +313,7 @@ class OcclusionQueryTest extends GPUTest {
: null;
const depthStencilTexture = depthStencilFormat
? this.createTexture({
? this.createTextureTracked({
format: depthStencilFormat,
size: kTextureSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
@ -955,8 +949,8 @@ g.test('occlusion_query,multi_resolve')
readBuffer,
} = t.setup({ numQueries: kNumQueries });
const readBuffer2 = t.createBuffer(readBuffer);
const readBuffer3 = t.createBuffer(readBuffer);
const readBuffer2 = t.createBufferTracked(readBuffer);
const readBuffer3 = t.createBufferTracked(readBuffer);
const renderSomething = (encoder: GPUCommandEncoder) => {
const pass = encoder.beginRenderPass(renderPassDescriptor);

22
src/webgpu/api/operation/command_buffer/render/state_tracking.spec.ts
View file

@ -94,12 +94,11 @@ g.test('set_index_buffer_without_changing_buffer')
// Initialize the vertex buffer with required vertex attributes (position: f32, color: f32x4)
// Note that the maximum index in the test is 0x10000.
const kVertexAttributesCount = 0x10000 + 1;
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
usage: GPUBufferUsage.VERTEX,
size: t.kVertexAttributeSize * kVertexAttributesCount,
mappedAtCreation: true,
});
t.trackForCleanup(vertexBuffer);
const vertexAttributes = vertexBuffer.getMappedRange();
const kPositions = [-0.8, -0.4, 0.0, 0.4, 0.8, -0.4];
const kColors = [
@ -131,7 +130,7 @@ g.test('set_index_buffer_without_changing_buffer')
const renderPipeline = t.GetRenderPipelineForTest(t.kVertexAttributeSize);
const outputTextureSize = [kPositions.length - 1, 1, 1];
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: outputTextureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -205,12 +204,11 @@ g.test('set_vertex_buffer_without_changing_buffer')
// Initialize the vertex buffer with required vertex attributes (position: f32, color: f32x4)
const kVertexAttributesCount = 8;
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
usage: GPUBufferUsage.VERTEX,
size: t.kVertexAttributeSize * kVertexAttributesCount,
mappedAtCreation: true,
});
t.trackForCleanup(vertexBuffer);
const vertexAttributes = vertexBuffer.getMappedRange();
for (let i = 0; i < kPositions.length; ++i) {
const baseOffset = t.kVertexAttributeSize * i;
@ -225,7 +223,7 @@ g.test('set_vertex_buffer_without_changing_buffer')
const renderPipeline = t.GetRenderPipelineForTest(t.kVertexAttributeSize);
const outputTextureSize = [kPositions.length, 1, 1];
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: outputTextureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -303,12 +301,11 @@ g.test('change_pipeline_before_and_after_vertex_buffer')
];
// Initialize the vertex buffer with required vertex attributes (position: f32, color: f32x4)
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
usage: GPUBufferUsage.VERTEX,
size: t.kVertexAttributeSize * kPositions.length,
mappedAtCreation: true,
});
t.trackForCleanup(vertexBuffer);
// Note that kPositions[1], kColors[1], kPositions[5] and kColors[5] are not used.
const vertexAttributes = vertexBuffer.getMappedRange();
for (let i = 0; i < kPositions.length; ++i) {
@ -326,7 +323,7 @@ g.test('change_pipeline_before_and_after_vertex_buffer')
const kPointsCount = kPositions.length - 1;
const outputTextureSize = [kPointsCount, 1, 1];
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: outputTextureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -502,7 +499,7 @@ g.test('set_vertex_buffer_but_not_used_in_draw')
const kPointsCount = 4;
const outputTextureSize = [kPointsCount, 1, 1];
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: [kPointsCount, 1, 1],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -562,12 +559,11 @@ g.test('set_index_buffer_before_non_indexed_draw')
];
// Initialize the vertex buffer with required vertex attributes (position: f32, color: f32x4)
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
usage: GPUBufferUsage.VERTEX,
size: t.kVertexAttributeSize * kPositions.length,
mappedAtCreation: true,
});
t.trackForCleanup(vertexBuffer);
const vertexAttributes = vertexBuffer.getMappedRange();
for (let i = 0; i < kPositions.length; ++i) {
const baseOffset = t.kVertexAttributeSize * i;
@ -585,7 +581,7 @@ g.test('set_index_buffer_before_non_indexed_draw')
const kPointsCount = 4;
const outputTextureSize = [kPointsCount, 1, 1];
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: [kPointsCount, 1, 1],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,

4
src/webgpu/api/operation/compute/basic.spec.ts
View file

@ -13,7 +13,7 @@ g.test('memcpy').fn(t => {
const src = t.makeBufferWithContents(data, GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE);
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
});
@ -92,7 +92,7 @@ g.test('large_dispatch')
: t.params.dispatchSize;
const bufferLength = dispatchSize * wgSize;
const bufferByteSize = Uint32Array.BYTES_PER_ELEMENT * bufferLength;
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: bufferByteSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
});

16
src/webgpu/api/operation/compute_pipeline/overrides.spec.ts
View file

@ -13,7 +13,7 @@ class F extends GPUTest {
constants: Record<string, GPUPipelineConstantValue>,
code: string
) {
const dst = this.device.createBuffer({
const dst = this.createBufferTracked({
size: expected.byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
});
@ -171,7 +171,7 @@ g.test('computed')
const expected = new Uint32Array([2, 4, 8]);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 3 * Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
});
@ -311,11 +311,11 @@ g.test('shared_shader_module')
const expects = [new Uint32Array([1]), new Uint32Array([2])];
const buffers = [
t.device.createBuffer({
t.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
}),
t.device.createBuffer({
t.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
}),
@ -430,19 +430,19 @@ g.test('multi_entry_points')
];
const buffers = [
t.device.createBuffer({
t.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
}),
t.device.createBuffer({
t.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
}),
t.device.createBuffer({
t.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
}),
t.device.createBuffer({
t.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
}),

8
src/webgpu/api/operation/labels.spec.ts
View file

@ -12,7 +12,7 @@ export const g = makeTestGroup(GPUTest);
type TestFunction = (t: GPUTest, label: string) => Promise<void> | void;
const kTestFunctions: { [name: string]: TestFunction } = {
createBuffer: (t: GPUTest, label: string) => {
const buffer = t.device.createBuffer({ size: 16, usage: GPUBufferUsage.COPY_DST, label });
const buffer = t.createBufferTracked({ size: 16, usage: GPUBufferUsage.COPY_DST, label });
t.expect(buffer.label === label);
buffer.destroy();
t.expect(buffer.label === label);
@ -30,7 +30,7 @@ const kTestFunctions: { [name: string]: TestFunction } = {
},
createTexture: (t: GPUTest, label: string) => {
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
label,
size: [1, 1, 1],
format: 'rgba8unorm',
@ -188,7 +188,7 @@ const kTestFunctions: { [name: string]: TestFunction } = {
},
beginRenderPass: (t: GPUTest, label: string) => {
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
label,
size: [1, 1, 1],
format: 'rgba8unorm',
@ -230,7 +230,7 @@ const kTestFunctions: { [name: string]: TestFunction } = {
},
createView: (t: GPUTest, label: string) => {
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: [1, 1, 1],
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,

112
src/webgpu/api/operation/memory_sync/buffer/buffer_sync_test.ts
View file

@ -221,39 +221,35 @@ export class BufferSyncTest extends GPUTest {
break;
}
const dstBuffer = this.trackForCleanup(
this.device.createBuffer({
size: Uint32Array.BYTES_PER_ELEMENT,
usage:
GPUBufferUsage.COPY_SRC |
GPUBufferUsage.COPY_DST |
GPUBufferUsage.STORAGE |
GPUBufferUsage.VERTEX |
GPUBufferUsage.INDEX |
GPUBufferUsage.INDIRECT |
GPUBufferUsage.UNIFORM,
})
);
const dstBuffer = this.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage:
GPUBufferUsage.COPY_SRC |
GPUBufferUsage.COPY_DST |
GPUBufferUsage.STORAGE |
GPUBufferUsage.VERTEX |
GPUBufferUsage.INDEX |
GPUBufferUsage.INDIRECT |
GPUBufferUsage.UNIFORM,
});
return { srcBuffer, dstBuffer };
}
// Create a buffer with 1 uint32 element, and initialize it to a specified value.
async createBufferWithValue(initValue: number): Promise<GPUBuffer> {
const buffer = this.trackForCleanup(
this.device.createBuffer({
mappedAtCreation: true,
size: Uint32Array.BYTES_PER_ELEMENT,
usage:
GPUBufferUsage.COPY_SRC |
GPUBufferUsage.COPY_DST |
GPUBufferUsage.STORAGE |
GPUBufferUsage.VERTEX |
GPUBufferUsage.INDEX |
GPUBufferUsage.INDIRECT |
GPUBufferUsage.UNIFORM,
})
);
const buffer = this.createBufferTracked({
mappedAtCreation: true,
size: Uint32Array.BYTES_PER_ELEMENT,
usage:
GPUBufferUsage.COPY_SRC |
GPUBufferUsage.COPY_DST |
GPUBufferUsage.STORAGE |
GPUBufferUsage.VERTEX |
GPUBufferUsage.INDEX |
GPUBufferUsage.INDIRECT |
GPUBufferUsage.UNIFORM,
});
new Uint32Array(buffer.getMappedRange()).fill(initValue);
buffer.unmap();
await this.queue.onSubmittedWorkDone();
@ -262,20 +258,18 @@ export class BufferSyncTest extends GPUTest {
// Create a buffer, and initialize it to the specified values.
async createBufferWithValues(initValues: number[]): Promise<GPUBuffer> {
const buffer = this.trackForCleanup(
this.device.createBuffer({
mappedAtCreation: true,
size: Uint32Array.BYTES_PER_ELEMENT * initValues.length,
usage:
GPUBufferUsage.COPY_SRC |
GPUBufferUsage.COPY_DST |
GPUBufferUsage.STORAGE |
GPUBufferUsage.VERTEX |
GPUBufferUsage.INDEX |
GPUBufferUsage.INDIRECT |
GPUBufferUsage.UNIFORM,
})
);
const buffer = this.createBufferTracked({
mappedAtCreation: true,
size: Uint32Array.BYTES_PER_ELEMENT * initValues.length,
usage:
GPUBufferUsage.COPY_SRC |
GPUBufferUsage.COPY_DST |
GPUBufferUsage.STORAGE |
GPUBufferUsage.VERTEX |
GPUBufferUsage.INDEX |
GPUBufferUsage.INDIRECT |
GPUBufferUsage.UNIFORM,
});
const bufferView = new Uint32Array(buffer.getMappedRange());
bufferView.set(initValues);
buffer.unmap();
@ -287,13 +281,11 @@ export class BufferSyncTest extends GPUTest {
async createTextureWithValue(initValue: number): Promise<GPUTexture> {
// This is not hot in profiles; optimize if this gets used more heavily.
const data = new Uint32Array(1).fill(initValue);
const texture = this.trackForCleanup(
this.device.createTexture({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'r32uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
})
);
const texture = this.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'r32uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
});
this.device.queue.writeTexture(
{ texture, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } },
data,
@ -379,13 +371,11 @@ export class BufferSyncTest extends GPUTest {
}
beginSimpleRenderPass(encoder: GPUCommandEncoder): GPURenderPassEncoder {
const view = this.trackForCleanup(
this.device.createTexture({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
).createView();
const view = this.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
}).createView();
return encoder.beginRenderPass({
colorAttachments: [
{
@ -806,13 +796,11 @@ export class BufferSyncTest extends GPUTest {
// Read and Write texture via BufferToTexture copy.
encodeReadByB2TCopy(encoder: GPUCommandEncoder, srcBuffer: GPUBuffer, dstBuffer: GPUBuffer) {
const tmpTexture = this.trackForCleanup(
this.device.createTexture({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'r32uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
})
);
const tmpTexture = this.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'r32uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
});
// The b2t copy is just encoded into command encoder, it doesn't write immediately.
encoder.copyBufferToTexture(

12
src/webgpu/api/operation/memory_sync/operation_context_helper.ts
View file

@ -168,13 +168,11 @@ export class OperationContextHelper {
}
private makeDummyAttachment(): GPURenderPassColorAttachment {
const texture = this.t.trackForCleanup(
this.device.createTexture({
format: this.kTextureFormat,
size: this.kTextureSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
);
const texture = this.t.createTextureTracked({
format: this.kTextureFormat,
size: this.kTextureSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
return {
view: texture.createView(),
loadOp: 'load',

11
src/webgpu/api/operation/memory_sync/texture/readonly_depth_stencil.spec.ts
View file

@ -49,13 +49,12 @@ testing while the other one is used for sampling.
const hasStencil = formatInfo.stencil !== undefined;
// The 3x3 depth stencil texture used for the tests.
const ds = t.device.createTexture({
const ds = t.createTextureTracked({
label: 'testTexture',
size: [3, 3],
format,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
t.trackForCleanup(ds);
// Fill the texture along the X axis with stencil values 1, 2, 3 and along the Y axis depth
// values 0.1, 0.2, 0.3. The depth value is written using @builtin(frag_depth) while the
@ -217,20 +216,18 @@ testing while the other one is used for sampling.
});
// Make fake stencil or depth textures to put in the bindgroup if the aspect is not readonly.
const fakeStencil = t.device.createTexture({
const fakeStencil = t.createTextureTracked({
label: 'fakeStencil',
format: 'r32uint',
size: [1, 1],
usage: GPUTextureUsage.TEXTURE_BINDING,
});
t.trackForCleanup(fakeStencil);
const fakeDepth = t.device.createTexture({
const fakeDepth = t.createTextureTracked({
label: 'fakeDepth',
format: 'r32float',
size: [1, 1],
usage: GPUTextureUsage.TEXTURE_BINDING,
});
t.trackForCleanup(fakeDepth);
const stencilView = stencilReadOnly
? ds.createView({ aspect: 'stencil-only' })
: fakeStencil.createView();
@ -301,7 +298,7 @@ testing while the other one is used for sampling.
],
});
const resultTexture = t.device.createTexture({
const resultTexture = t.createTextureTracked({
label: 'resultTexture',
format: 'r32uint',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,

84
src/webgpu/api/operation/memory_sync/texture/same_subresource.spec.ts
View file

@ -66,13 +66,11 @@ class TextureSyncTestHelper extends OperationContextHelper {
}
) {
super(t);
this.texture = t.trackForCleanup(
t.device.createTexture({
size: this.kTextureSize,
format: this.kTextureFormat,
...textureCreationParams,
})
);
this.texture = t.createTextureTracked({
size: this.kTextureSize,
format: this.kTextureFormat,
...textureCreationParams,
});
}
/**
@ -83,13 +81,11 @@ class TextureSyncTestHelper extends OperationContextHelper {
this.ensureContext(context);
switch (op) {
case 't2t-copy': {
const texture = this.t.trackForCleanup(
this.device.createTexture({
size: this.kTextureSize,
format: this.kTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
})
);
const texture = this.t.createTextureTracked({
size: this.kTextureSize,
format: this.kTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
});
assert(this.commandEncoder !== undefined);
this.commandEncoder.copyTextureToTexture(
@ -106,20 +102,16 @@ class TextureSyncTestHelper extends OperationContextHelper {
...this.kTextureSize,
1,
]);
const buffer = this.t.trackForCleanup(
this.device.createBuffer({
size: byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
})
);
const buffer = this.t.createBufferTracked({
size: byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
const texture = this.t.trackForCleanup(
this.device.createTexture({
size: this.kTextureSize,
format: this.kTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
})
);
const texture = this.t.createTextureTracked({
size: this.kTextureSize,
format: this.kTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
});
assert(this.commandEncoder !== undefined);
this.commandEncoder.copyTextureToBuffer(
@ -137,13 +129,11 @@ class TextureSyncTestHelper extends OperationContextHelper {
return texture;
}
case 'sample': {
const texture = this.t.trackForCleanup(
this.device.createTexture({
size: this.kTextureSize,
format: this.kTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
})
);
const texture = this.t.createTextureTracked({
size: this.kTextureSize,
format: this.kTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
const bindGroupLayout = this.device.createBindGroupLayout({
entries: [
@ -326,7 +316,7 @@ class TextureSyncTestHelper extends OperationContextHelper {
break;
}
case 't2t-copy': {
const texture = this.device.createTexture({
const texture = this.t.createTextureTracked({
size: this.kTextureSize,
format: this.kTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
@ -376,12 +366,10 @@ class TextureSyncTestHelper extends OperationContextHelper {
}
}
const buffer = this.t.trackForCleanup(
this.device.createBuffer({
size: fullTexelData.byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
})
);
const buffer = this.t.createBufferTracked({
size: fullTexelData.byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
this.queue.writeBuffer(buffer, 0, fullTexelData);
@ -395,14 +383,12 @@ class TextureSyncTestHelper extends OperationContextHelper {
}
case 'attachment-resolve': {
assert(this.commandEncoder !== undefined);
const renderTarget = this.t.trackForCleanup(
this.device.createTexture({
format: this.kTextureFormat,
size: this.kTextureSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: 4,
})
);
const renderTarget = this.t.createTextureTracked({
format: this.kTextureFormat,
size: this.kTextureSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: 4,
});
this.renderPassEncoder = this.commandEncoder.beginRenderPass({
colorAttachments: [
{

2
src/webgpu/api/operation/onSubmittedWorkDone.spec.ts
View file

@ -19,7 +19,7 @@ g.test('without_work')
g.test('with_work')
.desc(`Await onSubmittedWorkDone once after submitting some work (writeBuffer).`)
.fn(async t => {
const buffer = t.device.createBuffer({ size: 4, usage: GPUBufferUsage.COPY_DST });
const buffer = t.createBufferTracked({ size: 4, usage: GPUBufferUsage.COPY_DST });
t.queue.writeBuffer(buffer, 0, new Uint8Array(4));
await t.queue.onSubmittedWorkDone();
});

22
src/webgpu/api/operation/reflection.spec.ts
View file

@ -44,7 +44,7 @@ g.test('buffer_reflection_attributes')
const { descriptor } = t.params;
t.expectValidationError(() => {
const buffer = t.device.createBuffer(descriptor);
const buffer = t.createBufferTracked(descriptor);
t.expect(buffer.size === descriptor.size);
t.expect(buffer.usage === descriptor.usage);
@ -66,10 +66,8 @@ g.test('buffer_creation_from_reflection')
.fn(t => {
const { descriptor } = t.params;
const buffer = t.device.createBuffer(descriptor);
t.trackForCleanup(buffer);
const buffer2 = t.device.createBuffer(buffer);
t.trackForCleanup(buffer2);
const buffer = t.createBufferTracked(descriptor);
const buffer2 = t.createBufferTracked(buffer);
const bufferAsObject = buffer as unknown as { [k: string]: unknown };
const buffer2AsObject = buffer2 as unknown as { [k: string]: unknown };
@ -164,7 +162,7 @@ g.test('texture_reflection_attributes')
}
t.expectValidationError(() => {
const texture = t.device.createTexture(descriptor);
const texture = t.createTextureTracked(descriptor);
t.expect(texture.width === width);
t.expect(texture.height === height);
@ -195,12 +193,10 @@ g.test('texture_creation_from_reflection')
.fn(t => {
const { descriptor } = t.params;
const texture = t.device.createTexture(descriptor);
t.trackForCleanup(texture);
const texture = t.createTextureTracked(descriptor);
const textureWithSize = texture as TextureWithSize;
textureWithSize.size = [texture.width, texture.height, texture.depthOrArrayLayers];
const texture2 = t.device.createTexture(textureWithSize);
t.trackForCleanup(texture2);
const texture2 = t.createTextureTracked(textureWithSize);
const textureAsObject = texture as unknown as { [k: string]: unknown };
const texture2AsObject = texture2 as unknown as { [k: string]: unknown };
@ -217,14 +213,14 @@ g.test('texture_creation_from_reflection')
// MAINTENANCE_TODO: Check this if it is made possible by a spec change.
//
// texture3 = t.device.createTexture({
// texture3 = t.createTextureTracked({
// ...texture,
// size: [texture.width, texture.height, texture.depthOrArrayLayers],
// });
//
// and this
//
// texture3 = t.device.createTexture({
// texture3 = t.createTextureTracked({
// size: [texture.width, texture.height, texture.depthOrArrayLayers],
// ...texture,
// });
@ -271,9 +267,7 @@ g.test('query_set_creation_from_reflection')
const { descriptor } = t.params;
const querySet = t.createQuerySetTracked(descriptor);
t.trackForCleanup(querySet);
const querySet2 = t.createQuerySetTracked(querySet);
t.trackForCleanup(querySet2);
const querySetAsObject = querySet as unknown as { [k: string]: unknown };
const querySet2AsObject = querySet2 as unknown as { [k: string]: unknown };

7
src/webgpu/api/operation/render_pass/clear_value.spec.ts
View file

@ -64,12 +64,12 @@ g.test('stencil_clear_value')
const kSize = [1, 1, 1] as const;
const colorFormat = 'rgba8unorm';
const stencilTexture = t.device.createTexture({
const stencilTexture = t.createTextureTracked({
format: stencilFormat,
size: kSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
});
const colorTexture = t.device.createTexture({
const colorTexture = t.createTextureTracked({
format: colorFormat,
size: kSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
@ -162,11 +162,10 @@ g.test('stencil_clear_value')
renderPassEncoder.draw(6);
renderPassEncoder.end();
const destinationBuffer = t.device.createBuffer({
const destinationBuffer = t.createBufferTracked({
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
size: 4,
});
t.trackForCleanup(destinationBuffer);
encoder.copyTextureToBuffer(
{
texture: stencilTexture,

6
src/webgpu/api/operation/render_pass/resolve.spec.ts
View file

@ -99,7 +99,7 @@ g.test('render_pass_resolve')
const kResolveTargetSize = kSize << t.params.resolveTargetBaseMipLevel;
for (let i = 0; i < t.params.numColorAttachments; i++) {
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: kFormat,
size: { width: kSize, height: kSize, depthOrArrayLayers: 1 },
sampleCount: 4,
@ -109,7 +109,7 @@ g.test('render_pass_resolve')
});
if (t.params.slotsToResolve.includes(i)) {
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: kFormat,
size: { width: kSize, height: kSize, depthOrArrayLayers: 1 },
sampleCount: 4,
@ -118,7 +118,7 @@ g.test('render_pass_resolve')
GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const resolveTarget = t.device.createTexture({
const resolveTarget = t.createTextureTracked({
format: kFormat,
size: {
width: kResolveTargetSize,

10
src/webgpu/api/operation/render_pass/storeOp.spec.ts
View file

@ -65,7 +65,7 @@ g.test('render_pass_store_op,color_attachment_with_depth_stencil_attachment')
.fn(t => {
// Create a basic color attachment.
const kColorFormat: GPUTextureFormat = 'rgba8unorm';
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: kColorFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -75,7 +75,7 @@ g.test('render_pass_store_op,color_attachment_with_depth_stencil_attachment')
// Create a basic depth/stencil attachment.
const kDepthStencilFormat: GPUTextureFormat = 'depth32float';
const depthStencilAttachment = t.device.createTexture({
const depthStencilAttachment = t.createTextureTracked({
format: kDepthStencilFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -154,7 +154,7 @@ g.test('render_pass_store_op,color_attachment_only')
t.skipIfTextureFormatNotSupported(t.params.colorFormat);
})
.fn(t => {
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: t.params.colorFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: t.params.arrayLayer + 1 },
mipLevelCount: kMipLevelCount,
@ -219,7 +219,7 @@ g.test('render_pass_store_op,multiple_color_attachments')
for (let i = 0; i < t.params.colorAttachments; i++) {
colorAttachments.push(
t.device.createTexture({
t.createTextureTracked({
format: kColorFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -284,7 +284,7 @@ TODO: Also test unsized depth/stencil formats [1]
.combine('arrayLayer', kArrayLayers)
)
.fn(t => {
const depthStencilTexture = t.device.createTexture({
const depthStencilTexture = t.createTextureTracked({
format: t.params.depthStencilFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: t.params.arrayLayer + 1 },
mipLevelCount: kMipLevelCount,

2
src/webgpu/api/operation/render_pass/storeop2.spec.ts
View file

@ -19,7 +19,7 @@ TODO: needs review and rename
{ storeOp: 'discard', _expected: 0 },
] as const)
.fn(t => {
const renderTexture = t.device.createTexture({
const renderTexture = t.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: 'r8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,

4
src/webgpu/api/operation/render_pipeline/culling_tests.spec.ts
View file

@ -140,7 +140,7 @@ g.test('culling')
const size = 4;
const format = 'rgba8unorm';
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: { width: size, height: size, depthOrArrayLayers: 1 },
format,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
@ -151,7 +151,7 @@ g.test('culling')
let depthStencilAttachment: GPURenderPassDepthStencilAttachment | undefined = undefined;
let depthStencil: GPUDepthStencilState | undefined = undefined;
if (depthStencilFormat) {
depthTexture = t.device.createTexture({
depthTexture = t.createTextureTracked({
size: { width: size, height: size, depthOrArrayLayers: 1 },
format: depthStencilFormat,
usage: GPUTextureUsage.RENDER_ATTACHMENT,

6
src/webgpu/api/operation/render_pipeline/overrides.spec.ts
View file

@ -14,7 +14,7 @@ class F extends GPUTest {
vertex: GPUVertexState,
fragment: GPUFragmentState
) {
const renderTarget = this.device.createTexture({
const renderTarget = this.createTextureTracked({
format,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -311,12 +311,12 @@ g.test('shared_shader_module')
t.params.fragmentConstants1
);
const renderTarget0 = t.device.createTexture({
const renderTarget0 = t.createTextureTracked({
format,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const renderTarget1 = t.device.createTexture({
const renderTarget1 = t.createTextureTracked({
format,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,

6
src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
View file

@ -79,7 +79,7 @@ g.test('color,attachments')
: attachmentsFloatWriteValues;
const renderTargets = range(attachmentCount, () =>
t.device.createTexture({
t.createTextureTracked({
format,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -170,7 +170,7 @@ g.test('color,component_count')
// extra channels are discarded
const values = [0, 1, 0, 1];
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
format,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -381,7 +381,7 @@ The attachment has a load value of [1, 0, 0, 1]
const componentCount = output.length;
const info = kTextureFormatInfo[format];
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
format,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,

2
src/webgpu/api/operation/render_pipeline/primitive_topology.spec.ts
View file

@ -281,7 +281,7 @@ function generateVertexBuffer(vertexLocations: Point2D[]): Float32Array {
const kDefaultDrawCount = 6;
class PrimitiveTopologyTest extends TextureTestMixin(GPUTest) {
makeAttachmentTexture(): GPUTexture {
return this.device.createTexture({
return this.createTextureTracked({
format: kColorFormat,
size: { width: kRTSize, height: kRTSize, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,

12
src/webgpu/api/operation/render_pipeline/sample_mask.spec.ts
View file

@ -331,7 +331,7 @@ class F extends TextureTestMixin(GPUTest) {
const renderTargetTextures = [];
const resolveTargetTextures: (GPUTexture | null)[] = [];
for (let i = 0; i < colorTargetsCount; i++) {
const renderTargetTexture = this.device.createTexture({
const renderTargetTexture = this.createTextureTracked({
format,
size: {
width: kRenderTargetSize,
@ -347,7 +347,7 @@ class F extends TextureTestMixin(GPUTest) {
const resolveTargetTexture =
sampleCount === 1
? null
: this.device.createTexture({
: this.createTextureTracked({
format,
size: {
width: kRenderTargetSize,
@ -361,7 +361,7 @@ class F extends TextureTestMixin(GPUTest) {
resolveTargetTextures.push(resolveTargetTexture);
}
const depthStencilTexture = this.device.createTexture({
const depthStencilTexture = this.createTextureTracked({
size: {
width: kRenderTargetSize,
height: kRenderTargetSize,
@ -531,11 +531,10 @@ textureLoad each sample index from the texture and write to a storage buffer to
.fn(t => {
const { sampleCount, rasterizationMask, sampleMask, fragmentShaderOutputMask } = t.params;
const fragmentMaskUniformBuffer = t.device.createBuffer({
const fragmentMaskUniformBuffer = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
});
t.trackForCleanup(fragmentMaskUniformBuffer);
t.device.queue.writeBuffer(
fragmentMaskUniformBuffer,
0,
@ -647,11 +646,10 @@ color' <= color.
const sampleMask = 0xffffffff;
const alphaValues = new Float32Array(4); // [alpha0, alpha1, 0, 0]
const alphaValueUniformBuffer = t.device.createBuffer({
const alphaValueUniformBuffer = t.createBufferTracked({
size: alphaValues.byteLength,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
});
t.trackForCleanup(alphaValueUniformBuffer);
const module = t.device.createShaderModule({ code: kSampleMaskTestShader });
const pipeline = t.device.createRenderPipeline({

14
src/webgpu/api/operation/rendering/3d_texture_slices.spec.ts
View file

@ -97,7 +97,7 @@ g.test('one_color_attachment,mip_levels')
.fn(t => {
const { mipLevel, depthSlice } = t.params;
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: [kSize << mipLevel, kSize << mipLevel, 2 << mipLevel],
dimension: '3d',
format: kFormat,
@ -107,7 +107,7 @@ g.test('one_color_attachment,mip_levels')
const { bufferSize } = t.getBufferSizeAndOffset(kSize, kSize, 1);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
@ -187,7 +187,7 @@ g.test('multiple_color_attachments,same_mip_level')
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
} as const;
const texture = t.device.createTexture(descriptor);
const texture = t.createTextureTracked(descriptor);
const textures: GPUTexture[] = [];
const colorAttachments: GPURenderPassColorAttachment[] = [];
@ -195,7 +195,7 @@ g.test('multiple_color_attachments,same_mip_level')
if (sameTexture) {
textures.push(texture);
} else {
const diffTexture = t.device.createTexture(descriptor);
const diffTexture = t.createTextureTracked(descriptor);
textures.push(diffTexture);
}
@ -254,7 +254,7 @@ g.test('multiple_color_attachments,same_mip_level')
}
const { bufferSize, bufferOffset } = t.getBufferSizeAndOffset(kSize, kSize, attachmentCount);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
@ -309,7 +309,7 @@ g.test('multiple_color_attachments,same_slice_with_diff_mip_levels')
primitive: { topology: 'triangle-list' },
});
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: [kBaseSize, kBaseSize, (depthSlice + 1) << attachmentCount],
dimension: '3d',
format: kFormat,
@ -345,7 +345,7 @@ g.test('multiple_color_attachments,same_slice_with_diff_mip_levels')
kBaseSize,
attachmentCount
);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});

19
src/webgpu/api/operation/rendering/basic.spec.ts
View file

@ -10,12 +10,12 @@ import { checkElementsEqual } from '../../../util/check_contents.js';
export const g = makeTestGroup(GPUTest);
g.test('clear').fn(t => {
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: 'rgba8unorm',
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -45,12 +45,12 @@ g.test('clear').fn(t => {
});
g.test('fullscreen_quad').fn(t => {
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: 'rgba8unorm',
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -146,17 +146,17 @@ g.test('large_draw')
const { indexed, indirect } = t.params;
const kBytesPerRow = 256;
const dst = t.device.createBuffer({
const dst = t.createBufferTracked({
size: 3 * kBytesPerRow,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
const paramsBuffer = t.device.createBuffer({
const paramsBuffer = t.createBufferTracked({
size: 8,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
});
const indirectBuffer = t.device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: 20,
usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_DST,
});
@ -173,12 +173,11 @@ g.test('large_draw')
let indexBuffer: null | GPUBuffer = null;
if (indexed) {
const kMaxIndices = 16 * 1024 * 1024;
indexBuffer = t.device.createBuffer({
indexBuffer = t.createBufferTracked({
size: kMaxIndices * Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
mappedAtCreation: true,
});
t.trackForCleanup(indexBuffer);
const indexData = new Uint32Array(indexBuffer.getMappedRange());
for (let i = 0; i < kMaxIndices; ++i) {
indexData[i] = i;
@ -186,7 +185,7 @@ g.test('large_draw')
indexBuffer.unmap();
}
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: 'rgba8unorm',
size: { width: 3, height: 3, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,

16
src/webgpu/api/operation/rendering/color_target_state.spec.ts
View file

@ -263,7 +263,7 @@ struct Uniform {
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [1, 1, 1],
format: textureFormat,
@ -374,7 +374,7 @@ g.test('blending,formats')
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [1, 1, 1],
format,
@ -414,7 +414,7 @@ g.test('blend_constant,initial')
blend: { color: blendComponent, alpha: blendComponent },
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [kSize, kSize],
format,
@ -472,7 +472,7 @@ g.test('blend_constant,setting')
blend: { color: blendComponent, alpha: blendComponent },
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [kSize, kSize],
format,
@ -524,7 +524,7 @@ g.test('blend_constant,not_inherited')
blend: { color: blendComponent, alpha: blendComponent },
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [kSize, kSize],
format,
@ -627,7 +627,7 @@ g.test('color_write_mask,channel_work')
writeMask: mask,
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [kSize, kSize],
format,
@ -683,7 +683,7 @@ g.test('color_write_mask,blending_disabled')
writeMask: GPUColorWrite.RED,
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [kSize, kSize],
format,
@ -779,7 +779,7 @@ g.test('blending,clamping')
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
size: [1, 1, 1],
format,

36
src/webgpu/api/operation/rendering/depth.spec.ts
View file

@ -25,24 +25,20 @@ class DepthTest extends TextureTestMixin(GPUTest) {
runDepthStateTest(testStates: TestStates[], expectedColor: Float32Array) {
const renderTargetFormat = 'rgba8unorm';
const renderTarget = this.trackForCleanup(
this.device.createTexture({
format: renderTargetFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
})
);
const renderTarget = this.createTextureTracked({
format: renderTargetFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const depthStencilFormat: GPUTextureFormat = 'depth24plus-stencil8';
const depthTexture = this.trackForCleanup(
this.device.createTexture({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: depthStencilFormat,
sampleCount: 1,
mipLevelCount: 1,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST,
})
);
const depthTexture = this.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: depthStencilFormat,
sampleCount: 1,
mipLevelCount: 1,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST,
});
const depthStencilAttachment: GPURenderPassDepthStencilAttachment = {
view: depthTexture.createView(),
@ -347,14 +343,14 @@ g.test('depth_compare_func')
const { depthCompare, depthClearValue, _expected, format } = t.params;
const colorAttachmentFormat = 'rgba8unorm';
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: colorAttachmentFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const colorAttachmentView = colorAttachment.createView();
const depthTexture = t.device.createTexture({
const depthTexture = t.createTextureTracked({
size: { width: 1, height: 1 },
format,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
@ -439,7 +435,7 @@ g.test('reverse_depth')
.params(u => u.combine('reversed', [false, true]))
.fn(t => {
const colorAttachmentFormat = 'rgba8unorm';
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: colorAttachmentFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -447,7 +443,7 @@ g.test('reverse_depth')
const colorAttachmentView = colorAttachment.createView();
const depthBufferFormat = 'depth32float';
const depthTexture = t.device.createTexture({
const depthTexture = t.createTextureTracked({
size: { width: 1, height: 1 },
format: depthBufferFormat,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,

28
src/webgpu/api/operation/rendering/depth_bias.spec.ts
View file

@ -87,23 +87,19 @@ class DepthBiasTest extends TextureTestMixin(GPUTest) {
unreachable();
}
const renderTarget = this.trackForCleanup(
this.device.createTexture({
format: renderTargetFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
})
);
const renderTarget = this.createTextureTracked({
format: renderTargetFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const depthTexture = this.trackForCleanup(
this.device.createTexture({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: depthFormat,
sampleCount: 1,
mipLevelCount: 1,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
})
);
const depthTexture = this.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: depthFormat,
sampleCount: 1,
mipLevelCount: 1,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
});
const depthStencilAttachment: GPURenderPassDepthStencilAttachment = {
view: depthTexture.createView(),

22
src/webgpu/api/operation/rendering/depth_clip_clamp.spec.ts
View file

@ -204,7 +204,7 @@ have unexpected values then get drawn to the color buffer, which is later checke
fragment: { module, entryPoint: 'fcheck', targets: [{ format: 'r8unorm' }] },
});
const dsTexture = t.device.createTexture({
const dsTexture = t.createTextureTracked({
format,
size: [kNumTestPoints],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
@ -217,32 +217,32 @@ have unexpected values then get drawn to the color buffer, which is later checke
size: [kNumTestPoints],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
};
const checkTexture = t.device.createTexture(checkTextureDesc);
const checkTexture = t.createTextureTracked(checkTextureDesc);
const checkTextureView = checkTexture.createView();
const checkTextureMSView = multisampled
? t.device.createTexture({ ...checkTextureDesc, sampleCount: 4 }).createView()
? t.createTextureTracked({ ...checkTextureDesc, sampleCount: 4 }).createView()
: undefined;
const dsActual =
!multisampled && info.depth.bytes
? t.device.createBuffer({
? t.createBufferTracked({
size: kNumTestPoints * info.depth.bytes,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
})
: undefined;
const dsExpected =
!multisampled && info.depth.bytes
? t.device.createBuffer({
? t.createBufferTracked({
size: kNumTestPoints * info.depth.bytes,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
})
: undefined;
const checkBuffer = t.device.createBuffer({
const checkBuffer = t.createBufferTracked({
size: kNumTestPoints,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
const fragInputZFailedBuffer = t.device.createBuffer({
const fragInputZFailedBuffer = t.createBufferTracked({
size: 4 * kNumTestPoints,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
});
@ -453,7 +453,7 @@ to be empty.`
fragment: { module, entryPoint: 'ftest', targets: [{ format: 'r8unorm' }] },
});
const dsTexture = t.device.createTexture({
const dsTexture = t.createTextureTracked({
format,
size: [kNumDepthValues],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
@ -466,13 +466,13 @@ to be empty.`
size: [kNumDepthValues],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
};
const testTexture = t.device.createTexture(testTextureDesc);
const testTexture = t.createTextureTracked(testTextureDesc);
const testTextureView = testTexture.createView();
const testTextureMSView = multisampled
? t.device.createTexture({ ...testTextureDesc, sampleCount: 4 }).createView()
? t.createTextureTracked({ ...testTextureDesc, sampleCount: 4 }).createView()
: undefined;
const resultBuffer = t.device.createBuffer({
const resultBuffer = t.createBufferTracked({
size: kNumDepthValues,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});

10
src/webgpu/api/operation/rendering/draw.spec.ts
View file

@ -61,7 +61,7 @@ class DrawTest extends TextureTestMixin(GPUTest) {
1.0, 1.0,
];
const renderTarget = this.device.createTexture({
const renderTarget = this.createTextureTracked({
size: renderTargetSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: 'rgba8unorm',
@ -136,7 +136,7 @@ struct Output {
},
});
const resultBuffer = this.device.createBuffer({
const resultBuffer = this.createBufferTracked({
size: Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
});
@ -685,7 +685,7 @@ ${accumulateVariableAssignmentsInFragmentShader}
},
});
const resultBuffer = t.device.createBuffer({
const resultBuffer = t.createBufferTracked({
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
size: vertexCount * instanceCount * vertexInputShaderLocations.length * 4,
});
@ -708,8 +708,8 @@ ${accumulateVariableAssignmentsInFragmentShader}
{
// Dummy render attachment - not used (WebGPU doesn't allow using a render pass with no
// attachments)
view: t.device
.createTexture({
view: t
.createTextureTracked({
usage: GPUTextureUsage.RENDER_ATTACHMENT,
size: [1],
format: 'rgba8unorm',

2
src/webgpu/api/operation/rendering/indirect_draw.spec.ts
View file

@ -204,7 +204,7 @@ Params:
},
});
const renderTarget = t.device.createTexture({
const renderTarget = t.createTextureTracked({
size: [4, 4],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
format: kRenderTargetFormat,

28
src/webgpu/api/operation/rendering/stencil.spec.ts
View file

@ -128,23 +128,19 @@ class StencilTest extends TextureTestMixin(GPUTest) {
isSingleEncoderMultiplePass: boolean = false
) {
const renderTargetFormat = 'rgba8unorm';
const renderTarget = this.trackForCleanup(
this.device.createTexture({
format: renderTargetFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
})
);
const renderTarget = this.createTextureTracked({
format: renderTargetFormat,
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const depthTexture = this.trackForCleanup(
this.device.createTexture({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: depthStencilFormat,
sampleCount: 1,
mipLevelCount: 1,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST,
})
);
const depthTexture = this.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: depthStencilFormat,
sampleCount: 1,
mipLevelCount: 1,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST,
});
const hasDepth = kTextureFormatInfo[depthStencilFormat].depth;
const depthStencilAttachment: GPURenderPassDepthStencilAttachment = {

72
src/webgpu/api/operation/resource_init/buffer.spec.ts
View file

@ -56,12 +56,11 @@ class F extends GPUTest {
entryPoint: 'main',
},
});
const outputTexture = this.device.createTexture({
const outputTexture = this.createTextureTracked({
format: 'rgba8unorm',
size: [1, 1, 1],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
this.trackForCleanup(outputTexture);
const bindGroup = this.device.createBindGroup({
layout: computePipeline.getBindGroupLayout(0),
entries: [
@ -176,11 +175,10 @@ the buffer, the remaining part of that buffer will be initialized to 0.`
const bufferSize = 32;
const appliedOffset = offset >= 0 ? offset : bufferSize + offset;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
t.trackForCleanup(buffer);
const copySize = 12;
const writeData = new Uint8Array(copySize);
@ -205,11 +203,10 @@ have already been initialized to 0.`
const bufferSize = 32;
const bufferUsage = t.GetBufferUsageFromMapMode(mapMode);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: bufferUsage,
});
t.trackForCleanup(buffer);
await buffer.mapAsync(mapMode);
const readData = new Uint8Array(buffer.getMappedRange());
@ -235,11 +232,10 @@ already been initialized to 0.`
const appliedOffset = offset >= 0 ? offset : bufferSize + offset;
const bufferUsage = t.GetBufferUsageFromMapMode(mapMode);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: bufferUsage,
});
t.trackForCleanup(buffer);
const expectedData = new Uint8Array(bufferSize);
{
@ -269,12 +265,11 @@ array buffer of getMappedRange() and the GPUBuffer itself have all been initiali
const { bufferUsage } = t.params;
const bufferSize = 32;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
mappedAtCreation: true,
size: bufferSize,
usage: bufferUsage,
});
t.trackForCleanup(buffer);
const mapped = new Uint8Array(buffer.getMappedRange());
for (let i = 0; i < bufferSize; ++i) {
@ -303,12 +298,11 @@ array buffer of getMappedRange() and the GPUBuffer itself have all been initiali
const bufferSize = 32;
const appliedOffset = offset >= 0 ? offset : bufferSize + offset;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
mappedAtCreation: true,
size: bufferSize,
usage: bufferUsage,
});
t.trackForCleanup(buffer);
const expectedData = new Uint8Array(bufferSize);
{
@ -334,11 +328,10 @@ CopyBufferToBuffer(), the contents of the GPUBuffer have already been initialize
.fn(t => {
const bufferSize = 32;
const bufferUsage = GPUBufferUsage.COPY_SRC;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: bufferUsage,
});
t.trackForCleanup(buffer);
const expectedData = new Uint8Array(bufferSize);
// copyBufferToBuffer() is called inside t.CheckGPUBufferContent().
@ -356,20 +349,18 @@ CopyBufferToTexture(), the contents of the GPUBuffer have already been initializ
const textureSize: [number, number, number] = [8, 8, 1];
const dstTextureFormat = 'rgba8unorm';
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: textureSize,
format: dstTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
});
t.trackForCleanup(dstTexture);
const layout = getTextureCopyLayout(dstTextureFormat, '2d', textureSize);
const srcBufferSize = layout.byteLength + bufferOffset;
const srcBufferUsage = GPUBufferUsage.COPY_SRC;
const srcBuffer = t.device.createBuffer({
const srcBuffer = t.createBufferTracked({
size: srcBufferSize,
usage: srcBufferUsage,
});
t.trackForCleanup(srcBuffer);
const encoder = t.device.createCommandEncoder();
encoder.copyBufferToTexture(
@ -402,11 +393,10 @@ remaining part of it will be initialized to 0.`
const { bufferOffset } = t.params;
const bufferSize = bufferOffset + 8;
const bufferUsage = GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE;
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: bufferSize,
usage: bufferUsage,
});
t.trackForCleanup(dstBuffer);
const querySet = t.createQuerySetTracked({ type: 'occlusion', count: 1 });
const encoder = t.device.createCommandEncoder();
@ -438,13 +428,12 @@ remaining part of it will be initialized to 0.`
const srcTextureFormat = 'r8uint';
const textureSize = [32, 16, arrayLayerCount] as const;
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
format: srcTextureFormat,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
size: textureSize,
mipLevelCount: copyMipLevel + 1,
});
t.trackForCleanup(srcTexture);
const bytesPerRow = 256;
const layout = getTextureCopyLayout(srcTextureFormat, '2d', textureSize, {
@ -454,11 +443,10 @@ remaining part of it will be initialized to 0.`
});
const dstBufferSize = layout.byteLength + Math.abs(bufferOffset);
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: dstBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
t.trackForCleanup(dstBuffer);
const encoder = t.device.createCommandEncoder();
@ -513,11 +501,10 @@ g.test('uniform_buffer')
const { bufferOffset } = t.params;
const boundBufferSize = 16;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferOffset + boundBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM,
});
t.trackForCleanup(buffer);
const computeShaderModule = t.device.createShaderModule({
code: `
@ -549,11 +536,10 @@ g.test('readonly_storage_buffer')
.fn(t => {
const { bufferOffset } = t.params;
const boundBufferSize = 16;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferOffset + boundBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
});
t.trackForCleanup(buffer);
const computeShaderModule = t.device.createShaderModule({
code: `
@ -585,11 +571,10 @@ g.test('storage_buffer')
.fn(t => {
const { bufferOffset } = t.params;
const boundBufferSize = 16;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferOffset + boundBufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
});
t.trackForCleanup(buffer);
const computeShaderModule = t.device.createShaderModule({
code: `
@ -644,18 +629,16 @@ g.test('vertex_buffer')
);
const bufferSize = 16 + bufferOffset;
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_SRC,
});
t.trackForCleanup(vertexBuffer);
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: [1, 1, 1],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
t.trackForCleanup(outputTexture);
const encoder = t.device.createCommandEncoder();
const renderPass = encoder.beginRenderPass({
@ -711,18 +694,16 @@ GPUBuffer, all the contents in that GPUBuffer have been initialized to 0.`
// The size of GPUBuffer must be at least 4.
const bufferSize = 4 + bufferOffset;
const indexBuffer = t.device.createBuffer({
const indexBuffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_SRC,
});
t.trackForCleanup(indexBuffer);
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: [1, 1, 1],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
t.trackForCleanup(outputTexture);
const encoder = t.device.createCommandEncoder();
const renderPass = encoder.beginRenderPass({
@ -778,18 +759,16 @@ have been initialized to 0.`
const kDrawIndexedIndirectParametersSize = 20;
const bufferSize =
Math.max(kDrawIndirectParametersSize, kDrawIndexedIndirectParametersSize) + bufferOffset;
const indirectBuffer = t.device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT,
});
t.trackForCleanup(indirectBuffer);
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: [1, 1, 1],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
t.trackForCleanup(outputTexture);
// Initialize outputTexture to green.
const encoder = t.device.createCommandEncoder();
@ -808,11 +787,10 @@ have been initialized to 0.`
let indexBuffer = undefined;
if (test_indexed_draw) {
indexBuffer = t.device.createBuffer({
indexBuffer = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.INDEX,
});
t.trackForCleanup(indexBuffer);
renderPass.setIndexBuffer(indexBuffer, 'uint16');
renderPass.drawIndexedIndirect(indirectBuffer, bufferOffset);
} else {
@ -854,13 +832,12 @@ g.test('indirect_buffer_for_dispatch_indirect')
const kDispatchIndirectParametersSize = 12;
const bufferSize = kDispatchIndirectParametersSize + bufferOffset;
const indirectBuffer = t.device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT,
});
t.trackForCleanup(indirectBuffer);
const outputTexture = t.device.createTexture({
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: [1, 1, 1],
usage:
@ -868,7 +845,6 @@ g.test('indirect_buffer_for_dispatch_indirect')
GPUTextureUsage.RENDER_ATTACHMENT |
GPUTextureUsage.STORAGE_BINDING,
});
t.trackForCleanup(outputTexture);
// Initialize outputTexture to green.
const encoder = t.device.createCommandEncoder();

3
src/webgpu/api/operation/resource_init/check_texture/by_copy.ts
View file

@ -42,13 +42,12 @@ export const checkContentsByTextureCopy: CheckContents = (
level
);
const dst = t.device.createTexture({
const dst = t.createTextureTracked({
dimension: params.dimension,
size: [width, height, depth],
format: params.format,
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
t.trackForCleanup(dst);
const commandEncoder = t.device.createCommandEncoder();
commandEncoder.copyTextureToTexture(

4
src/webgpu/api/operation/resource_init/check_texture/by_ds_test.ts
View file

@ -120,7 +120,7 @@ const checkContents: (type: 'depth' | 'stencil', ...args: Parameters<CheckConten
viewDescriptor.baseMipLevel
);
const renderTexture = t.device.createTexture({
const renderTexture = t.createTextureTracked({
size: [width, height, 1],
format: 'r8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
@ -130,7 +130,7 @@ const checkContents: (type: 'depth' | 'stencil', ...args: Parameters<CheckConten
let resolveTexture = undefined;
let resolveTarget = undefined;
if (params.sampleCount > 1) {
resolveTexture = t.device.createTexture({
resolveTexture = t.createTextureTracked({
size: [width, height, 1],
format: 'r8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,

5
src/webgpu/api/operation/resource_init/check_texture/by_sampling.ts
View file

@ -96,7 +96,7 @@ export const checkContentsBySampling: CheckContents = (
});
for (const layer of layers) {
const ubo = t.device.createBuffer({
const ubo = t.createBufferTracked({
mappedAtCreation: true,
size: 8,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
@ -106,11 +106,10 @@ export const checkContentsBySampling: CheckContents = (
const byteLength =
width * height * depth * ReadbackTypedArray.BYTES_PER_ELEMENT * rep.componentOrder.length;
const resultBuffer = t.device.createBuffer({
const resultBuffer = t.createBufferTracked({
size: byteLength,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
});
t.trackForCleanup(resultBuffer);
const viewDescriptor: GPUTextureViewDescriptor = {
...(!t.isCompatibility && {

2
src/webgpu/api/operation/resource_init/check_texture/texture_zero_init_test.ts
View file

@ -363,8 +363,8 @@ export class TextureZeroInitTest extends GPUTest {
const rep = kTexelRepresentationInfo[format];
const texelData = new Uint8Array(rep.pack(rep.encode(this.stateToTexelComponents[state])));
const { buffer, bytesPerRow, rowsPerImage } = createTextureUploadBuffer(
this,
texelData,
this.device,
format,
this.p.dimension,
[largestWidth, largestHeight, largestDepth]

3
src/webgpu/api/operation/resource_init/texture_zero.spec.ts
View file

@ -53,7 +53,7 @@ g.test('uninitialized_texture_is_zero')
t.params.readMethod
);
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: [t.textureWidth, t.textureHeight, t.textureDepthOrArrayLayers],
format: t.params.format,
dimension: t.params.dimension,
@ -61,7 +61,6 @@ g.test('uninitialized_texture_is_zero')
mipLevelCount: t.params.mipLevelCount,
sampleCount: t.params.sampleCount,
});
t.trackForCleanup(texture);
if (t.params.canaryOnCreation) {
// Initialize some subresources with canary values

6
src/webgpu/api/operation/sampling/anisotropy.spec.ts
View file

@ -36,7 +36,7 @@ const checkerColors = [
class SamplerAnisotropicFilteringSlantedPlaneTest extends GPUTest {
copyRenderTargetToBuffer(rt: GPUTexture): GPUBuffer {
const byteLength = kRTSize * kBytesPerRow;
const buffer = this.device.createBuffer({
const buffer = this.createBufferTracked({
size: byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
@ -133,7 +133,7 @@ class SamplerAnisotropicFilteringSlantedPlaneTest extends GPUTest {
layout: this.pipeline.getBindGroupLayout(0),
});
const colorAttachment = this.device.createTexture({
const colorAttachment = this.createTextureTracked({
format: kColorAttachmentFormat,
size: { width: kRTSize, height: kRTSize, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
@ -176,7 +176,7 @@ g.test('anisotropic_filter_checkerboard')
.fn(async t => {
// init texture with only a top level mipmap
const textureSize = 32;
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
mipLevelCount: 1,
size: { width: textureSize, height: textureSize, depthOrArrayLayers: 1 },
format: kTextureFormat,

4
src/webgpu/api/operation/sampling/filter_mode.spec.ts
View file

@ -41,7 +41,7 @@ class FilterModeTest extends TextureTestMixin(GPUTest) {
usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
}
);
const renderTexture = this.device.createTexture({
const renderTexture = this.createTextureTracked({
format,
size: renderSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
@ -1000,7 +1000,7 @@ g.test('mipmapFilter')
usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
}
);
const renderTexture = t.device.createTexture({
const renderTexture = t.createTextureTracked({
format,
size: [kRenderSize, 1],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,

12
src/webgpu/api/operation/storage_texture/read_only.spec.ts
View file

@ -396,12 +396,11 @@ class F extends GPUTest {
entries: bindGroupEntries,
});
const placeholderColorTexture = this.device.createTexture({
const placeholderColorTexture = this.createTextureTracked({
size: [storageTexture.width, storageTexture.height, 1],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
format: 'rgba8unorm',
});
this.trackForCleanup(placeholderColorTexture);
const renderPassEncoder = commandEncoder.beginRenderPass({
colorAttachments: [
@ -529,12 +528,11 @@ class F extends GPUTest {
entries: bindGroupEntries,
});
const placeholderColorTexture = this.device.createTexture({
const placeholderColorTexture = this.createTextureTracked({
size: [storageTexture.width, storageTexture.height, 1],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
format: 'rgba8unorm',
});
this.trackForCleanup(placeholderColorTexture);
const renderPassEncoder = commandEncoder.beginRenderPass({
colorAttachments: [
@ -590,21 +588,19 @@ g.test('basic')
const kWidth = 8;
const height = dimension === '1d' ? 1 : 8;
const storageTexture = t.device.createTexture({
const storageTexture = t.createTextureTracked({
format,
dimension,
size: [kWidth, height, depthOrArrayLayers],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
t.trackForCleanup(storageTexture);
const expectedData = t.InitTextureAndGetExpectedOutputBufferData(storageTexture, format);
const outputBuffer = t.device.createBuffer({
const outputBuffer = t.createBufferTracked({
size: 4 * 4 * kWidth * height * depthOrArrayLayers,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE,
});
t.trackForCleanup(outputBuffer);
t.DoTransform(storageTexture, shaderStage, format, outputBuffer);

9
src/webgpu/api/operation/storage_texture/read_write.spec.ts
View file

@ -208,12 +208,11 @@ class F extends GPUTest {
],
});
const placeholderColorTexture = device.createTexture({
const placeholderColorTexture = this.createTextureTracked({
size: [rwTexture.width, rwTexture.height, 1],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
format: 'rgba8unorm',
});
this.trackForCleanup(placeholderColorTexture);
const renderPassEncoder = commandEncoder.beginRenderPass({
colorAttachments: [
@ -327,13 +326,12 @@ g.test('basic')
const kWidth = t.isCompatibility ? 8 : 16;
const height = textureDimension === '1d' ? 1 : 8;
const textureSize = [kWidth, height, depthOrArrayLayers] as const;
const storageTexture = t.device.createTexture({
const storageTexture = t.createTextureTracked({
format,
dimension: textureDimension,
size: textureSize,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
});
t.trackForCleanup(storageTexture);
const bytesPerBlock = kTextureFormatInfo[format].bytesPerBlock;
const initialData = t.GetInitialData(storageTexture);
@ -352,11 +350,10 @@ g.test('basic')
t.RecordCommandsToTransform(t.device, shaderStage, commandEncoder, storageTexture);
const expectedData = t.GetExpectedData(shaderStage, storageTexture, initialData);
const readbackBuffer = t.device.createBuffer({
const readbackBuffer = t.createBufferTracked({
size: expectedData.byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
t.trackForCleanup(readbackBuffer);
const bytesPerRow = align(bytesPerBlock * kWidth, 256);
commandEncoder.copyTextureToBuffer(
{

58
src/webgpu/api/operation/texture_view/format_reinterpretation.spec.ts
View file

@ -148,13 +148,11 @@ g.test('texture_binding')
});
// Create an rgba8unorm output texture.
const outputTexture = t.trackForCleanup(
t.device.createTexture({
format: 'rgba8unorm',
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC,
})
);
const outputTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.COPY_SRC,
});
// Execute a compute pass to load data from the reinterpreted view and
// write out to the rgba8unorm texture.
@ -221,29 +219,25 @@ in view format and match in base format.`
const inputTexelView = makeInputTexelView(format);
// Create the renderTexture as |format|.
const renderTexture = t.trackForCleanup(
t.device.createTexture({
format,
size: [kTextureSize, kTextureSize],
usage:
GPUTextureUsage.RENDER_ATTACHMENT |
(sampleCount > 1 ? GPUTextureUsage.TEXTURE_BINDING : GPUTextureUsage.COPY_SRC),
viewFormats: [viewFormat],
sampleCount,
})
);
const renderTexture = t.createTextureTracked({
format,
size: [kTextureSize, kTextureSize],
usage:
GPUTextureUsage.RENDER_ATTACHMENT |
(sampleCount > 1 ? GPUTextureUsage.TEXTURE_BINDING : GPUTextureUsage.COPY_SRC),
viewFormats: [viewFormat],
sampleCount,
});
const resolveTexture =
sampleCount === 1
? undefined
: t.trackForCleanup(
t.device.createTexture({
format,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [viewFormat],
})
);
: t.createTextureTracked({
format,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [viewFormat],
});
// Create the sample source with the contents of the input texel view.
// We will sample this texture into |renderTexture|. It uses the same format to keep the same
@ -295,13 +289,11 @@ in view format and match in base format.`
// If the render target is multisampled, we'll manually resolve it to check
// the contents.
const singleSampleRenderTexture = resolveTexture
? t.trackForCleanup(
t.device.createTexture({
format,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
})
)
? t.createTextureTracked({
format,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
})
: renderTexture;
if (resolveTexture) {

40
src/webgpu/api/operation/texture_view/write.spec.ts
View file

@ -136,13 +136,11 @@ function writeTextureAndGetExpectedTexelView(
// The size of which equals that of format texture we are testing,
// so that we have the same number of fragments and texels.
const kPlaceholderTextureFormat = 'rgba8unorm';
const placeholderTexture = t.trackForCleanup(
t.device.createTexture({
format: kPlaceholderTextureFormat,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
);
const placeholderTexture = t.createTextureTracked({
format: kPlaceholderTextureFormat,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
const pipeline = t.device.createRenderPipeline({
layout: 'auto',
@ -210,14 +208,12 @@ function writeTextureAndGetExpectedTexelView(
method === 'render-pass-store'
? view
: t
.trackForCleanup(
t.device.createTexture({
format,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: 4,
})
)
.createTextureTracked({
format,
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: 4,
})
.createView();
const resolveView = method === 'render-pass-store' ? undefined : view;
const multisampleCount = method === 'render-pass-store' ? sampleCount : 4;
@ -344,14 +340,12 @@ TODO: Test rgb10a2uint when TexelRepresentation.numericRange is made per-compone
? GPUTextureUsage.STORAGE_BINDING
: GPUTextureUsage.RENDER_ATTACHMENT);
const texture = t.trackForCleanup(
t.device.createTexture({
format,
usage,
size: [kTextureSize, kTextureSize],
sampleCount,
})
);
const texture = t.createTextureTracked({
format,
usage,
size: [kTextureSize, kTextureSize],
sampleCount,
});
const view = texture.createView();
const expectedTexelView = writeTextureAndGetExpectedTexelView(

2
src/webgpu/api/operation/vertex_state/correctness.spec.ts
View file

@ -282,7 +282,7 @@ struct VSOutputs {
vertexCount: number,
instanceCount: number
) {
const testTexture = this.device.createTexture({
const testTexture = this.createTextureTracked({
format: 'r32sint',
size: [vertexCount, instanceCount],
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,

16
src/webgpu/api/operation/vertex_state/index_format.spec.ts
View file

@ -119,13 +119,13 @@ class IndexFormatTest extends GPUTest {
pipeline = this.MakeRenderPipeline(primitiveTopology);
}
const colorAttachment = this.device.createTexture({
const colorAttachment = this.createTextureTracked({
format: kTextureFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const result = this.device.createBuffer({
const result = this.createBufferTracked({
size: byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
@ -233,13 +233,13 @@ g.test('index_format,change_pipeline_after_setIndexBuffer')
const pipeline32 = t.MakeRenderPipeline(kPrimitiveTopology, indexFormat32);
const pipeline16 = t.MakeRenderPipeline(kPrimitiveTopology, indexFormat16);
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: kTextureFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const result = t.device.createBuffer({
const result = t.createBufferTracked({
size: byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
@ -290,13 +290,13 @@ g.test('index_format,setIndexBuffer_before_setPipeline')
const kPrimitiveTopology = 'triangle-strip';
const pipeline = t.MakeRenderPipeline(kPrimitiveTopology, indexFormat);
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: kTextureFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const result = t.device.createBuffer({
const result = t.createBufferTracked({
size: byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
@ -350,13 +350,13 @@ g.test('index_format,setIndexBuffer_different_formats')
const expectedTextureValues = t.CreateExpectedUint8Array(kBottomLeftTriangle);
const colorAttachment = t.device.createTexture({
const colorAttachment = t.createTextureTracked({
format: kTextureFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const result = t.device.createBuffer({
const result = t.createBufferTracked({
size: byteLength,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});

8
src/webgpu/api/validation/buffer/create.spec.ts
View file

@ -38,7 +38,7 @@ g.test('size')
const usage = BufferUsage.COPY_SRC;
t.expectGPUError(
'validation',
() => t.device.createBuffer({ size, usage, mappedAtCreation }),
() => t.createBufferTracked({ size, usage, mappedAtCreation }),
!isValid
);
});
@ -51,7 +51,7 @@ g.test('limit')
const size = t.makeLimitVariant('maxBufferSize', { mult: 1, add: sizeAddition });
const isValid = size <= t.device.limits.maxBufferSize;
const usage = BufferUsage.COPY_SRC;
t.expectGPUError('validation', () => t.device.createBuffer({ size, usage }), !isValid);
t.expectGPUError('validation', () => t.createBufferTracked({ size, usage }), !isValid);
});
const kInvalidUsage = 0x8000;
@ -79,7 +79,7 @@ g.test('usage')
t.expectGPUError(
'validation',
() => t.device.createBuffer({ size: kBufferSizeAlignment * 2, usage, mappedAtCreation }),
() => t.createBufferTracked({ size: kBufferSizeAlignment * 2, usage, mappedAtCreation }),
!isValid
);
});
@ -109,5 +109,5 @@ hidden behind the "more severe" validation error.`
.fn(t => {
const { _valid, usage, size } = t.params;
t.expectGPUError('validation', () => t.device.createBuffer({ size, usage }), !_valid);
t.expectGPUError('validation', () => t.createBufferTracked({ size, usage }), !_valid);
});

6
src/webgpu/api/validation/buffer/destroy.spec.ts
View file

@ -17,7 +17,7 @@ g.test('all_usages')
)
.fn(t => {
const { usage } = t.params;
const buf = t.device.createBuffer({
const buf = t.createBufferTracked({
size: 4,
usage,
});
@ -48,7 +48,7 @@ g.test('twice')
])
)
.fn(t => {
const buf = t.device.createBuffer(t.params);
const buf = t.createBufferTracked(t.params);
buf.destroy();
buf.destroy();
@ -81,7 +81,7 @@ g.test('while_mapped')
)
.fn(async t => {
const { usage, mapMode, mappedAtCreation, unmapBeforeDestroy } = t.params;
const buf = t.device.createBuffer({
const buf = t.createBufferTracked({
size: 4,
usage,
mappedAtCreation,

38
src/webgpu/api/validation/buffer/mapping.spec.ts
View file

@ -85,12 +85,12 @@ class F extends ValidationTest {
createMappableBuffer(type: GPUMapModeFlags, size: number): GPUBuffer {
switch (type) {
case GPUMapMode.READ:
return this.device.createBuffer({
return this.createBufferTracked({
size,
usage: GPUBufferUsage.MAP_READ,
});
case GPUMapMode.WRITE:
return this.device.createBuffer({
return this.createBufferTracked({
size,
usage: GPUBufferUsage.MAP_WRITE,
});
@ -128,7 +128,7 @@ g.test('mapAsync,usage')
.fn(async t => {
const { mapMode, validUsage, usage } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage,
});
@ -194,7 +194,7 @@ g.test('mapAsync,state,mappedAtCreation')
.fn(async t => {
const { mapMode, validUsage } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: validUsage,
mappedAtCreation: true,
@ -477,7 +477,7 @@ g.test('getMappedRange,state,mappedAtCreation')
.fn(async t => {
const { bufferUsage, mapMode } = t.params;
const bufferSize = 16;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
usage: bufferUsage,
size: bufferSize,
mappedAtCreation: true,
@ -509,7 +509,7 @@ so the Content process doesn't necessarily know the buffer is invalid.`
)
.fn(t => {
const buffer = t.expectGPUError('validation', () =>
t.device.createBuffer({
t.createBufferTracked({
mappedAtCreation: true,
size: 16,
usage: 0xffff_ffff, // Invalid usage
@ -563,7 +563,7 @@ Test for various cases of being unmapped: at creation, after a mapAsync call or
// It is invalid to call getMappedRange when the buffer is unmapped after mappedAtCreation.
{
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
usage: GPUBufferUsage.MAP_READ,
size: 16,
mappedAtCreation: true,
@ -610,7 +610,7 @@ g.test('getMappedRange,subrange,mappedAtCreation')
const bufferSize = 16;
const offset = 8;
const subrangeSize = bufferSize - offset;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
mappedAtCreation: true,
@ -653,7 +653,7 @@ Test for various cases of being destroyed: at creation, after a mapAsync call or
// It is invalid to call getMappedRange when the buffer is destroyed when mapped at creation.
{
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
usage: GPUBufferUsage.MAP_READ,
size: 16,
mappedAtCreation: true,
@ -717,7 +717,7 @@ g.test('getMappedRange,offsetAndSizeAlignment,mappedAtCreation')
)
.fn(t => {
const { offset, size } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
mappedAtCreation: true,
@ -763,7 +763,7 @@ g.test('getMappedRange,sizeAndOffsetOOB,mappedAtCreation')
])
.fn(t => {
const { bufferSize, offset, size } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.COPY_DST,
mappedAtCreation: true,
@ -925,7 +925,7 @@ g.test('getMappedRange,disjointRanges')
)
.fn(async t => {
const { offset1, size1, offset2, size2, remapBetweenCalls } = t.params;
const buffer = t.device.createBuffer({ size: 80, usage: GPUBufferUsage.MAP_READ });
const buffer = t.createBufferTracked({ size: 80, usage: GPUBufferUsage.MAP_READ });
await buffer.mapAsync(GPUMapMode.READ);
t.testGetMappedRangeCall(true, buffer, offset1, size1);
@ -949,7 +949,7 @@ g.test('getMappedRange,disjoinRanges_many')
const kStride = 256;
const kNumStrides = 256;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: kStride * kNumStrides,
usage: GPUBufferUsage.MAP_READ,
});
@ -976,7 +976,7 @@ g.test('unmap,state,unmapped')
.fn(async t => {
// It is valid to call unmap after creation of an unmapped buffer.
{
const buffer = t.device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
const buffer = t.createBufferTracked({ size: 16, usage: GPUBufferUsage.MAP_READ });
buffer.unmap();
}
@ -990,7 +990,7 @@ g.test('unmap,state,unmapped')
// It is valid to call unmap after unmapping a mappedAtCreation buffer.
{
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
usage: GPUBufferUsage.MAP_READ,
size: 16,
mappedAtCreation: true,
@ -1008,7 +1008,7 @@ g.test('unmap,state,destroyed')
.fn(async t => {
// It is valid to call unmap after destruction of an unmapped buffer.
{
const buffer = t.device.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_READ });
const buffer = t.createBufferTracked({ size: 16, usage: GPUBufferUsage.MAP_READ });
buffer.destroy();
buffer.unmap();
}
@ -1023,7 +1023,7 @@ g.test('unmap,state,destroyed')
// It is valid to call unmap after destroying a mappedAtCreation buffer.
{
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
usage: GPUBufferUsage.MAP_READ,
size: 16,
mappedAtCreation: true,
@ -1041,7 +1041,7 @@ g.test('unmap,state,mappedAtCreation')
)
.fn(t => {
const { bufferUsage } = t.params;
const buffer = t.device.createBuffer({ size: 16, usage: bufferUsage, mappedAtCreation: true });
const buffer = t.createBufferTracked({ size: 16, usage: bufferUsage, mappedAtCreation: true });
buffer.unmap();
});
@ -1079,7 +1079,7 @@ g.test('gc_behavior,mappedAtCreation')
)
.fn(async t => {
let buffer = null;
buffer = t.device.createBuffer({
buffer = t.createBufferTracked({
size: 256,
usage: GPUBufferUsage.COPY_DST,
mappedAtCreation: true,

12
src/webgpu/api/validation/capability_checks/features/query_types.spec.ts
View file

@ -99,13 +99,11 @@ g.test('timestamp')
{
const encoder = t.createEncoder('non-pass');
const view = t
.trackForCleanup(
t.device.createTexture({
size: [16, 16, 1],
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
)
.createTextureTracked({
size: [16, 16, 1],
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
.createView();
encoder.encoder
.beginRenderPass({

6
src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
View file

@ -38,7 +38,7 @@ g.test('texture_descriptor')
const formatInfo = kTextureFormatInfo[format];
t.shouldThrow(enable_required_feature ? false : 'TypeError', () => {
t.device.createTexture({
t.createTextureTracked({
format,
size: [formatInfo.blockWidth, formatInfo.blockHeight, 1] as const,
usage: GPUTextureUsage.TEXTURE_BINDING,
@ -69,7 +69,7 @@ g.test('texture_descriptor_view_formats')
const formatInfo = kTextureFormatInfo[format];
t.shouldThrow(enable_required_feature ? false : 'TypeError', () => {
t.device.createTexture({
t.createTextureTracked({
format,
size: [formatInfo.blockWidth, formatInfo.blockHeight, 1] as const,
usage: GPUTextureUsage.TEXTURE_BINDING,
@ -107,7 +107,7 @@ g.test('texture_view_descriptor')
const textureFormat = enable_required_feature ? format : 'rgba8unorm';
const formatInfo = kTextureFormatInfo[format];
const testTexture = t.device.createTexture({
const testTexture = t.createTextureTracked({
format: textureFormat,
size: [formatInfo.blockWidth, formatInfo.blockHeight, 1] as const,
usage: GPUTextureUsage.TEXTURE_BINDING,

42
src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
View file

@ -892,20 +892,16 @@ export class LimitTestsImpl extends GPUTestBase {
switch (encoderType) {
case 'render': {
const buffer = this.trackForCleanup(
device.createBuffer({
size: 16,
usage: GPUBufferUsage.UNIFORM,
})
);
const buffer = this.createBufferTracked({
size: 16,
usage: GPUBufferUsage.UNIFORM,
});
const texture = this.trackForCleanup(
device.createTexture({
size: [1, 1],
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
);
const texture = this.createTextureTracked({
size: [1, 1],
format: 'rgba8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
const layout = device.createBindGroupLayout({
entries: [
@ -952,12 +948,10 @@ export class LimitTestsImpl extends GPUTestBase {
}
case 'renderBundle': {
const buffer = this.trackForCleanup(
device.createBuffer({
size: 16,
usage: GPUBufferUsage.UNIFORM,
})
);
const buffer = this.createBufferTracked({
size: 16,
usage: GPUBufferUsage.UNIFORM,
});
const layout = device.createBindGroupLayout({
entries: [
@ -1027,12 +1021,10 @@ export class LimitTestsImpl extends GPUTestBase {
switch (encoderType) {
case 'compute': {
const buffer = this.trackForCleanup(
device.createBuffer({
size: 16,
usage: GPUBufferUsage.UNIFORM,
})
);
const buffer = this.createBufferTracked({
size: 16,
usage: GPUBufferUsage.UNIFORM,
});
const layout = device.createBindGroupLayout({
entries: [

9
src/webgpu/api/validation/capability_checks/limits/maxBindGroupsPlusVertexBuffers.spec.ts
View file

@ -232,11 +232,10 @@ g.test('draw,at_over')
fragment: { module, targets: [{ format: 'rgba8unorm' }] },
});
const vertexBuffer = device.createBuffer({
const vertexBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.VERTEX,
});
t.trackForCleanup(vertexBuffer);
await t.testGPURenderAndBindingCommandsMixin(
encoderType,
@ -261,17 +260,15 @@ g.test('draw,at_over')
passEncoder.setPipeline(pipeline);
const indirectBuffer = device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: 20,
usage: GPUBufferUsage.INDIRECT,
});
t.trackForCleanup(indirectBuffer);
const indexBuffer = device.createBuffer({
const indexBuffer = t.createBufferTracked({
size: 4,
usage: GPUBufferUsage.INDEX,
});
t.trackForCleanup(indexBuffer);
switch (drawType) {
case 'draw':

5
src/webgpu/api/validation/capability_checks/limits/maxBufferSize.spec.ts
View file

@ -11,14 +11,13 @@ g.test('createBuffer,at_over')
await t.testDeviceWithRequestedMaximumLimits(
limitTest,
testValueName,
async ({ device, testValue, actualLimit, shouldError }) => {
async ({ testValue, actualLimit, shouldError }) => {
await t.testForValidationErrorWithPossibleOutOfMemoryError(
() => {
const buffer = device.createBuffer({
t.createBufferTracked({
usage: GPUBufferUsage.VERTEX,
size: testValue,
});
buffer.destroy();
},
shouldError,
`size: ${testValue}, limit: ${actualLimit}`

12
src/webgpu/api/validation/capability_checks/limits/maxColorAttachmentBytesPerSample.spec.ts
View file

@ -132,13 +132,11 @@ function getPipelineDescriptor(
function createTextures(t: LimitTestsImpl, targets: GPUColorTargetState[]) {
return targets.map(({ format }) =>
t.trackForCleanup(
t.device.createTexture({
size: [1, 1],
format,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
)
t.createTextureTracked({
size: [1, 1],
format,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
);
}

12
src/webgpu/api/validation/capability_checks/limits/maxColorAttachments.spec.ts
View file

@ -59,13 +59,11 @@ g.test('beginRenderPass,at_over')
const encoder = device.createCommandEncoder();
const textures = range(testValue, _ =>
t.trackForCleanup(
device.createTexture({
size: [1, 1],
format: 'r8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
)
t.createTextureTracked({
size: [1, 1],
format: 'r8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
})
);
const pass = encoder.beginRenderPass({

2
src/webgpu/api/validation/capability_checks/limits/maxComputeWorkgroupsPerDimension.spec.ts
View file

@ -39,7 +39,7 @@ g.test('dispatchWorkgroups,at_over')
const counts = [1, 1, 1];
counts[axis] = testValue;
const buffer = device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.STORAGE,
});

10
src/webgpu/api/validation/capability_checks/limits/maxStorageBufferBindingSize.spec.ts
View file

@ -110,12 +110,10 @@ g.test('createBindGroup,at_over')
}
device.pushErrorScope('out-of-memory');
const storageBuffer = t.trackForCleanup(
device.createBuffer({
usage: GPUBufferUsage.STORAGE,
size,
})
);
const storageBuffer = t.createBufferTracked({
usage: GPUBufferUsage.STORAGE,
size,
});
const outOfMemoryError = await device.popErrorScope();
if (!outOfMemoryError) {

4
src/webgpu/api/validation/capability_checks/limits/maxTextureArrayLayers.spec.ts
View file

@ -11,9 +11,9 @@ g.test('createTexture,at_over')
await t.testDeviceWithRequestedMaximumLimits(
limitTest,
testValueName,
async ({ device, testValue, shouldError }) => {
async ({ testValue, shouldError }) => {
await t.testForValidationErrorWithPossibleOutOfMemoryError(() => {
const texture = device.createTexture({
const texture = t.createTextureTracked({
size: [1, 1, testValue],
format: 'rgba8unorm',
usage: GPUTextureUsage.TEXTURE_BINDING,

4
src/webgpu/api/validation/capability_checks/limits/maxTextureDimension1D.spec.ts
View file

@ -11,9 +11,9 @@ g.test('createTexture,at_over')
await t.testDeviceWithRequestedMaximumLimits(
limitTest,
testValueName,
async ({ device, testValue, shouldError }) => {
async ({ testValue, shouldError }) => {
await t.testForValidationErrorWithPossibleOutOfMemoryError(() => {
const texture = device.createTexture({
const texture = t.createTextureTracked({
size: [testValue, 1, 1],
format: 'rgba8unorm',
dimension: '1d',

4
src/webgpu/api/validation/capability_checks/limits/maxTextureDimension2D.spec.ts
View file

@ -14,14 +14,14 @@ g.test('createTexture,at_over')
await t.testDeviceWithRequestedMaximumLimits(
limitTest,
testValueName,
async ({ device, shouldError, testValue, actualLimit }) => {
async ({ shouldError, testValue, actualLimit }) => {
for (let dimensionIndex = 0; dimensionIndex < 2; ++dimensionIndex) {
const size = [1, 1, 1];
size[dimensionIndex] = testValue;
await t.testForValidationErrorWithPossibleOutOfMemoryError(
() => {
const texture = device.createTexture({
const texture = t.createTextureTracked({
size,
format: 'rgba8unorm',
usage: GPUTextureUsage.TEXTURE_BINDING,

4
src/webgpu/api/validation/capability_checks/limits/maxTextureDimension3D.spec.ts
View file

@ -11,13 +11,13 @@ g.test('createTexture,at_over')
await t.testDeviceWithRequestedMaximumLimits(
limitTest,
testValueName,
async ({ device, shouldError, testValue }) => {
async ({ shouldError, testValue }) => {
for (let dimensionIndex = 0; dimensionIndex < 3; ++dimensionIndex) {
const size = [2, 2, 2];
size[dimensionIndex] = testValue;
await t.testForValidationErrorWithPossibleOutOfMemoryError(() => {
const texture = device.createTexture({
const texture = t.createTextureTracked({
size,
format: 'rgba8unorm',
dimension: '3d',

10
src/webgpu/api/validation/capability_checks/limits/maxUniformBufferBindingSize.spec.ts
View file

@ -47,12 +47,10 @@ g.test('createBindGroup,at_over')
}
device.pushErrorScope('out-of-memory');
const uniformBuffer = t.trackForCleanup(
device.createBuffer({
usage: GPUBufferUsage.UNIFORM,
size,
})
);
const uniformBuffer = t.createBufferTracked({
usage: GPUBufferUsage.UNIFORM,
size,
});
const outOfMemoryError = await device.popErrorScope();
if (!outOfMemoryError) {

4
src/webgpu/api/validation/capability_checks/limits/maxVertexBuffers.spec.ts
View file

@ -55,10 +55,10 @@ g.test('setVertexBuffer,at_over')
await t.testDeviceWithRequestedMaximumLimits(
limitTest,
testValueName,
async ({ device, testValue, shouldError, actualLimit }) => {
async ({ testValue, shouldError, actualLimit }) => {
const lastIndex = testValue - 1;
const buffer = device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.VERTEX,
});

12
src/webgpu/api/validation/capability_checks/limits/minStorageBufferOffsetAlignment.spec.ts
View file

@ -70,12 +70,10 @@ g.test('createBindGroup,at_over')
requestedLimit,
testValue,
async ({ device, testValue, shouldError }) => {
const storageBuffer = t.trackForCleanup(
device.createBuffer({
size: testValue * 2,
usage: GPUBufferUsage.STORAGE,
})
);
const storageBuffer = t.createBufferTracked({
size: testValue * 2,
usage: GPUBufferUsage.STORAGE,
});
const layout = device.createBindGroupLayout({
entries: [
@ -123,7 +121,7 @@ g.test('setBindGroup,at_over')
requestedLimit,
testValue,
async ({ device, testValue, shouldError }) => {
const buffer = device.createBuffer({
const buffer = t.createBufferTracked({
size: testValue * 2,
usage: GPUBufferUsage.STORAGE,
});

12
src/webgpu/api/validation/capability_checks/limits/minUniformBufferOffsetAlignment.spec.ts
View file

@ -73,12 +73,10 @@ g.test('createBindGroup,at_over')
requestedLimit,
testValue,
async ({ device, testValue, shouldError }) => {
const buffer = t.trackForCleanup(
device.createBuffer({
size: testValue * 2,
usage: GPUBufferUsage.UNIFORM,
})
);
const buffer = t.createBufferTracked({
size: testValue * 2,
usage: GPUBufferUsage.UNIFORM,
});
const layout = device.createBindGroupLayout({
entries: [
@ -126,7 +124,7 @@ g.test('setBindGroup,at_over')
requestedLimit,
testValue,
async ({ device, testValue, shouldError }) => {
const buffer = device.createBuffer({
const buffer = t.createBufferTracked({
size: testValue * 2,
usage: GPUBufferUsage.UNIFORM,
});

28
src/webgpu/api/validation/createBindGroup.spec.ts
View file

@ -187,7 +187,7 @@ g.test('texture_binding_must_have_correct_usage')
usage: appliedUsage,
sampleCount: info.resource === 'sampledTexMS' ? 4 : 1,
};
const resource = t.device.createTexture(descriptor).createView();
const resource = t.createTextureTracked(descriptor).createView();
const shouldError = (usage & info.usage) === 0;
t.expectValidationError(() => {
@ -241,7 +241,7 @@ g.test('texture_must_have_correct_component_type')
entries: [
{
binding: 0,
resource: t.device.createTexture(goodDescriptor).createView(),
resource: t.createTextureTracked(goodDescriptor).createView(),
},
],
layout: bindGroupLayout,
@ -266,7 +266,7 @@ g.test('texture_must_have_correct_component_type')
t.expectValidationError(() => {
t.device.createBindGroup({
entries: [{ binding: 0, resource: t.device.createTexture(badDescriptor).createView() }],
entries: [{ binding: 0, resource: t.createTextureTracked(badDescriptor).createView() }],
layout: bindGroupLayout,
});
});
@ -322,7 +322,7 @@ g.test('texture_must_have_correct_dimension')
depthOrArrayLayers = 1;
}
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: { width: 16, height, depthOrArrayLayers },
format: 'rgba8unorm' as const,
usage,
@ -380,7 +380,7 @@ g.test('multisampled_validation')
],
});
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
format: 'rgba8unorm' as const,
usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
@ -438,7 +438,7 @@ g.test('buffer_offset_and_size_for_bind_groups_match')
entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } }],
});
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 1024,
usage: GPUBufferUsage.STORAGE,
});
@ -491,7 +491,7 @@ g.test('minBindingSize')
],
});
const storageBuffer = t.device.createBuffer({
const storageBuffer = t.createBufferTracked({
size,
usage: GPUBufferUsage.STORAGE,
});
@ -742,7 +742,7 @@ g.test('storage_texture,usage')
],
});
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
format: 'rgba8unorm' as const,
usage,
@ -786,7 +786,7 @@ g.test('storage_texture,mip_level_count')
});
const MIP_LEVEL_COUNT = 4;
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
format: 'rgba8unorm' as const,
usage: GPUTextureUsage.STORAGE_BINDING,
@ -832,7 +832,7 @@ g.test('storage_texture,format')
],
});
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
format: resourceFormat,
usage: GPUTextureUsage.STORAGE_BINDING,
@ -885,7 +885,7 @@ g.test('buffer,usage')
],
});
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 4,
usage,
});
@ -945,7 +945,7 @@ g.test('buffer,resource_offset')
const usage = type === 'uniform' ? GPUBufferUsage.UNIFORM : GPUBufferUsage.STORAGE;
const isValid = offset % minAlignment === 0;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 1024,
usage,
});
@ -1004,7 +1004,7 @@ g.test('buffer,resource_binding_size')
const isValid = bindingSize <= maxBindingSize;
// MAINTENANCE_TODO: Allocating the max size seems likely to fail. Refactor test.
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: maxBindingSize,
usage,
});
@ -1061,7 +1061,7 @@ g.test('buffer,effective_buffer_binding_size')
isValid = effectiveBindingSize % 4 === 0;
}
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: bufferSize,
usage,
});

40
src/webgpu/api/validation/createTexture.spec.ts
View file

@ -95,7 +95,7 @@ g.test('zero_size_and_usage')
const success = zeroArgument === 'none';
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -126,7 +126,7 @@ g.test('dimension_type_and_format_compatibility')
};
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !textureDimensionAndFormatCompatible(dimension, format));
});
@ -185,7 +185,7 @@ g.test('mipLevelCount,format')
const success = mipLevelCount <= maxMipLevelCount(descriptor);
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -243,11 +243,11 @@ g.test('mipLevelCount,bound_check')
const mipLevelCount = maxMipLevelCount(descriptor);
descriptor.mipLevelCount = mipLevelCount;
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
descriptor.mipLevelCount = mipLevelCount + 1;
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
});
});
@ -262,7 +262,7 @@ g.test('mipLevelCount,bound_check,bigger_than_integer_bit_width')
};
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
});
});
@ -302,7 +302,7 @@ g.test('sampleCount,various_sampleCount_with_all_formats')
const success = sampleCount === 1 || (sampleCount === 4 && info.multisample);
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -390,7 +390,7 @@ g.test('sampleCount,valid_sampleCount_with_other_parameter_varies')
(usage & GPUConst.TextureUsage.STORAGE_BINDING) === 0);
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -409,7 +409,7 @@ g.test('sample_count,1d_2d_array_3d')
const { dimension, size, shouldError } = t.params;
t.expectValidationError(() => {
t.device.createTexture({
t.createTextureTracked({
size,
dimension,
sampleCount: 4,
@ -449,7 +449,7 @@ g.test('texture_size,default_value_and_smallest_size,uncompressed_format')
usage: GPUTextureUsage.TEXTURE_BINDING,
};
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
});
g.test('texture_size,default_value_and_smallest_size,compressed_format')
@ -491,7 +491,7 @@ g.test('texture_size,default_value_and_smallest_size,compressed_format')
};
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !_success);
});
@ -531,7 +531,7 @@ g.test('texture_size,1d_texture')
width <= t.device.limits.maxTextureDimension1D && height === 1 && depthOrArrayLayers === 1;
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -586,7 +586,7 @@ g.test('texture_size,2d_texture,uncompressed_format')
size[2] <= t.device.limits.maxTextureArrayLayers;
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -775,7 +775,7 @@ g.test('texture_size,2d_texture,compressed_format')
size[2] <= t.device.limits.maxTextureArrayLayers;
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -829,7 +829,7 @@ g.test('texture_size,3d_texture,uncompressed_format')
size[2] <= maxTextureDimension3D;
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -1023,7 +1023,7 @@ g.test('texture_size,3d_texture,compressed_format')
size[2] <= maxTextureDimension3D;
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -1075,7 +1075,7 @@ g.test('texture_usage')
}
t.expectValidationError(() => {
t.device.createTexture(descriptor);
t.createTextureTracked(descriptor);
}, !success);
});
@ -1109,7 +1109,7 @@ g.test('viewFormats')
// Test the viewFormat in the list.
t.expectValidationError(() => {
t.device.createTexture({
t.createTextureTracked({
format,
size: [blockWidth, blockHeight],
usage: GPUTextureUsage.TEXTURE_BINDING,
@ -1119,7 +1119,7 @@ g.test('viewFormats')
// Test the viewFormat and the texture format in the list.
t.expectValidationError(() => {
t.device.createTexture({
t.createTextureTracked({
format,
size: [blockWidth, blockHeight],
usage: GPUTextureUsage.TEXTURE_BINDING,
@ -1129,7 +1129,7 @@ g.test('viewFormats')
// Test the viewFormat multiple times in the list.
t.expectValidationError(() => {
t.device.createTexture({
t.createTextureTracked({
format,
size: [blockWidth, blockHeight],
usage: GPUTextureUsage.TEXTURE_BINDING,

12
src/webgpu/api/validation/createView.spec.ts
View file

@ -59,7 +59,7 @@ g.test('format')
const compatible =
viewFormat === undefined || viewCompatible(t.isCompatibility, textureFormat, viewFormat);
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
format: textureFormat,
size: [blockWidth, blockHeight],
usage: GPUTextureUsage.TEXTURE_BINDING,
@ -104,7 +104,7 @@ g.test('dimension')
size,
usage: GPUTextureUsage.TEXTURE_BINDING,
};
const texture = t.device.createTexture(textureDescriptor);
const texture = t.createTextureTracked(textureDescriptor);
const view = { dimension: viewDimension };
const reified = reifyTextureViewDescriptor(textureDescriptor, view);
@ -135,7 +135,7 @@ g.test('aspect')
const { format, aspect } = t.params;
const info = kTextureFormatInfo[format];
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
format,
size: [info.blockWidth, info.blockHeight, 1],
usage: GPUTextureUsage.TEXTURE_BINDING,
@ -239,7 +239,7 @@ g.test('array_layers')
const viewDescriptor = { dimension: viewDimension, baseArrayLayer, arrayLayerCount };
const success = validateCreateViewLayersLevels(textureDescriptor, viewDescriptor);
const texture = t.device.createTexture(textureDescriptor);
const texture = t.createTextureTracked(textureDescriptor);
t.expectValidationError(() => {
texture.createView(viewDescriptor);
}, !success);
@ -288,7 +288,7 @@ g.test('mip_levels')
const viewDescriptor = { dimension: viewDimension, baseMipLevel, mipLevelCount };
const success = validateCreateViewLayersLevels(textureDescriptor, viewDescriptor);
const texture = t.device.createTexture(textureDescriptor);
const texture = t.createTextureTracked(textureDescriptor);
t.debug(`${mipLevelCount} ${success}`);
t.expectValidationError(() => {
texture.createView(viewDescriptor);
@ -316,7 +316,7 @@ g.test('cube_faces_square')
t.skipIfTextureViewDimensionNotSupported(dimension);
const texture = t.device.createTexture({
const texture = t.createTextureTracked({
format: 'rgba8unorm',
size,
usage: GPUTextureUsage.TEXTURE_BINDING,

3
src/webgpu/api/validation/debugMarker.spec.ts
View file

@ -8,12 +8,11 @@ import { ValidationTest } from './validation_test.js';
class F extends ValidationTest {
beginRenderPass(commandEncoder: GPUCommandEncoder): GPURenderPassEncoder {
const attachmentTexture = this.device.createTexture({
const attachmentTexture = this.createTextureTracked({
format: 'rgba8unorm',
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
this.trackForCleanup(attachmentTexture);
return commandEncoder.beginRenderPass({
colorAttachments: [
{

4
src/webgpu/api/validation/encoding/beginRenderPass.spec.ts
View file

@ -125,7 +125,7 @@ g.test('depth_stencil_attachment,device_mismatch')
const depthStencilTexture = mismatched
? t.getDeviceMismatchedTexture(descriptor)
: t.device.createTexture(descriptor);
: t.createTextureTracked(descriptor);
const encoder = t.createEncoder('non-pass');
const pass = encoder.encoder.beginRenderPass({
@ -195,7 +195,7 @@ g.test('timestamp_query_set,device_mismatch')
beginningOfPassWriteIndex: 0,
};
const colorTexture = t.device.createTexture({
const colorTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: { width: 4, height: 4, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT,

23
src/webgpu/api/validation/encoding/cmds/clearBuffer.spec.ts
View file

@ -65,11 +65,12 @@ g.test('buffer,device_mismatch')
const sourceDevice = mismatched ? t.mismatchedDevice : t.device;
const size = 8;
const buffer = sourceDevice.createBuffer({
size,
usage: GPUBufferUsage.COPY_DST,
});
t.trackForCleanup(buffer);
const buffer = t.trackForCleanup(
sourceDevice.createBuffer({
size,
usage: GPUBufferUsage.COPY_DST,
})
);
t.TestClearBuffer({
buffer,
@ -89,7 +90,7 @@ g.test('default_args')
.fn(t => {
const { offset, size } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
@ -111,7 +112,7 @@ g.test('buffer_usage')
.fn(t => {
const { usage } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage,
});
@ -146,7 +147,7 @@ g.test('size_alignment')
.fn(t => {
const { size, _isSuccess: isSuccess } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
@ -180,7 +181,7 @@ g.test('offset_alignment')
.fn(t => {
const { offset, _isSuccess: isSuccess } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
@ -204,7 +205,7 @@ g.test('overflow')
.fn(t => {
const { offset, size } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
@ -232,7 +233,7 @@ g.test('out_of_bounds')
.fn(t => {
const { offset, size, _isSuccess = false } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 32,
usage: GPUBufferUsage.COPY_DST,
});

16
src/webgpu/api/validation/encoding/cmds/compute_pass.spec.ts
View file

@ -31,7 +31,7 @@ class F extends ValidationTest {
}
this.device.pushErrorScope('validation');
const buffer = this.device.createBuffer(descriptor);
const buffer = this.createBufferTracked(descriptor);
void this.device.popErrorScope();
if (state === 'valid') {
@ -203,11 +203,12 @@ g.test('indirect_dispatch_buffer,device_mismatch')
const sourceDevice = mismatched ? t.mismatchedDevice : t.device;
const buffer = sourceDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.INDIRECT,
});
t.trackForCleanup(buffer);
const buffer = t.trackForCleanup(
sourceDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.INDIRECT,
})
);
const { encoder, validateFinish } = t.createEncoder('compute pass');
encoder.setPipeline(pipeline);
@ -243,11 +244,10 @@ g.test('indirect_dispatch_buffer,usage')
const layout = t.device.createPipelineLayout({ bindGroupLayouts: [] });
const pipeline = t.createNoOpComputePipeline(layout);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: bufferUsage,
});
t.trackForCleanup(buffer);
const success = (GPUBufferUsage.INDIRECT & bufferUsage) !== 0;

44
src/webgpu/api/validation/encoding/cmds/copyBufferToBuffer.spec.ts
View file

@ -109,18 +109,20 @@ g.test('buffer,device_mismatch')
const { srcMismatched, dstMismatched } = t.params;
const srcBufferDevice = srcMismatched ? t.mismatchedDevice : t.device;
const srcBuffer = srcBufferDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.COPY_SRC,
});
t.trackForCleanup(srcBuffer);
const srcBuffer = t.trackForCleanup(
srcBufferDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.COPY_SRC,
})
);
const dstBufferDevice = dstMismatched ? t.mismatchedDevice : t.device;
const dstBuffer = dstBufferDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
t.trackForCleanup(dstBuffer);
const dstBuffer = t.trackForCleanup(
dstBufferDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.COPY_DST,
})
);
t.TestCopyBufferToBuffer({
srcBuffer,
@ -141,11 +143,11 @@ g.test('buffer_usage')
.fn(t => {
const { srcUsage, dstUsage } = t.params;
const srcBuffer = t.device.createBuffer({
const srcBuffer = t.createBufferTracked({
size: 16,
usage: srcUsage,
});
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: 16,
usage: dstUsage,
});
@ -174,11 +176,11 @@ g.test('copy_size_alignment')
.fn(t => {
const { copySize, _isSuccess: isSuccess } = t.params;
const srcBuffer = t.device.createBuffer({
const srcBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_SRC,
});
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
@ -209,11 +211,11 @@ g.test('copy_offset_alignment')
.fn(t => {
const { srcOffset, dstOffset, _isSuccess: isSuccess } = t.params;
const srcBuffer = t.device.createBuffer({
const srcBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_SRC,
});
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
@ -246,11 +248,11 @@ g.test('copy_overflow')
.fn(t => {
const { srcOffset, dstOffset, copySize } = t.params;
const srcBuffer = t.device.createBuffer({
const srcBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_SRC,
});
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST,
});
@ -281,11 +283,11 @@ g.test('copy_out_of_bounds')
.fn(t => {
const { srcOffset, dstOffset, copySize, _isSuccess = false } = t.params;
const srcBuffer = t.device.createBuffer({
const srcBuffer = t.createBufferTracked({
size: 32,
usage: GPUBufferUsage.COPY_SRC,
});
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: 32,
usage: GPUBufferUsage.COPY_DST,
});
@ -310,7 +312,7 @@ g.test('copy_within_same_buffer')
.fn(t => {
const { srcOffset, dstOffset, copySize } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});

64
src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
View file

@ -128,20 +128,22 @@ g.test('texture,device_mismatch')
const format = 'rgba8unorm';
const srcTextureDevice = srcMismatched ? t.mismatchedDevice : t.device;
const srcTexture = srcTextureDevice.createTexture({
size,
format,
usage: GPUTextureUsage.COPY_SRC,
});
t.trackForCleanup(srcTexture);
const srcTexture = t.trackForCleanup(
srcTextureDevice.createTexture({
size,
format,
usage: GPUTextureUsage.COPY_SRC,
})
);
const dstTextureDevice = dstMismatched ? t.mismatchedDevice : t.device;
const dstTexture = dstTextureDevice.createTexture({
size,
format,
usage: GPUTextureUsage.COPY_DST,
});
t.trackForCleanup(dstTexture);
const dstTexture = t.trackForCleanup(
dstTextureDevice.createTexture({
size,
format,
usage: GPUTextureUsage.COPY_DST,
})
);
t.TestCopyTextureToTexture(
{ texture: srcTexture },
@ -180,14 +182,14 @@ Test copyTextureToTexture must specify mipLevels that are in range.
.fn(t => {
const { srcLevelCount, dstLevelCount, srcCopyLevel, dstCopyLevel, dimension } = t.params;
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: { width: 32, height: 1, depthOrArrayLayers: 1 },
dimension,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC,
mipLevelCount: srcLevelCount,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: { width: 32, height: 1, depthOrArrayLayers: 1 },
dimension,
format: 'rgba8unorm',
@ -220,12 +222,12 @@ Test that copyTextureToTexture source/destination need COPY_SRC/COPY_DST usages.
.fn(t => {
const { srcUsage, dstUsage } = t.params;
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: { width: 4, height: 4, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: srcUsage,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: { width: 4, height: 4, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: dstUsage,
@ -264,13 +266,13 @@ Test that textures in copyTextureToTexture must have the same sample count.
.fn(t => {
const { srcSampleCount, dstSampleCount } = t.params;
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: { width: 4, height: 4, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: srcSampleCount,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: { width: 4, height: 4, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
@ -324,13 +326,13 @@ TODO: Check the source and destination constraints separately.
// Currently we don't support multisampled 2D array textures and the mipmap level count of the
// multisampled textures must be 1.
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
sampleCount: 4,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: { width: kWidth, height: kHeight, depthOrArrayLayers: 1 },
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
@ -385,13 +387,13 @@ Test the formats of textures in copyTextureToTexture must be copy-compatible.
depthOrArrayLayers: 1,
};
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: textureSize,
format: srcFormat,
usage: GPUTextureUsage.COPY_SRC,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: textureSize,
format: dstFormat,
usage: GPUTextureUsage.COPY_DST,
@ -455,13 +457,13 @@ Note: this is only tested for 2D textures as it is the only dimension compatible
t.params;
const kMipLevelCount = 3;
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: { width: srcTextureSize.width, height: srcTextureSize.height, depthOrArrayLayers: 1 },
format,
mipLevelCount: kMipLevelCount,
usage: GPUTextureUsage.COPY_SRC,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: { width: dstTextureSize.width, height: dstTextureSize.height, depthOrArrayLayers: 1 },
format,
mipLevelCount: kMipLevelCount,
@ -552,14 +554,14 @@ Test that copyTextureToTexture copy boxes must be in range of the subresource.
}
const kFormat = 'rgba8unorm';
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: textureSize,
format: kFormat,
dimension,
mipLevelCount,
usage: GPUTextureUsage.COPY_SRC,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: textureSize,
format: kFormat,
dimension,
@ -669,7 +671,7 @@ TODO: Extend to 1D and 3D textures.`
const kArrayLayerCount = 7;
const testTexture = t.device.createTexture({
const testTexture = t.createTextureTracked({
size: { width: 16, height: 16, depthOrArrayLayers: kArrayLayerCount },
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
@ -711,12 +713,12 @@ Test the validations on the member 'aspect' of GPUImageCopyTexture in CopyTextur
const kTextureSize = { width: 16, height: 8, depthOrArrayLayers: 1 };
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: kTextureSize,
format,
usage: GPUTextureUsage.COPY_SRC,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: kTextureSize,
format,
usage: GPUTextureUsage.COPY_DST,
@ -797,14 +799,14 @@ TODO: Express the offsets in "block size" so as to be able to test non-4x4 compr
};
const kMipLevelCount = 4;
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: kTextureSize,
format,
dimension,
mipLevelCount: kMipLevelCount,
usage: GPUTextureUsage.COPY_SRC,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: kTextureSize,
format,
dimension,

2
src/webgpu/api/validation/encoding/cmds/index_access.spec.ts
View file

@ -40,7 +40,7 @@ class F extends ValidationTest {
}
beginRenderPass(encoder: GPUCommandEncoder) {
const colorAttachment = this.device.createTexture({
const colorAttachment = this.createTextureTracked({
format: 'rgba8unorm',
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT,

2
src/webgpu/api/validation/encoding/cmds/render/draw.spec.ts
View file

@ -772,7 +772,7 @@ and checks whether GPUCommandEncoder.finish() causes a validation error.
const { bundleFirstHalf, bundleSecondHalf, maxDrawCount, drawCount } = t.params;
const colorFormat = 'rgba8unorm';
const colorTexture = t.device.createTexture({
const colorTexture = t.createTextureTracked({
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
format: colorFormat,
mipLevelCount: 1,

6
src/webgpu/api/validation/encoding/cmds/render/dynamic_state.spec.ts
View file

@ -47,7 +47,7 @@ class F extends ValidationTest {
v: ViewportCall,
attachmentSize: GPUExtent3D = { width: 1, height: 1, depthOrArrayLayers: 1 }
) {
const attachment = this.device.createTexture({
const attachment = this.createTextureTracked({
format: 'rgba8unorm',
size: attachmentSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
@ -76,7 +76,7 @@ class F extends ValidationTest {
s: ScissorCall,
attachmentSize: GPUExtent3D = { width: 1, height: 1, depthOrArrayLayers: 1 }
) {
const attachment = this.device.createTexture({
const attachment = this.createTextureTracked({
format: 'rgba8unorm',
size: attachmentSize,
usage: GPUTextureUsage.RENDER_ATTACHMENT,
@ -107,7 +107,7 @@ class F extends ValidationTest {
}
createDummyRenderPassEncoder(): { encoder: GPUCommandEncoder; pass: GPURenderPassEncoder } {
const attachment = this.device.createTexture({
const attachment = this.createTextureTracked({
format: 'rgba8unorm',
size: [1, 1, 1],
usage: GPUTextureUsage.RENDER_ATTACHMENT,

19
src/webgpu/api/validation/encoding/cmds/render/indirect_draw.spec.ts
View file

@ -13,7 +13,7 @@ const kIndirectDrawTestParams = kRenderEncodeTypeParams.combine('indexed', [true
class F extends ValidationTest {
makeIndexBuffer(): GPUBuffer {
return this.device.createBuffer({
return this.createBufferTracked({
size: 16,
usage: GPUBufferUsage.INDEX,
});
@ -63,11 +63,12 @@ g.test('indirect_buffer,device_mismatch')
const sourceDevice = mismatched ? t.mismatchedDevice : t.device;
const indirectBuffer = sourceDevice.createBuffer({
size: 256,
usage: GPUBufferUsage.INDIRECT,
});
t.trackForCleanup(indirectBuffer);
const indirectBuffer = t.trackForCleanup(
sourceDevice.createBuffer({
size: 256,
usage: GPUBufferUsage.INDIRECT,
})
);
const { encoder, validateFinish } = t.createEncoder(encoderType);
encoder.setPipeline(t.createNoOpRenderPipeline());
@ -96,7 +97,7 @@ Tests indirect buffer must have 'Indirect' usage.
)
.fn(t => {
const { encoderType, indexed, usage } = t.params;
const indirectBuffer = t.device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: 256,
usage,
});
@ -123,7 +124,7 @@ Tests indirect offset must be a multiple of 4.
.fn(t => {
const { encoderType, indexed, indirectOffset } = t.params;
const pipeline = t.createNoOpRenderPipeline();
const indirectBuffer = t.device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: 256,
usage: GPUBufferUsage.INDIRECT,
});
@ -183,7 +184,7 @@ Tests indirect draw calls with various indirect offsets and buffer sizes.
.fn(t => {
const { encoderType, indexed, indirectOffset, bufferSize, _valid } = t.params;
const pipeline = t.createNoOpRenderPipeline();
const indirectBuffer = t.device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.INDIRECT,
});

17
src/webgpu/api/validation/encoding/cmds/render/setIndexBuffer.spec.ts
View file

@ -40,11 +40,12 @@ g.test('index_buffer,device_mismatch')
const { encoderType, mismatched } = t.params;
const sourceDevice = mismatched ? t.mismatchedDevice : t.device;
const indexBuffer = sourceDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.INDEX,
});
t.trackForCleanup(indexBuffer);
const indexBuffer = t.trackForCleanup(
sourceDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.INDEX,
})
);
const { encoder, validateFinish } = t.createEncoder(encoderType);
encoder.setIndexBuffer(indexBuffer, 'uint32');
@ -66,7 +67,7 @@ Tests index buffer must have 'Index' usage.
)
.fn(t => {
const { encoderType, usage } = t.params;
const indexBuffer = t.device.createBuffer({
const indexBuffer = t.createBufferTracked({
size: 16,
usage,
});
@ -91,7 +92,7 @@ Tests offset must be a multiple of index format’s byte size.
)
.fn(t => {
const { encoderType, indexFormat, offset } = t.params;
const indexBuffer = t.device.createBuffer({
const indexBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.INDEX,
});
@ -113,7 +114,7 @@ Tests offset and size cannot be larger than index buffer size.
.paramsSubcasesOnly(buildBufferOffsetAndSizeOOBTestParams(4, 256))
.fn(t => {
const { encoderType, offset, size, _valid } = t.params;
const indexBuffer = t.device.createBuffer({
const indexBuffer = t.createBufferTracked({
size: 256,
usage: GPUBufferUsage.INDEX,
});

17
src/webgpu/api/validation/encoding/cmds/render/setVertexBuffer.spec.ts
View file

@ -69,11 +69,12 @@ g.test('vertex_buffer,device_mismatch')
const { encoderType, mismatched } = t.params;
const sourceDevice = mismatched ? t.mismatchedDevice : t.device;
const vertexBuffer = sourceDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.VERTEX,
});
t.trackForCleanup(vertexBuffer);
const vertexBuffer = t.trackForCleanup(
sourceDevice.createBuffer({
size: 16,
usage: GPUBufferUsage.VERTEX,
})
);
const { encoder, validateFinish } = t.createEncoder(encoderType);
encoder.setVertexBuffer(0, vertexBuffer);
@ -95,7 +96,7 @@ Tests vertex buffer must have 'Vertex' usage.
)
.fn(t => {
const { encoderType, usage } = t.params;
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
size: 16,
usage,
});
@ -114,7 +115,7 @@ Tests offset must be a multiple of 4.
.paramsSubcasesOnly(kRenderEncodeTypeParams.combine('offset', [0, 2, 4] as const))
.fn(t => {
const { encoderType, offset } = t.params;
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.VERTEX,
});
@ -133,7 +134,7 @@ Tests offset and size cannot be larger than vertex buffer size.
.paramsSubcasesOnly(buildBufferOffsetAndSizeOOBTestParams(4, 256))
.fn(t => {
const { encoderType, offset, size, _valid } = t.params;
const vertexBuffer = t.device.createBuffer({
const vertexBuffer = t.createBufferTracked({
size: 256,
usage: GPUBufferUsage.VERTEX,
});

4
src/webgpu/api/validation/encoding/cmds/render/state_tracking.spec.ts
View file

@ -8,7 +8,7 @@ import { ValidationTest } from '../../../validation_test.js';
class F extends ValidationTest {
getVertexBuffer(): GPUBuffer {
return this.device.createBuffer({
return this.createBufferTracked({
size: 256,
usage: GPUBufferUsage.VERTEX,
});
@ -55,7 +55,7 @@ class F extends ValidationTest {
}
beginRenderPass(commandEncoder: GPUCommandEncoder): GPURenderPassEncoder {
const attachmentTexture = this.device.createTexture({
const attachmentTexture = this.createTextureTracked({
format: 'rgba8unorm',
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT,

16
src/webgpu/api/validation/encoding/cmds/setBindGroup.spec.ts
View file

@ -150,10 +150,12 @@ g.test('bind_group,device_mismatch')
const { encoderType, useU32Array, mismatched } = t.params;
const sourceDevice = mismatched ? t.mismatchedDevice : t.device;
const buffer = sourceDevice.createBuffer({
size: 4,
usage: GPUBufferUsage.STORAGE,
});
const buffer = t.trackForCleanup(
sourceDevice.createBuffer({
size: 4,
usage: GPUBufferUsage.STORAGE,
})
);
const layout = sourceDevice.createBindGroupLayout({
entries: [
@ -247,12 +249,12 @@ g.test('dynamic_offsets_match_expectations_in_pass_encoder')
],
});
const uniformBuffer = t.device.createBuffer({
const uniformBuffer = t.createBufferTracked({
size: 2 * kMinDynamicBufferOffsetAlignment + 8,
usage: GPUBufferUsage.UNIFORM,
});
const storageBuffer = t.device.createBuffer({
const storageBuffer = t.createBufferTracked({
size: 2 * kMinDynamicBufferOffsetAlignment + 8,
usage: GPUBufferUsage.STORAGE,
});
@ -419,7 +421,7 @@ g.test('buffer_dynamic_offsets')
const usage = type === 'uniform' ? GPUBufferUsage.UNIFORM : GPUBufferUsage.STORAGE;
const isValid = dynamicOffset % minAlignment === 0;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 3 * kMinDynamicBufferOffsetAlignment,
usage,
});

14
src/webgpu/api/validation/encoding/encoder_open_state.spec.ts
View file

@ -169,23 +169,23 @@ g.test('non_pass_commands')
.fn(t => {
const { command, finishBeforeCommand } = t.params;
const srcBuffer = t.device.createBuffer({
const srcBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
});
const dstBuffer = t.device.createBuffer({
const dstBuffer = t.createBufferTracked({
size: 16,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE,
});
const textureSize = { width: 1, height: 1 };
const textureFormat = 'rgba8unorm';
const srcTexture = t.device.createTexture({
const srcTexture = t.createTextureTracked({
size: textureSize,
format: textureFormat,
usage: GPUTextureUsage.COPY_SRC,
});
const dstTexture = t.device.createTexture({
const dstTexture = t.createTextureTracked({
size: textureSize,
format: textureFormat,
usage: GPUTextureUsage.COPY_DST,
@ -305,7 +305,7 @@ g.test('render_pass_commands')
const encoder = t.device.createCommandEncoder();
const renderPass = beginRenderPassWithQuerySet(t, encoder, querySet);
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 12,
usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
@ -436,7 +436,7 @@ g.test('render_bundle_commands')
.fn(t => {
const { command, finishBeforeCommand } = t.params;
const buffer = t.device.createBuffer({
const buffer = t.createBufferTracked({
size: 12,
usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
@ -537,7 +537,7 @@ g.test('compute_pass_commands')
const encoder = t.device.createCommandEncoder();
const computePass = encoder.beginComputePass();
const indirectBuffer = t.device.createBuffer({
const indirectBuffer = t.createBufferTracked({
size: 12,
usage: GPUBufferUsage.INDIRECT,
});

3
src/webgpu/api/validation/encoding/encoder_state.spec.ts
View file

@ -35,12 +35,11 @@ class F extends ValidationTest {
}
createAttachmentTextureView(): GPUTextureView {
const texture = this.device.createTexture({
const texture = this.createTextureTracked({
format: 'rgba8unorm',
size: { width: 1, height: 1, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
this.trackForCleanup(texture);
return texture.createView();
}
}

12
src/webgpu/api/validation/encoding/programmable/pipeline_bind_group_compat.spec.ts
View file

@ -73,14 +73,14 @@ const kCompatTestParams = kUnitCaseParamsBuilder
class F extends ValidationTest {
getIndexBuffer(): GPUBuffer {
return this.device.createBuffer({
return this.createBufferTracked({
size: 8 * Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.INDEX,
});
}
getIndirectBuffer(indirectParams: Array<number>): GPUBuffer {
const buffer = this.device.createBuffer({
const buffer = this.createBufferTracked({
mappedAtCreation: true,
size: indirectParams.length * Uint32Array.BYTES_PER_ELEMENT,
usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_DST,
@ -347,11 +347,10 @@ class F extends ValidationTest {
explicitPipelineLayout
);
const buffer = device.createBuffer({
const buffer = this.createBufferTracked({
size: 16,
usage: GPUBufferUsage.UNIFORM,
});
this.trackForCleanup(buffer);
let emptyBindGroupLayouts;
let nonEmptyBindGroupLayouts;
@ -909,7 +908,7 @@ g.test('empty_bind_group_layouts_requires_empty_bind_groups,render_pass')
const encoder = t.device.createCommandEncoder();
const attachmentTexture = t.device.createTexture({
const attachmentTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT,
@ -1082,12 +1081,11 @@ g.test('default_bind_group_layouts_never_match,render_pass')
);
},
doCommandFn: ({ t, encoder, pipeline, emptyBindGroups, nonEmptyBindGroups }) => {
const attachmentTexture = t.device.createTexture({
const attachmentTexture = t.createTextureTracked({
format: 'rgba8unorm',
size: { width: 16, height: 16, depthOrArrayLayers: 1 },
usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
t.trackForCleanup(attachmentTexture);
const renderPass = encoder.beginRenderPass({
colorAttachments: [

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