| // Copyright 2020 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 "utils/ComboRenderPipelineDescriptor.h" | |
| #include "utils/WGPUHelpers.h" | |
| class QueryTests : public DawnTest { | |
| protected: | |
| wgpu::Buffer CreateResolveBuffer(uint64_t size) { | |
| wgpu::BufferDescriptor descriptor; | |
| descriptor.size = size; | |
| descriptor.usage = wgpu::BufferUsage::QueryResolve | wgpu::BufferUsage::CopySrc | | |
| wgpu::BufferUsage::CopyDst; | |
| return device.CreateBuffer(&descriptor); | |
| } | |
| }; | |
| // Clear the content of the result buffer into 0xFFFFFFFF. | |
| constexpr static uint64_t kSentinelValue = ~uint64_t(0u); | |
| constexpr static uint64_t kZero = 0u; | |
| constexpr uint64_t kMinDestinationOffset = 256; | |
| constexpr uint64_t kMinCount = kMinDestinationOffset / sizeof(uint64_t); | |
| class OcclusionExpectation : public detail::Expectation { | |
| public: | |
| enum class Result { Zero, NonZero }; | |
| ~OcclusionExpectation() override = default; | |
| OcclusionExpectation(Result expected) { | |
| mExpected = expected; | |
| } | |
| testing::AssertionResult Check(const void* data, size_t size) override { | |
| ASSERT(size % sizeof(uint64_t) == 0); | |
| const uint64_t* actual = static_cast<const uint64_t*>(data); | |
| for (size_t i = 0; i < size / sizeof(uint64_t); i++) { | |
| if (actual[i] == kSentinelValue) { | |
| return testing::AssertionFailure() | |
| << "Data[" << i << "] was not written (it kept the sentinel value of " | |
| << kSentinelValue << ")." << std::endl; | |
| } | |
| if (mExpected == Result::Zero && actual[i] != 0) { | |
| return testing::AssertionFailure() | |
| << "Expected data[" << i << "] to be zero, actual: " << actual[i] << "." | |
| << std::endl; | |
| } | |
| if (mExpected == Result::NonZero && actual[i] == 0) { | |
| return testing::AssertionFailure() | |
| << "Expected data[" << i << "] to be non-zero." << std::endl; | |
| } | |
| } | |
| return testing::AssertionSuccess(); | |
| } | |
| private: | |
| Result mExpected; | |
| }; | |
| class OcclusionQueryTests : public QueryTests { | |
| protected: | |
| void SetUp() override { | |
| DawnTest::SetUp(); | |
| // Create basic render pipeline | |
| vsModule = utils::CreateShaderModule(device, R"( | |
| [[stage(vertex)]] | |
| fn main([[builtin(vertex_index)]] VertexIndex : u32) -> [[builtin(position)]] vec4<f32> { | |
| var pos = array<vec2<f32>, 3>( | |
| vec2<f32>( 1.0, 1.0), | |
| vec2<f32>(-1.0, -1.0), | |
| vec2<f32>( 1.0, -1.0)); | |
| return vec4<f32>(pos[VertexIndex], 0.0, 1.0); | |
| })"); | |
| fsModule = utils::CreateShaderModule(device, R"( | |
| [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> { | |
| return vec4<f32>(0.0, 1.0, 0.0, 1.0); | |
| })"); | |
| utils::ComboRenderPipelineDescriptor descriptor; | |
| descriptor.vertex.module = vsModule; | |
| descriptor.cFragment.module = fsModule; | |
| pipeline = device.CreateRenderPipeline(&descriptor); | |
| } | |
| struct ScissorRect { | |
| uint32_t x; | |
| uint32_t y; | |
| uint32_t width; | |
| uint32_t height; | |
| }; | |
| wgpu::QuerySet CreateOcclusionQuerySet(uint32_t count) { | |
| wgpu::QuerySetDescriptor descriptor; | |
| descriptor.count = count; | |
| descriptor.type = wgpu::QueryType::Occlusion; | |
| return device.CreateQuerySet(&descriptor); | |
| } | |
| wgpu::Texture CreateRenderTexture(wgpu::TextureFormat format) { | |
| wgpu::TextureDescriptor descriptor; | |
| descriptor.size = {kRTSize, kRTSize, 1}; | |
| descriptor.format = format; | |
| descriptor.usage = wgpu::TextureUsage::RenderAttachment; | |
| return device.CreateTexture(&descriptor); | |
| } | |
| void TestOcclusionQueryWithDepthStencilTest(bool depthTestEnabled, | |
| bool stencilTestEnabled, | |
| OcclusionExpectation::Result expected) { | |
| constexpr uint32_t kQueryCount = 1; | |
| utils::ComboRenderPipelineDescriptor descriptor; | |
| descriptor.vertex.module = vsModule; | |
| descriptor.cFragment.module = fsModule; | |
| // Enable depth and stencil tests and set comparison tests never pass. | |
| wgpu::DepthStencilState* depthStencil = | |
| descriptor.EnableDepthStencil(wgpu::TextureFormat::Depth24PlusStencil8); | |
| depthStencil->depthCompare = | |
| depthTestEnabled ? wgpu::CompareFunction::Never : wgpu::CompareFunction::Always; | |
| depthStencil->stencilFront.compare = | |
| stencilTestEnabled ? wgpu::CompareFunction::Never : wgpu::CompareFunction::Always; | |
| depthStencil->stencilBack.compare = | |
| stencilTestEnabled ? wgpu::CompareFunction::Never : wgpu::CompareFunction::Always; | |
| wgpu::RenderPipeline renderPipeline = device.CreateRenderPipeline(&descriptor); | |
| wgpu::Texture renderTarget = CreateRenderTexture(wgpu::TextureFormat::RGBA8Unorm); | |
| wgpu::TextureView renderTargetView = renderTarget.CreateView(); | |
| wgpu::Texture depthTexture = CreateRenderTexture(wgpu::TextureFormat::Depth24PlusStencil8); | |
| wgpu::TextureView depthTextureView = depthTexture.CreateView(); | |
| wgpu::QuerySet querySet = CreateOcclusionQuerySet(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| // Set all bits in buffer to check 0 is correctly written if there is no sample passed the | |
| // occlusion testing | |
| queue.WriteBuffer(destination, 0, &kSentinelValue, sizeof(kSentinelValue)); | |
| utils::ComboRenderPassDescriptor renderPass({renderTargetView}, depthTextureView); | |
| renderPass.occlusionQuerySet = querySet; | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); | |
| pass.SetPipeline(renderPipeline); | |
| pass.SetStencilReference(0); | |
| pass.BeginOcclusionQuery(0); | |
| pass.Draw(3); | |
| pass.EndOcclusionQuery(); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, sizeof(uint64_t), new OcclusionExpectation(expected)); | |
| } | |
| void TestOcclusionQueryWithScissorTest(ScissorRect rect, | |
| OcclusionExpectation::Result expected) { | |
| constexpr uint32_t kQueryCount = 1; | |
| wgpu::QuerySet querySet = CreateOcclusionQuerySet(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| // Set all bits in buffer to check 0 is correctly written if there is no sample passed the | |
| // occlusion testing | |
| queue.WriteBuffer(destination, 0, &kSentinelValue, sizeof(kSentinelValue)); | |
| utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); | |
| renderPass.renderPassInfo.occlusionQuerySet = querySet; | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); | |
| pass.SetPipeline(pipeline); | |
| pass.SetScissorRect(rect.x, rect.y, rect.width, rect.height); | |
| pass.BeginOcclusionQuery(0); | |
| pass.Draw(3); | |
| pass.EndOcclusionQuery(); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, sizeof(uint64_t), new OcclusionExpectation(expected)); | |
| } | |
| wgpu::ShaderModule vsModule; | |
| wgpu::ShaderModule fsModule; | |
| wgpu::RenderPipeline pipeline; | |
| constexpr static unsigned int kRTSize = 4; | |
| }; | |
| // Test creating query set with the type of Occlusion | |
| TEST_P(OcclusionQueryTests, QuerySetCreation) { | |
| // Zero-sized query set is allowed. | |
| CreateOcclusionQuerySet(0); | |
| CreateOcclusionQuerySet(1); | |
| } | |
| // Test destroying query set | |
| TEST_P(OcclusionQueryTests, QuerySetDestroy) { | |
| wgpu::QuerySet querySet = CreateOcclusionQuerySet(1); | |
| querySet.Destroy(); | |
| } | |
| // Draw a bottom right triangle with depth/stencil testing enabled and check whether there is | |
| // sample passed the testing by non-precise occlusion query with the results: | |
| // zero indicates that no sample passed depth/stencil testing, | |
| // non-zero indicates that at least one sample passed depth/stencil testing. | |
| TEST_P(OcclusionQueryTests, QueryWithDepthStencilTest) { | |
| // Disable depth/stencil testing, the samples always pass the testing, the expected occlusion | |
| // result is non-zero. | |
| TestOcclusionQueryWithDepthStencilTest(false, false, OcclusionExpectation::Result::NonZero); | |
| // Only enable depth testing and set the samples never pass the testing, the expected occlusion | |
| // result is zero. | |
| TestOcclusionQueryWithDepthStencilTest(true, false, OcclusionExpectation::Result::Zero); | |
| // Only enable stencil testing and set the samples never pass the testing, the expected | |
| // occlusion result is zero. | |
| TestOcclusionQueryWithDepthStencilTest(false, true, OcclusionExpectation::Result::Zero); | |
| } | |
| // Draw a bottom right triangle with scissor testing enabled and check whether there is | |
| // sample passed the testing by non-precise occlusion query with the results: | |
| // zero indicates that no sample passed scissor testing, | |
| // non-zero indicates that at least one sample passed scissor testing. | |
| TEST_P(OcclusionQueryTests, QueryWithScissorTest) { | |
| // TODO(hao.x.li@intel.com): It's failed weirdly on Intel TGL（Window Vulkan) which says | |
| // the destination buffer keep sentinel value in the second case, it cannot be reproduced with | |
| // any debug actions including Vulkan validation layers enabled, and takes time to find out if | |
| // the WriteBuffer and ResolveQuerySet are not executed in order or the ResolveQuerySet does not | |
| // copy the result to the buffer. In order to integrate end2end tests to Intel driver CL without | |
| // unknown issues, skip it until we find the root cause. | |
| DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel()); | |
| // Test there are samples passed scissor testing, the expected occlusion result is non-zero. | |
| TestOcclusionQueryWithScissorTest({2, 1, 2, 1}, OcclusionExpectation::Result::NonZero); | |
| // Test there is no sample passed scissor testing, the expected occlusion result is zero. | |
| TestOcclusionQueryWithScissorTest({0, 0, 2, 1}, OcclusionExpectation::Result::Zero); | |
| } | |
| // Test begin occlusion query with same query index on different render pass | |
| TEST_P(OcclusionQueryTests, Rewrite) { | |
| constexpr uint32_t kQueryCount = 1; | |
| wgpu::QuerySet querySet = CreateOcclusionQuerySet(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| // Set all bits in buffer to check 0 is correctly written if there is no sample passed the | |
| // occlusion testing | |
| queue.WriteBuffer(destination, 0, &kSentinelValue, sizeof(kSentinelValue)); | |
| utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); | |
| renderPass.renderPassInfo.occlusionQuerySet = querySet; | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| // Begin occlusion without draw call | |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); | |
| pass.BeginOcclusionQuery(0); | |
| pass.EndOcclusionQuery(); | |
| pass.EndPass(); | |
| // Begin occlusion with same query index with draw call | |
| wgpu::RenderPassEncoder rewritePass = encoder.BeginRenderPass(&renderPass.renderPassInfo); | |
| rewritePass.SetPipeline(pipeline); | |
| rewritePass.BeginOcclusionQuery(0); | |
| rewritePass.Draw(3); | |
| rewritePass.EndOcclusionQuery(); | |
| rewritePass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, sizeof(uint64_t), | |
| new OcclusionExpectation(OcclusionExpectation::Result::NonZero)); | |
| } | |
| // Test resolving occlusion query correctly if the queries are written sparsely, which also tests | |
| // the query resetting at the start of render passes on Vulkan backend. | |
| TEST_P(OcclusionQueryTests, ResolveSparseQueries) { | |
| // TODO(hao.x.li@intel.com): Fails on Intel Windows Vulkan due to a driver issue that | |
| // vkCmdFillBuffer and vkCmdCopyQueryPoolResults are not executed in order, skip it util | |
| // the issue is fixed. | |
| DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel()); | |
| // TODO(hao.x.li@intel.com): Investigate why it's failed on D3D12 on Nvidia when running with | |
| // the previous occlusion tests. Expect resolve to 0 for these unwritten queries but the | |
| // occlusion result of the previous tests is got. | |
| DAWN_SUPPRESS_TEST_IF(IsD3D12() && IsNvidia()); | |
| constexpr uint32_t kQueryCount = 7; | |
| wgpu::QuerySet querySet = CreateOcclusionQuerySet(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| // Set sentinel values to check the queries are resolved correctly if the queries are | |
| // written sparsely. | |
| std::vector<uint64_t> sentinelValues(kQueryCount, kSentinelValue); | |
| queue.WriteBuffer(destination, 0, sentinelValues.data(), kQueryCount * sizeof(uint64_t)); | |
| utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); | |
| renderPass.renderPassInfo.occlusionQuerySet = querySet; | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); | |
| pass.SetPipeline(pipeline); | |
| // Write queries sparsely for testing the query resetting on Vulkan and resolving unwritten | |
| // queries to 0. | |
| // 0 - not written (tests starting with not written). | |
| // 1 - written (tests combing multiple written, although other tests already do it). | |
| // 2 - written. | |
| // 3 - not written (tests skipping over not written in the middle). | |
| // 4 - not written. | |
| // 5 - written (tests another written query in the middle). | |
| // 6 - not written (tests the last query not being written). | |
| pass.BeginOcclusionQuery(1); | |
| pass.Draw(3); | |
| pass.EndOcclusionQuery(); | |
| pass.BeginOcclusionQuery(2); | |
| pass.Draw(3); | |
| pass.EndOcclusionQuery(); | |
| pass.BeginOcclusionQuery(5); | |
| pass.Draw(3); | |
| pass.EndOcclusionQuery(); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| // The query at index 0 should be resolved to 0. | |
| EXPECT_BUFFER_U64_RANGE_EQ(&kZero, destination, 0, 1); | |
| EXPECT_BUFFER(destination, sizeof(uint64_t), 2 * sizeof(uint64_t), | |
| new OcclusionExpectation(OcclusionExpectation::Result::NonZero)); | |
| // The queries at index 3 and 4 should be resolved to 0. | |
| std::vector<uint64_t> zeros(2, kZero); | |
| EXPECT_BUFFER_U64_RANGE_EQ(zeros.data(), destination, 3 * sizeof(uint64_t), 2); | |
| EXPECT_BUFFER(destination, 5 * sizeof(uint64_t), sizeof(uint64_t), | |
| new OcclusionExpectation(OcclusionExpectation::Result::NonZero)); | |
| // The query at index 6 should be resolved to 0. | |
| EXPECT_BUFFER_U64_RANGE_EQ(&kZero, destination, 6 * sizeof(uint64_t), 1); | |
| } | |
| // Test resolving occlusion query to 0 if all queries are not written | |
| TEST_P(OcclusionQueryTests, ResolveWithoutWritten) { | |
| // TODO(hao.x.li@intel.com): Investigate why it's failed on D3D12 on Nvidia when running with | |
| // the previous occlusion tests. Expect resolve to 0 but the occlusion result of the previous | |
| // tests is got. | |
| DAWN_SUPPRESS_TEST_IF(IsD3D12() && IsNvidia()); | |
| constexpr uint32_t kQueryCount = 1; | |
| wgpu::QuerySet querySet = CreateOcclusionQuerySet(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| // Set sentinel values to check 0 is correctly written if resolving query set without | |
| // any written. | |
| queue.WriteBuffer(destination, 0, &kSentinelValue, sizeof(kSentinelValue)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER_U64_RANGE_EQ(&kZero, destination, 0, 1); | |
| } | |
| // Test resolving occlusion query to the destination buffer with offset | |
| TEST_P(OcclusionQueryTests, ResolveToBufferWithOffset) { | |
| constexpr uint32_t kQueryCount = 2; | |
| wgpu::QuerySet querySet = CreateOcclusionQuerySet(kQueryCount); | |
| utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); | |
| renderPass.renderPassInfo.occlusionQuerySet = querySet; | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); | |
| pass.SetPipeline(pipeline); | |
| pass.BeginOcclusionQuery(0); | |
| pass.Draw(3); | |
| pass.EndOcclusionQuery(); | |
| pass.EndPass(); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| constexpr uint64_t kBufferSize = kQueryCount * sizeof(uint64_t) + kMinDestinationOffset; | |
| constexpr uint64_t kCount = kQueryCount + kMinCount; | |
| // Resolve the query result to first slot in the buffer, other slots should not be written. | |
| { | |
| wgpu::Buffer destination = CreateResolveBuffer(kBufferSize); | |
| // Set sentinel values to check the query is resolved to the correct slot of the buffer. | |
| std::vector<uint64_t> sentinelValues(kCount, kSentinelValue); | |
| queue.WriteBuffer(destination, 0, sentinelValues.data(), kBufferSize); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.ResolveQuerySet(querySet, 0, 1, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, sizeof(uint64_t), | |
| new OcclusionExpectation(OcclusionExpectation::Result::NonZero)); | |
| EXPECT_BUFFER_U64_RANGE_EQ(sentinelValues.data(), destination, sizeof(uint64_t), | |
| kCount - 1); | |
| } | |
| // Resolve the query result to second slot in the buffer, the first one should not be written. | |
| { | |
| wgpu::Buffer destination = CreateResolveBuffer(kBufferSize); | |
| // Set sentinel values to check the query is resolved to the correct slot of the buffer. | |
| std::vector<uint64_t> sentinelValues(kCount, kSentinelValue); | |
| queue.WriteBuffer(destination, 0, sentinelValues.data(), kBufferSize); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.ResolveQuerySet(querySet, 0, 1, destination, kMinDestinationOffset); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER_U64_RANGE_EQ(sentinelValues.data(), destination, 0, kMinCount); | |
| EXPECT_BUFFER(destination, kMinDestinationOffset, sizeof(uint64_t), | |
| new OcclusionExpectation(OcclusionExpectation::Result::NonZero)); | |
| } | |
| } | |
| DAWN_INSTANTIATE_TEST(OcclusionQueryTests, D3D12Backend(), MetalBackend(), VulkanBackend()); | |
| class PipelineStatisticsQueryTests : public QueryTests { | |
| protected: | |
| void SetUp() override { | |
| DawnTest::SetUp(); | |
| // Skip all tests if pipeline statistics feature is not supported | |
| DAWN_TEST_UNSUPPORTED_IF(!SupportsFeatures({"pipeline-statistics-query"})); | |
| } | |
| std::vector<const char*> GetRequiredFeatures() override { | |
| std::vector<const char*> requiredFeatures = {}; | |
| if (SupportsFeatures({"pipeline-statistics-query"})) { | |
| requiredFeatures.push_back("pipeline-statistics-query"); | |
| } | |
| return requiredFeatures; | |
| } | |
| wgpu::QuerySet CreateQuerySetForPipelineStatistics( | |
| uint32_t queryCount, | |
| std::vector<wgpu::PipelineStatisticName> pipelineStatistics = {}) { | |
| wgpu::QuerySetDescriptor descriptor; | |
| descriptor.count = queryCount; | |
| descriptor.type = wgpu::QueryType::PipelineStatistics; | |
| if (pipelineStatistics.size() > 0) { | |
| descriptor.pipelineStatistics = pipelineStatistics.data(); | |
| descriptor.pipelineStatisticsCount = pipelineStatistics.size(); | |
| } | |
| return device.CreateQuerySet(&descriptor); | |
| } | |
| }; | |
| // Test creating query set with the type of PipelineStatistics | |
| TEST_P(PipelineStatisticsQueryTests, QuerySetCreation) { | |
| // Zero-sized query set is allowed. | |
| CreateQuerySetForPipelineStatistics(0, {wgpu::PipelineStatisticName::ClipperInvocations, | |
| wgpu::PipelineStatisticName::VertexShaderInvocations}); | |
| CreateQuerySetForPipelineStatistics(1, {wgpu::PipelineStatisticName::ClipperInvocations, | |
| wgpu::PipelineStatisticName::VertexShaderInvocations}); | |
| } | |
| DAWN_INSTANTIATE_TEST(PipelineStatisticsQueryTests, | |
| D3D12Backend(), | |
| MetalBackend(), | |
| OpenGLBackend(), | |
| OpenGLESBackend(), | |
| VulkanBackend()); | |
| class TimestampExpectation : public detail::Expectation { | |
| public: | |
| ~TimestampExpectation() override = default; | |
| // Expect the timestamp results are greater than 0. | |
| testing::AssertionResult Check(const void* data, size_t size) override { | |
| ASSERT(size % sizeof(uint64_t) == 0); | |
| const uint64_t* timestamps = static_cast<const uint64_t*>(data); | |
| for (size_t i = 0; i < size / sizeof(uint64_t); i++) { | |
| if (timestamps[i] == 0) { | |
| return testing::AssertionFailure() | |
| << "Expected data[" << i << "] to be greater than 0." << std::endl; | |
| } | |
| } | |
| return testing::AssertionSuccess(); | |
| } | |
| }; | |
| class TimestampQueryTests : public QueryTests { | |
| protected: | |
| void SetUp() override { | |
| DawnTest::SetUp(); | |
| // Skip all tests if timestamp feature is not supported | |
| DAWN_TEST_UNSUPPORTED_IF(!SupportsFeatures({"timestamp-query"})); | |
| } | |
| std::vector<const char*> GetRequiredFeatures() override { | |
| std::vector<const char*> requiredFeatures = {}; | |
| if (SupportsFeatures({"timestamp-query"})) { | |
| requiredFeatures.push_back("timestamp-query"); | |
| } | |
| return requiredFeatures; | |
| } | |
| wgpu::QuerySet CreateQuerySetForTimestamp(uint32_t queryCount) { | |
| wgpu::QuerySetDescriptor descriptor; | |
| descriptor.count = queryCount; | |
| descriptor.type = wgpu::QueryType::Timestamp; | |
| return device.CreateQuerySet(&descriptor); | |
| } | |
| }; | |
| // Test creating query set with the type of Timestamp | |
| TEST_P(TimestampQueryTests, QuerySetCreation) { | |
| // Zero-sized query set is allowed. | |
| CreateQuerySetForTimestamp(0); | |
| CreateQuerySetForTimestamp(1); | |
| } | |
| // Test calling timestamp query from command encoder | |
| TEST_P(TimestampQueryTests, TimestampOnCommandEncoder) { | |
| constexpr uint32_t kQueryCount = 2; | |
| // Write timestamp with different query indexes | |
| { | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.WriteTimestamp(querySet, 1); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| // Write timestamp with same query index outside pass on same encoder | |
| { | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.WriteTimestamp(querySet, 1); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.WriteTimestamp(querySet, 1); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| } | |
| // Test calling timestamp query from render pass encoder | |
| TEST_P(TimestampQueryTests, TimestampOnRenderPass) { | |
| constexpr uint32_t kQueryCount = 2; | |
| // Write timestamp with different query indexes | |
| { | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1); | |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); | |
| pass.WriteTimestamp(querySet, 0); | |
| pass.WriteTimestamp(querySet, 1); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| // Write timestamp with same query index, not need test rewrite inside render pass due to it's | |
| // not allowed | |
| { | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.WriteTimestamp(querySet, 1); | |
| utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1); | |
| wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo); | |
| pass.WriteTimestamp(querySet, 0); | |
| pass.WriteTimestamp(querySet, 1); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| } | |
| // Test calling timestamp query from compute pass encoder | |
| TEST_P(TimestampQueryTests, TimestampOnComputePass) { | |
| constexpr uint32_t kQueryCount = 2; | |
| // Write timestamp with different query indexes | |
| { | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); | |
| pass.WriteTimestamp(querySet, 0); | |
| pass.WriteTimestamp(querySet, 1); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| // Write timestamp with same query index on both the outside and the inside of the compute pass | |
| { | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.WriteTimestamp(querySet, 1); | |
| wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); | |
| pass.WriteTimestamp(querySet, 0); | |
| pass.WriteTimestamp(querySet, 1); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| // Write timestamp with same query index inside compute pass | |
| { | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| wgpu::ComputePassEncoder pass = encoder.BeginComputePass(); | |
| pass.WriteTimestamp(querySet, 0); | |
| pass.WriteTimestamp(querySet, 1); | |
| pass.WriteTimestamp(querySet, 0); | |
| pass.WriteTimestamp(querySet, 1); | |
| pass.EndPass(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| } | |
| // Test resolving timestamp query from another different encoder | |
| TEST_P(TimestampQueryTests, ResolveFromAnotherEncoder) { | |
| constexpr uint32_t kQueryCount = 2; | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder timestampEncoder = device.CreateCommandEncoder(); | |
| timestampEncoder.WriteTimestamp(querySet, 0); | |
| timestampEncoder.WriteTimestamp(querySet, 1); | |
| wgpu::CommandBuffer timestampCommands = timestampEncoder.Finish(); | |
| queue.Submit(1, ×tampCommands); | |
| wgpu::CommandEncoder resolveEncoder = device.CreateCommandEncoder(); | |
| resolveEncoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer resolveCommands = resolveEncoder.Finish(); | |
| queue.Submit(1, &resolveCommands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| // Test resolving timestamp query correctly if the queries are written sparsely | |
| TEST_P(TimestampQueryTests, ResolveSparseQueries) { | |
| // TODO(hao.x.li@intel.com): Fails on Intel Windows Vulkan due to a driver issue that | |
| // vkCmdFillBuffer and vkCmdCopyQueryPoolResults are not executed in order, skip it util | |
| // the issue is fixed. | |
| DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel()); | |
| constexpr uint32_t kQueryCount = 4; | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| // Set sentinel values to check the queries are resolved correctly if the queries are | |
| // written sparsely | |
| std::vector<uint64_t> sentinelValues{0, kSentinelValue, 0, kSentinelValue}; | |
| queue.WriteBuffer(destination, 0, sentinelValues.data(), kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.WriteTimestamp(querySet, 2); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, sizeof(uint64_t), new TimestampExpectation); | |
| // The query with no value written should be resolved to 0. | |
| EXPECT_BUFFER_U64_RANGE_EQ(&kZero, destination, sizeof(uint64_t), 1); | |
| EXPECT_BUFFER(destination, 2 * sizeof(uint64_t), sizeof(uint64_t), new TimestampExpectation); | |
| // The query with no value written should be resolved to 0. | |
| EXPECT_BUFFER_U64_RANGE_EQ(&kZero, destination, 3 * sizeof(uint64_t), 1); | |
| } | |
| // Test resolving timestamp query to 0 if all queries are not written | |
| TEST_P(TimestampQueryTests, ResolveWithoutWritten) { | |
| constexpr uint32_t kQueryCount = 2; | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| // Set sentinel values to check 0 is correctly written if resolving query set with no | |
| // query is written | |
| std::vector<uint64_t> sentinelValues(kQueryCount, kSentinelValue); | |
| queue.WriteBuffer(destination, 0, sentinelValues.data(), kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.ResolveQuerySet(querySet, 0, kQueryCount, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| std::vector<uint64_t> expectedZeros(kQueryCount); | |
| EXPECT_BUFFER_U64_RANGE_EQ(expectedZeros.data(), destination, 0, kQueryCount); | |
| } | |
| // Test resolving timestamp query to one slot in the buffer | |
| TEST_P(TimestampQueryTests, ResolveToBufferWithOffset) { | |
| // TODO(hao.x.li@intel.com): Fails on Intel Windows Vulkan due to a driver issue that | |
| // vkCmdFillBuffer and vkCmdCopyQueryPoolResults are not executed in order, skip it util | |
| // the issue is fixed. | |
| DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel()); | |
| constexpr uint32_t kQueryCount = 2; | |
| constexpr uint64_t kBufferSize = kQueryCount * sizeof(uint64_t) + kMinDestinationOffset; | |
| constexpr uint64_t kCount = kQueryCount + kMinCount; | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| // Resolve the query result to first slot in the buffer, other slots should not be written | |
| { | |
| wgpu::Buffer destination = CreateResolveBuffer(kBufferSize); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.ResolveQuerySet(querySet, 0, 1, destination, 0); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| std::vector<uint64_t> zeros(kCount - 1, kZero); | |
| EXPECT_BUFFER(destination, 0, sizeof(uint64_t), new TimestampExpectation); | |
| EXPECT_BUFFER_U64_RANGE_EQ(zeros.data(), destination, sizeof(uint64_t), kCount - 1); | |
| } | |
| // Resolve the query result to the buffer with offset, the slots before the offset | |
| // should not be written | |
| { | |
| wgpu::Buffer destination = CreateResolveBuffer(kBufferSize); | |
| // Set sentinel values to check the query is resolved to the correct slot of the buffer. | |
| std::vector<uint64_t> sentinelValues(kCount, kZero); | |
| queue.WriteBuffer(destination, 0, sentinelValues.data(), kBufferSize); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| encoder.WriteTimestamp(querySet, 0); | |
| encoder.ResolveQuerySet(querySet, 0, 1, destination, kMinDestinationOffset); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| std::vector<uint64_t> zeros(kMinCount, kZero); | |
| EXPECT_BUFFER_U64_RANGE_EQ(zeros.data(), destination, 0, kMinCount); | |
| EXPECT_BUFFER(destination, kMinDestinationOffset, sizeof(uint64_t), | |
| new TimestampExpectation); | |
| } | |
| } | |
| // Test resolving a query set twice into the same destination buffer with potentially overlapping | |
| // ranges | |
| TEST_P(TimestampQueryTests, ResolveTwiceToSameBuffer) { | |
| // TODO(hao.x.li@intel.com): Fails on Intel Windows Vulkan due to a driver issue that | |
| // vkCmdFillBuffer and vkCmdCopyQueryPoolResults are not executed in order, skip it util | |
| // the issue is fixed. | |
| DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel()); | |
| constexpr uint32_t kQueryCount = kMinCount + 2; | |
| wgpu::QuerySet querySet = CreateQuerySetForTimestamp(kQueryCount); | |
| wgpu::Buffer destination = CreateResolveBuffer(kQueryCount * sizeof(uint64_t)); | |
| wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); | |
| for (uint32_t i = 0; i < kQueryCount; i++) { | |
| encoder.WriteTimestamp(querySet, i); | |
| } | |
| encoder.ResolveQuerySet(querySet, 0, kMinCount + 1, destination, 0); | |
| encoder.ResolveQuerySet(querySet, kMinCount, 2, destination, kMinDestinationOffset); | |
| wgpu::CommandBuffer commands = encoder.Finish(); | |
| queue.Submit(1, &commands); | |
| EXPECT_BUFFER(destination, 0, kQueryCount * sizeof(uint64_t), new TimestampExpectation); | |
| } | |
| DAWN_INSTANTIATE_TEST(TimestampQueryTests, | |
| D3D12Backend(), | |
| MetalBackend(), | |
| OpenGLBackend(), | |
| OpenGLESBackend(), | |
| VulkanBackend()); |