src/tests/end2end/OpArrayLengthTests.cpp - dawn - Git at Google

 // Copyright 2019 The Dawn Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "tests/DawnTest.h"

 #include "common/Assert.h"
 #include "utils/ComboRenderPipelineDescriptor.h"
 #include "utils/WGPUHelpers.h"

 class OpArrayLengthTest : public DawnTest {
   protected:
     void SetUp() {
         DawnTest::SetUp();

         // Create buffers of various size to check the length() implementation
         wgpu::BufferDescriptor bufferDesc;
         bufferDesc.size = 4;
         bufferDesc.usage = wgpu::BufferUsage::Storage;
         mStorageBuffer4 = device.CreateBuffer(&bufferDesc);

         bufferDesc.size = 256;
         mStorageBuffer256 = device.CreateBuffer(&bufferDesc);

         bufferDesc.size = 512 + 256;
         mStorageBuffer512 = device.CreateBuffer(&bufferDesc);

         // Put them all in a bind group for tests to bind them easily.
         wgpu::ShaderStage kAllStages =
             wgpu::ShaderStage::Fragment | wgpu::ShaderStage::Vertex | wgpu::ShaderStage::Compute;
         mBindGroupLayout = utils::MakeBindGroupLayout(
             device, {{0, kAllStages, wgpu::BufferBindingType::ReadOnlyStorage},
                      {1, kAllStages, wgpu::BufferBindingType::ReadOnlyStorage},
                      {2, kAllStages, wgpu::BufferBindingType::ReadOnlyStorage}});

         mBindGroup = utils::MakeBindGroup(device, mBindGroupLayout,
                                           {
                                               {0, mStorageBuffer4, 0, 4},
                                               {1, mStorageBuffer256, 0, wgpu::kWholeSize},
                                               {2, mStorageBuffer512, 256, wgpu::kWholeSize},
                                           });

         // Common shader code to use these buffers in shaders, assuming they are in bindgroup index
         // 0.
         mShaderInterface = R"(
             [[block]] struct DataBuffer {
                 data : [[stride(4)]] array<f32>;
             };

             // The length should be 1 because the buffer is 4-byte long.
             [[group(0), binding(0)]] var<storage, read> buffer1 : DataBuffer;

             // The length should be 64 because the buffer is 256 bytes long.
             [[group(0), binding(1)]] var<storage, read> buffer2 : DataBuffer;

             // The length should be (512 - 16*4) / 8 = 56 because the buffer is 512 bytes long
             // and the structure is 8 bytes big.
             struct Buffer3Data {
                 a : f32;
                 b : i32;
             };

             [[block]] struct Buffer3 {
                 [[size(64)]] garbage : mat4x4<f32>;
                 data : [[stride(8)]] array<Buffer3Data>;
             };
             [[group(0), binding(2)]] var<storage, read> buffer3 : Buffer3;
         )";

         // See comments in the shader for an explanation of these values
         mExpectedLengths = {1, 64, 56};
     }

     wgpu::Buffer mStorageBuffer4;
     wgpu::Buffer mStorageBuffer256;
     wgpu::Buffer mStorageBuffer512;

     wgpu::BindGroupLayout mBindGroupLayout;
     wgpu::BindGroup mBindGroup;
     std::string mShaderInterface;
     std::array<uint32_t, 3> mExpectedLengths;
 };

 // Test OpArrayLength in the compute stage
 TEST_P(OpArrayLengthTest, Compute) {
     // TODO(crbug.com/dawn/197): The computations for length() of unsized buffer is broken on
     // Nvidia OpenGL.
     DAWN_SUPPRESS_TEST_IF(IsNvidia() && (IsOpenGL() || IsOpenGLES()));

     // Create a buffer to hold the result sizes and create a bindgroup for it.
     wgpu::BufferDescriptor bufferDesc;
     bufferDesc.usage = wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc;
     bufferDesc.size = sizeof(uint32_t) * mExpectedLengths.size();
     wgpu::Buffer resultBuffer = device.CreateBuffer(&bufferDesc);

     wgpu::BindGroupLayout resultLayout = utils::MakeBindGroupLayout(
         device, {{0, wgpu::ShaderStage::Compute, wgpu::BufferBindingType::Storage}});

     wgpu::BindGroup resultBindGroup =
         utils::MakeBindGroup(device, resultLayout, {{0, resultBuffer, 0, wgpu::kWholeSize}});

     // Create the compute pipeline that stores the length()s in the result buffer.
     wgpu::BindGroupLayout bgls[] = {mBindGroupLayout, resultLayout};
     wgpu::PipelineLayoutDescriptor plDesc;
     plDesc.bindGroupLayoutCount = 2;
     plDesc.bindGroupLayouts = bgls;
     wgpu::PipelineLayout pl = device.CreatePipelineLayout(&plDesc);

     wgpu::ComputePipelineDescriptor pipelineDesc;
     pipelineDesc.layout = pl;
     pipelineDesc.compute.entryPoint = "main";
     pipelineDesc.compute.module = utils::CreateShaderModule(device, (R"(
         [[block]] struct ResultBuffer {
             data : [[stride(4)]] array<u32, 3>;
         };
         [[group(1), binding(0)]] var<storage, read_write> result : ResultBuffer;
         )" + mShaderInterface + R"(
         [[stage(compute), workgroup_size(1)]] fn main() {
             result.data[0] = arrayLength(&buffer1.data);
             result.data[1] = arrayLength(&buffer2.data);
             result.data[2] = arrayLength(&buffer3.data);
         })")
                                                                         .c_str());
     wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc);

     // Run a single instance of the compute shader
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     wgpu::ComputePassEncoder pass = encoder.BeginComputePass();
     pass.SetPipeline(pipeline);
     pass.SetBindGroup(0, mBindGroup);
     pass.SetBindGroup(1, resultBindGroup);
     pass.Dispatch(1);
     pass.EndPass();

     wgpu::CommandBuffer commands = encoder.Finish();
     queue.Submit(1, &commands);

     EXPECT_BUFFER_U32_RANGE_EQ(mExpectedLengths.data(), resultBuffer, 0, 3);
 }

 // Test OpArrayLength in the fragment stage
 TEST_P(OpArrayLengthTest, Fragment) {
     // TODO(crbug.com/dawn/197): The computations for length() of unsized buffer is broken on
     // Nvidia OpenGL.
     DAWN_SUPPRESS_TEST_IF(IsNvidia() && (IsOpenGL() || IsOpenGLES()));

     utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);

     // Create the pipeline that computes the length of the buffers and writes it to the only render
     // pass pixel.
     wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
         [[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> {
             return vec4<f32>(0.0, 0.0, 0.0, 1.0);
         })");

     wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, (mShaderInterface + R"(
         [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
             var fragColor : vec4<f32>;
             fragColor.r = f32(arrayLength(&buffer1.data)) / 255.0;
             fragColor.g = f32(arrayLength(&buffer2.data)) / 255.0;
             fragColor.b = f32(arrayLength(&buffer3.data)) / 255.0;
             fragColor.a = 0.0;
             return fragColor;
         })")
                                                                         .c_str());

     utils::ComboRenderPipelineDescriptor descriptor;
     descriptor.vertex.module = vsModule;
     descriptor.cFragment.module = fsModule;
     descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
     descriptor.cTargets[0].format = renderPass.colorFormat;
     descriptor.layout = utils::MakeBasicPipelineLayout(device, &mBindGroupLayout);
     wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);

     // "Draw" the lengths to the texture.
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
         pass.SetPipeline(pipeline);
         pass.SetBindGroup(0, mBindGroup);
         pass.Draw(1);
         pass.EndPass();
     }

     wgpu::CommandBuffer commands = encoder.Finish();
     queue.Submit(1, &commands);

     RGBA8 expectedColor = RGBA8(mExpectedLengths[0], mExpectedLengths[1], mExpectedLengths[2], 0);
     EXPECT_PIXEL_RGBA8_EQ(expectedColor, renderPass.color, 0, 0);
 }

 // Test OpArrayLength in the vertex stage
 TEST_P(OpArrayLengthTest, Vertex) {
     // TODO(crbug.com/dawn/197): The computations for length() of unsized buffer is broken on
     // Nvidia OpenGL. Also failing on all GLES (NV, Intel, SwANGLE).
     DAWN_SUPPRESS_TEST_IF(IsNvidia() && IsOpenGL());
     DAWN_SUPPRESS_TEST_IF(IsOpenGLES());

     utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);

     // Create the pipeline that computes the length of the buffers and writes it to the only render
     // pass pixel.
     wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, (mShaderInterface + R"(
         struct VertexOut {
             [[location(0)]] color : vec4<f32>;
             [[builtin(position)]] position : vec4<f32>;
         };

         [[stage(vertex)]] fn main() -> VertexOut {
             var output : VertexOut;
             output.color.r = f32(arrayLength(&buffer1.data)) / 255.0;
             output.color.g = f32(arrayLength(&buffer2.data)) / 255.0;
             output.color.b = f32(arrayLength(&buffer3.data)) / 255.0;
             output.color.a = 0.0;

             output.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
             return output;
         })")
                                                                         .c_str());

     wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
         [[stage(fragment)]]
         fn main([[location(0)]] color : vec4<f32>) -> [[location(0)]] vec4<f32> {
             return color;
         })");

     utils::ComboRenderPipelineDescriptor descriptor;
     descriptor.vertex.module = vsModule;
     descriptor.cFragment.module = fsModule;
     descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
     descriptor.cTargets[0].format = renderPass.colorFormat;
     descriptor.layout = utils::MakeBasicPipelineLayout(device, &mBindGroupLayout);
     wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);

     // "Draw" the lengths to the texture.
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     {
         wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
         pass.SetPipeline(pipeline);
         pass.SetBindGroup(0, mBindGroup);
         pass.Draw(1);
         pass.EndPass();
     }

     wgpu::CommandBuffer commands = encoder.Finish();
     queue.Submit(1, &commands);

     RGBA8 expectedColor = RGBA8(mExpectedLengths[0], mExpectedLengths[1], mExpectedLengths[2], 0);
     EXPECT_PIXEL_RGBA8_EQ(expectedColor, renderPass.color, 0, 0);
 }

 DAWN_INSTANTIATE_TEST(OpArrayLengthTest,
                       D3D12Backend(),
                       MetalBackend(),
                       OpenGLBackend(),
                       OpenGLESBackend(),
                       VulkanBackend());
	// Copyright 2019 The Dawn Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "tests/DawnTest.h"

	#include "common/Assert.h"
	#include "utils/ComboRenderPipelineDescriptor.h"
	#include "utils/WGPUHelpers.h"

	class OpArrayLengthTest : public DawnTest {
	protected:
	void SetUp() {
	DawnTest::SetUp();

	// Create buffers of various size to check the length() implementation
	wgpu::BufferDescriptor bufferDesc;
	bufferDesc.size = 4;
	bufferDesc.usage = wgpu::BufferUsage::Storage;
	mStorageBuffer4 = device.CreateBuffer(&bufferDesc);

	bufferDesc.size = 256;
	mStorageBuffer256 = device.CreateBuffer(&bufferDesc);

	bufferDesc.size = 512 + 256;
	mStorageBuffer512 = device.CreateBuffer(&bufferDesc);

	// Put them all in a bind group for tests to bind them easily.
	wgpu::ShaderStage kAllStages =
	wgpu::ShaderStage::Fragment \| wgpu::ShaderStage::Vertex \| wgpu::ShaderStage::Compute;
	mBindGroupLayout = utils::MakeBindGroupLayout(
	device, {{0, kAllStages, wgpu::BufferBindingType::ReadOnlyStorage},
	{1, kAllStages, wgpu::BufferBindingType::ReadOnlyStorage},
	{2, kAllStages, wgpu::BufferBindingType::ReadOnlyStorage}});

	mBindGroup = utils::MakeBindGroup(device, mBindGroupLayout,
	{
	{0, mStorageBuffer4, 0, 4},
	{1, mStorageBuffer256, 0, wgpu::kWholeSize},
	{2, mStorageBuffer512, 256, wgpu::kWholeSize},
	});

	// Common shader code to use these buffers in shaders, assuming they are in bindgroup index
	// 0.
	mShaderInterface = R"(
	[[block]] struct DataBuffer {
	data : [[stride(4)]] array<f32>;
	};

	// The length should be 1 because the buffer is 4-byte long.
	[[group(0), binding(0)]] var<storage, read> buffer1 : DataBuffer;

	// The length should be 64 because the buffer is 256 bytes long.
	[[group(0), binding(1)]] var<storage, read> buffer2 : DataBuffer;

	// The length should be (512 - 16*4) / 8 = 56 because the buffer is 512 bytes long
	// and the structure is 8 bytes big.
	struct Buffer3Data {
	a : f32;
	b : i32;
	};

	[[block]] struct Buffer3 {
	[[size(64)]] garbage : mat4x4<f32>;
	data : [[stride(8)]] array<Buffer3Data>;
	};
	[[group(0), binding(2)]] var<storage, read> buffer3 : Buffer3;
	)";

	// See comments in the shader for an explanation of these values
	mExpectedLengths = {1, 64, 56};
	}

	wgpu::Buffer mStorageBuffer4;
	wgpu::Buffer mStorageBuffer256;
	wgpu::Buffer mStorageBuffer512;

	wgpu::BindGroupLayout mBindGroupLayout;
	wgpu::BindGroup mBindGroup;
	std::string mShaderInterface;
	std::array<uint32_t, 3> mExpectedLengths;
	};

	// Test OpArrayLength in the compute stage
	TEST_P(OpArrayLengthTest, Compute) {
	// TODO(crbug.com/dawn/197): The computations for length() of unsized buffer is broken on
	// Nvidia OpenGL.
	DAWN_SUPPRESS_TEST_IF(IsNvidia() && (IsOpenGL() \|\| IsOpenGLES()));

	// Create a buffer to hold the result sizes and create a bindgroup for it.
	wgpu::BufferDescriptor bufferDesc;
	bufferDesc.usage = wgpu::BufferUsage::Storage \| wgpu::BufferUsage::CopySrc;
	bufferDesc.size = sizeof(uint32_t) * mExpectedLengths.size();
	wgpu::Buffer resultBuffer = device.CreateBuffer(&bufferDesc);

	wgpu::BindGroupLayout resultLayout = utils::MakeBindGroupLayout(
	device, {{0, wgpu::ShaderStage::Compute, wgpu::BufferBindingType::Storage}});

	wgpu::BindGroup resultBindGroup =
	utils::MakeBindGroup(device, resultLayout, {{0, resultBuffer, 0, wgpu::kWholeSize}});

	// Create the compute pipeline that stores the length()s in the result buffer.
	wgpu::BindGroupLayout bgls[] = {mBindGroupLayout, resultLayout};
	wgpu::PipelineLayoutDescriptor plDesc;
	plDesc.bindGroupLayoutCount = 2;
	plDesc.bindGroupLayouts = bgls;
	wgpu::PipelineLayout pl = device.CreatePipelineLayout(&plDesc);

	wgpu::ComputePipelineDescriptor pipelineDesc;
	pipelineDesc.layout = pl;
	pipelineDesc.compute.entryPoint = "main";
	pipelineDesc.compute.module = utils::CreateShaderModule(device, (R"(
	[[block]] struct ResultBuffer {
	data : [[stride(4)]] array<u32, 3>;
	};
	[[group(1), binding(0)]] var<storage, read_write> result : ResultBuffer;
	)" + mShaderInterface + R"(
	[[stage(compute), workgroup_size(1)]] fn main() {
	result.data[0] = arrayLength(&buffer1.data);
	result.data[1] = arrayLength(&buffer2.data);
	result.data[2] = arrayLength(&buffer3.data);
	})")
	.c_str());
	wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc);

	// Run a single instance of the compute shader
	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
	wgpu::ComputePassEncoder pass = encoder.BeginComputePass();
	pass.SetPipeline(pipeline);
	pass.SetBindGroup(0, mBindGroup);
	pass.SetBindGroup(1, resultBindGroup);
	pass.Dispatch(1);
	pass.EndPass();

	wgpu::CommandBuffer commands = encoder.Finish();
	queue.Submit(1, &commands);

	EXPECT_BUFFER_U32_RANGE_EQ(mExpectedLengths.data(), resultBuffer, 0, 3);
	}

	// Test OpArrayLength in the fragment stage
	TEST_P(OpArrayLengthTest, Fragment) {
	// TODO(crbug.com/dawn/197): The computations for length() of unsized buffer is broken on
	// Nvidia OpenGL.
	DAWN_SUPPRESS_TEST_IF(IsNvidia() && (IsOpenGL() \|\| IsOpenGLES()));

	utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);

	// Create the pipeline that computes the length of the buffers and writes it to the only render
	// pass pixel.
	wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
	[[stage(vertex)]] fn main() -> [[builtin(position)]] vec4<f32> {
	return vec4<f32>(0.0, 0.0, 0.0, 1.0);
	})");

	wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, (mShaderInterface + R"(
	[[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
	var fragColor : vec4<f32>;
	fragColor.r = f32(arrayLength(&buffer1.data)) / 255.0;
	fragColor.g = f32(arrayLength(&buffer2.data)) / 255.0;
	fragColor.b = f32(arrayLength(&buffer3.data)) / 255.0;
	fragColor.a = 0.0;
	return fragColor;
	})")
	.c_str());

	utils::ComboRenderPipelineDescriptor descriptor;
	descriptor.vertex.module = vsModule;
	descriptor.cFragment.module = fsModule;
	descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
	descriptor.cTargets[0].format = renderPass.colorFormat;
	descriptor.layout = utils::MakeBasicPipelineLayout(device, &mBindGroupLayout);
	wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);

	// "Draw" the lengths to the texture.
	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
	{
	wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
	pass.SetPipeline(pipeline);
	pass.SetBindGroup(0, mBindGroup);
	pass.Draw(1);
	pass.EndPass();
	}

	wgpu::CommandBuffer commands = encoder.Finish();
	queue.Submit(1, &commands);

	RGBA8 expectedColor = RGBA8(mExpectedLengths[0], mExpectedLengths[1], mExpectedLengths[2], 0);
	EXPECT_PIXEL_RGBA8_EQ(expectedColor, renderPass.color, 0, 0);
	}

	// Test OpArrayLength in the vertex stage
	TEST_P(OpArrayLengthTest, Vertex) {
	// TODO(crbug.com/dawn/197): The computations for length() of unsized buffer is broken on
	// Nvidia OpenGL. Also failing on all GLES (NV, Intel, SwANGLE).
	DAWN_SUPPRESS_TEST_IF(IsNvidia() && IsOpenGL());
	DAWN_SUPPRESS_TEST_IF(IsOpenGLES());

	utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);

	// Create the pipeline that computes the length of the buffers and writes it to the only render
	// pass pixel.
	wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, (mShaderInterface + R"(
	struct VertexOut {
	[[location(0)]] color : vec4<f32>;
	[[builtin(position)]] position : vec4<f32>;
	};

	[[stage(vertex)]] fn main() -> VertexOut {
	var output : VertexOut;
	output.color.r = f32(arrayLength(&buffer1.data)) / 255.0;
	output.color.g = f32(arrayLength(&buffer2.data)) / 255.0;
	output.color.b = f32(arrayLength(&buffer3.data)) / 255.0;
	output.color.a = 0.0;

	output.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
	return output;
	})")
	.c_str());

	wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
	[[stage(fragment)]]
	fn main([[location(0)]] color : vec4<f32>) -> [[location(0)]] vec4<f32> {
	return color;
	})");

	utils::ComboRenderPipelineDescriptor descriptor;
	descriptor.vertex.module = vsModule;
	descriptor.cFragment.module = fsModule;
	descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
	descriptor.cTargets[0].format = renderPass.colorFormat;
	descriptor.layout = utils::MakeBasicPipelineLayout(device, &mBindGroupLayout);
	wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);

	// "Draw" the lengths to the texture.
	wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
	{
	wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
	pass.SetPipeline(pipeline);
	pass.SetBindGroup(0, mBindGroup);
	pass.Draw(1);
	pass.EndPass();
	}

	wgpu::CommandBuffer commands = encoder.Finish();
	queue.Submit(1, &commands);

	RGBA8 expectedColor = RGBA8(mExpectedLengths[0], mExpectedLengths[1], mExpectedLengths[2], 0);
	EXPECT_PIXEL_RGBA8_EQ(expectedColor, renderPass.color, 0, 0);
	}

	DAWN_INSTANTIATE_TEST(OpArrayLengthTest,
	D3D12Backend(),
	MetalBackend(),
	OpenGLBackend(),
	OpenGLESBackend(),
	VulkanBackend());