mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-05-13 19:01:24 +00:00
a9ca8cb4ab
Bug: tint:1382 Change-Id: I58ad2c88fde1e7c96f2ae8257e6df924b94b61db Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/77660 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Commit-Queue: Ben Clayton <bclayton@google.com>
850 lines
36 KiB
C++
850 lines
36 KiB
C++
// 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({wgpu::FeatureName::PipelineStatisticsQuery}));
|
||
}
|
||
|
||
std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
|
||
std::vector<wgpu::FeatureName> requiredFeatures = {};
|
||
if (SupportsFeatures({wgpu::FeatureName::PipelineStatisticsQuery})) {
|
||
requiredFeatures.push_back(wgpu::FeatureName::PipelineStatisticsQuery);
|
||
}
|
||
|
||
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({wgpu::FeatureName::TimestampQuery}));
|
||
}
|
||
|
||
std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
|
||
std::vector<wgpu::FeatureName> requiredFeatures = {};
|
||
if (SupportsFeatures({wgpu::FeatureName::TimestampQuery})) {
|
||
requiredFeatures.push_back(wgpu::FeatureName::TimestampQuery);
|
||
}
|
||
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());
|