LayoutTests/webgpu/whlsl-matrix.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
 <script src="../resources/js-test-pre.js"></script>
 </head>
 <body>
 <script>
 const shaderSource = `
 bool allEqual(float2x3 mat, float value)
 {
     for (uint i = 0; i < 2; i = i + 1) {
         for (uint j = 0; j < 3; j = j + 1) {
             if (mat[i][j] != value)
                 return false;
         }
     }
     return true;
 }

 [numthreads(1, 1, 1)]
 compute void computeShader(device float[] buffer : register(u0), float3 threadID : SV_DispatchThreadID) {
     float2x3 foo;
     if (!allEqual(foo, 0))
         return;

     foo = foo + 1.0;
     if (!allEqual(foo, 1))
         return;

     foo = foo * 8.5;
     if (!allEqual(foo, 8.5))
         return;

     foo = foo - 7.5;
     if (!allEqual(foo, 1))
         return;

     foo = foo + 1.0;
     if (!allEqual(foo, 2))
         return;

     foo = foo + foo;
     if (!allEqual(foo, 4))
         return;

     foo = foo + foo;
     if (!allEqual(foo, 8))
         return;

     float3 fourtyTwo;
     fourtyTwo.x = 42;
     fourtyTwo.y = 42;
     fourtyTwo.z = 42;

     foo[0] = fourtyTwo;
     foo[1] = fourtyTwo;
     if (!allEqual(foo, 42))
         return;

     foo[1337] = fourtyTwo;
     if (!allEqual(foo, 42))
         return;

     foo[1000000] = fourtyTwo;
     if (!allEqual(foo, 42))
         return;

     fourtyTwo[1337] = 50;
     foo[1] = fourtyTwo;
     if (!allEqual(foo, 42))
         return;

     fourtyTwo[1000000] = 50;
     foo[1] = fourtyTwo;
     if (!allEqual(foo, 42))
         return;

     float3 shouldBeZero = foo[100000];
     if (shouldBeZero.x != 0 || shouldBeZero.y != 0 || shouldBeZero.z != 0)
         return;

     if (fourtyTwo[10000000] != 0)
         return;

     buffer[uint(threadID.x)] = buffer[uint(threadID.x)] * 2.0;
 }
 `;
 let resultsFloat32Array;
 async function start() {
     const adapter = await navigator.gpu.requestAdapter();
     const device = await adapter.requestDevice();

     const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
     const computeStage = {module: shaderModule, entryPoint: "computeShader"};

     const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "storage-buffer"}]};
     const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
     const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
     const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);

     const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
     const computePipeline = device.createComputePipeline(computePipelineDescriptor);

     const size = Float32Array.BYTES_PER_ELEMENT * 8;

     const bufferDescriptor = {size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.TRANSFER_SRC};
     const buffer = device.createBuffer(bufferDescriptor);
     const bufferArrayBuffer = await buffer.mapWriteAsync();
     const bufferFloat32Array = new Float32Array(bufferArrayBuffer);
     bufferFloat32Array[0] = 1;
     bufferFloat32Array[1] = 2;
     bufferFloat32Array[2] = 3;
     bufferFloat32Array[3] = 4;
     bufferFloat32Array[4] = 5;
     bufferFloat32Array[5] = 6;
     bufferFloat32Array[6] = 7;
     bufferFloat32Array[7] = 8;
     buffer.unmap();

     const resultsBufferDescriptor = {size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.TRANSFER_DST | GPUBufferUsage.MAP_READ};
     const resultsBuffer = device.createBuffer(resultsBufferDescriptor);

     const bufferBinding = {buffer: resultsBuffer, size};
     const bindGroupBinding = {binding: 0, resource: bufferBinding};
     const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
     const bindGroup = device.createBindGroup(bindGroupDescriptor);

     const commandEncoder = device.createCommandEncoder(); // {}
     commandEncoder.copyBufferToBuffer(buffer, 0, resultsBuffer, 0, size);
     const computePassEncoder = commandEncoder.beginComputePass();
     computePassEncoder.setPipeline(computePipeline);
     computePassEncoder.setBindGroup(0, bindGroup);
     computePassEncoder.dispatch(4, 1, 1);
     computePassEncoder.endPass();
     const commandBuffer = commandEncoder.finish();
     device.getQueue().submit([commandBuffer]);

     const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
     resultsFloat32Array = new Float32Array(resultsArrayBuffer);
     shouldBe("resultsFloat32Array[0]", "2");
     shouldBe("resultsFloat32Array[1]", "4");
     shouldBe("resultsFloat32Array[2]", "6");
     shouldBe("resultsFloat32Array[3]", "8");
     shouldBe("resultsFloat32Array[4]", "5");
     shouldBe("resultsFloat32Array[5]", "6");
     shouldBe("resultsFloat32Array[6]", "7");
     shouldBe("resultsFloat32Array[7]", "8");
     resultsBuffer.unmap();
 }
 if (window.testRunner)
     testRunner.waitUntilDone();
 window.addEventListener("load", function() {
     start().then(function() {
         if (window.testRunner)
             testRunner.notifyDone();
     }, function() {
         if (window.testRunner)
             testRunner.notifyDone();
     });
 });
 </script>
 <script src="../resources/js-test-post.js"></script>
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src="../resources/js-test-pre.js"></script>
	</head>
	<body>
	<script>
	const shaderSource = `
	bool allEqual(float2x3 mat, float value)
	{
	for (uint i = 0; i < 2; i = i + 1) {
	for (uint j = 0; j < 3; j = j + 1) {
	if (mat[i][j] != value)
	return false;
	}
	}
	return true;
	}

	[numthreads(1, 1, 1)]
	compute void computeShader(device float[] buffer : register(u0), float3 threadID : SV_DispatchThreadID) {
	float2x3 foo;
	if (!allEqual(foo, 0))
	return;

	foo = foo + 1.0;
	if (!allEqual(foo, 1))
	return;

	foo = foo * 8.5;
	if (!allEqual(foo, 8.5))
	return;

	foo = foo - 7.5;
	if (!allEqual(foo, 1))
	return;

	foo = foo + 1.0;
	if (!allEqual(foo, 2))
	return;

	foo = foo + foo;
	if (!allEqual(foo, 4))
	return;

	foo = foo + foo;
	if (!allEqual(foo, 8))
	return;

	float3 fourtyTwo;
	fourtyTwo.x = 42;
	fourtyTwo.y = 42;
	fourtyTwo.z = 42;

	foo[0] = fourtyTwo;
	foo[1] = fourtyTwo;
	if (!allEqual(foo, 42))
	return;

	foo[1337] = fourtyTwo;
	if (!allEqual(foo, 42))
	return;

	foo[1000000] = fourtyTwo;
	if (!allEqual(foo, 42))
	return;

	fourtyTwo[1337] = 50;
	foo[1] = fourtyTwo;
	if (!allEqual(foo, 42))
	return;

	fourtyTwo[1000000] = 50;
	foo[1] = fourtyTwo;
	if (!allEqual(foo, 42))
	return;

	float3 shouldBeZero = foo[100000];
	if (shouldBeZero.x != 0 \|\| shouldBeZero.y != 0 \|\| shouldBeZero.z != 0)
	return;

	if (fourtyTwo[10000000] != 0)
	return;

	buffer[uint(threadID.x)] = buffer[uint(threadID.x)] * 2.0;
	}
	`;
	let resultsFloat32Array;
	async function start() {
	const adapter = await navigator.gpu.requestAdapter();
	const device = await adapter.requestDevice();

	const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
	const computeStage = {module: shaderModule, entryPoint: "computeShader"};

	const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "storage-buffer"}]};
	const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
	const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
	const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);

	const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
	const computePipeline = device.createComputePipeline(computePipelineDescriptor);

	const size = Float32Array.BYTES_PER_ELEMENT * 8;

	const bufferDescriptor = {size, usage: GPUBufferUsage.MAP_WRITE \| GPUBufferUsage.TRANSFER_SRC};
	const buffer = device.createBuffer(bufferDescriptor);
	const bufferArrayBuffer = await buffer.mapWriteAsync();
	const bufferFloat32Array = new Float32Array(bufferArrayBuffer);
	bufferFloat32Array[0] = 1;
	bufferFloat32Array[1] = 2;
	bufferFloat32Array[2] = 3;
	bufferFloat32Array[3] = 4;
	bufferFloat32Array[4] = 5;
	bufferFloat32Array[5] = 6;
	bufferFloat32Array[6] = 7;
	bufferFloat32Array[7] = 8;
	buffer.unmap();

	const resultsBufferDescriptor = {size, usage: GPUBufferUsage.STORAGE \| GPUBufferUsage.TRANSFER_DST \| GPUBufferUsage.MAP_READ};
	const resultsBuffer = device.createBuffer(resultsBufferDescriptor);

	const bufferBinding = {buffer: resultsBuffer, size};
	const bindGroupBinding = {binding: 0, resource: bufferBinding};
	const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
	const bindGroup = device.createBindGroup(bindGroupDescriptor);

	const commandEncoder = device.createCommandEncoder(); // {}
	commandEncoder.copyBufferToBuffer(buffer, 0, resultsBuffer, 0, size);
	const computePassEncoder = commandEncoder.beginComputePass();
	computePassEncoder.setPipeline(computePipeline);
	computePassEncoder.setBindGroup(0, bindGroup);
	computePassEncoder.dispatch(4, 1, 1);
	computePassEncoder.endPass();
	const commandBuffer = commandEncoder.finish();
	device.getQueue().submit([commandBuffer]);

	const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
	resultsFloat32Array = new Float32Array(resultsArrayBuffer);
	shouldBe("resultsFloat32Array[0]", "2");
	shouldBe("resultsFloat32Array[1]", "4");
	shouldBe("resultsFloat32Array[2]", "6");
	shouldBe("resultsFloat32Array[3]", "8");
	shouldBe("resultsFloat32Array[4]", "5");
	shouldBe("resultsFloat32Array[5]", "6");
	shouldBe("resultsFloat32Array[6]", "7");
	shouldBe("resultsFloat32Array[7]", "8");
	resultsBuffer.unmap();
	}
	if (window.testRunner)
	testRunner.waitUntilDone();
	window.addEventListener("load", function() {
	start().then(function() {
	if (window.testRunner)
	testRunner.notifyDone();
	}, function() {
	if (window.testRunner)
	testRunner.notifyDone();
	});
	});
	</script>
	<script src="../resources/js-test-post.js"></script>
	</body>
	</html>