1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2016 The Khronos Group Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Vulkan Statistics Query Tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktQueryPoolStatisticsTests.hpp"
25 #include "vktTestCase.hpp"
26
27 #include "vktDrawImageObjectUtil.hpp"
28 #include "vktDrawBufferObjectUtil.hpp"
29 #include "vktDrawCreateInfoUtil.hpp"
30 #include "vkBuilderUtil.hpp"
31 #include "vkRefUtil.hpp"
32 #include "vkPrograms.hpp"
33 #include "vkTypeUtil.hpp"
34 #include "vkCmdUtil.hpp"
35 #include "vkObjUtil.hpp"
36
37 #include "deMath.h"
38
39 #include "tcuTestLog.hpp"
40 #include "tcuResource.hpp"
41 #include "tcuImageCompare.hpp"
42 #include "vkImageUtil.hpp"
43 #include "tcuCommandLine.hpp"
44 #include "tcuRGBA.hpp"
45 #include "tcuStringTemplate.hpp"
46 #include "tcuMaybe.hpp"
47
48 #include <vector>
49 #include <utility>
50 #include <algorithm>
51
52 using std::vector;
53 using std::pair;
54
55 namespace vkt
56 {
57 namespace QueryPool
58 {
59 namespace
60 {
61
62 using namespace vk;
63 using namespace Draw;
64
65 //Test parameters
66 enum
67 {
68 WIDTH = 64,
69 HEIGHT = 64
70 };
71
72 enum ResetType
73 {
74 RESET_TYPE_NORMAL = 0,
75 RESET_TYPE_HOST,
76 RESET_TYPE_BEFORE_COPY,
77 RESET_TYPE_AFTER_COPY,
78 RESET_TYPE_LAST
79 };
80
81 enum CopyType
82 {
83 COPY_TYPE_GET = 0,
84 COPY_TYPE_CMD,
85 };
86
87 enum StrideType
88 {
89 STRIDE_TYPE_VALID = 0,
90 STRIDE_TYPE_ZERO,
91 };
92
93 enum ClearOperation
94 {
95 CLEAR_NOOP,
96 CLEAR_COLOR,
97 CLEAR_DEPTH
98 };
99
inputTypeToGLString(const VkPrimitiveTopology & inputType)100 std::string inputTypeToGLString (const VkPrimitiveTopology& inputType)
101 {
102 switch (inputType)
103 {
104 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
105 return "points";
106 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
107 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
108 return "lines";
109 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
110 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
111 return "lines_adjacency";
112 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
113 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
114 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
115 return "triangles";
116 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
117 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
118 return "triangles_adjacency";
119 default:
120 DE_ASSERT(DE_FALSE);
121 return "error";
122 }
123 }
124
outputTypeToGLString(const VkPrimitiveTopology & outputType)125 std::string outputTypeToGLString (const VkPrimitiveTopology& outputType)
126 {
127 switch (outputType)
128 {
129 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
130 return "points";
131 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
132 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
133 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
134 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
135 return "line_strip";
136 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
137 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
138 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
139 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
140 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
141 return "triangle_strip";
142 default:
143 DE_ASSERT(DE_FALSE);
144 return "error";
145 }
146 }
147
148 using Pair32 = pair<deUint32, deUint32>;
149 using Pair64 = pair<deUint64, deUint64>;
150 using ResultsVector = vector<deUint64>;
151 using ResultsVectorWithAvailability = vector<Pair64>;
152
153 // Get query pool results as a vector. Note results are always converted to
154 // deUint64, but the actual vkGetQueryPoolResults call will use the 64-bits flag
155 // or not depending on your preferences.
GetQueryPoolResultsVector(ResultsVector & output,const DeviceInterface & vk,vk::VkDevice device,vk::VkQueryPool queryPool,deUint32 firstQuery,deUint32 queryCount,VkQueryResultFlags flags)156 vk::VkResult GetQueryPoolResultsVector(
157 ResultsVector& output, const DeviceInterface& vk, vk::VkDevice device, vk::VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkQueryResultFlags flags)
158 {
159 if (flags & vk::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)
160 TCU_THROW(InternalError, "Availability flag passed when expecting results as ResultsVector");
161
162 vk::VkResult result;
163 output.resize(queryCount);
164
165 if (flags & vk::VK_QUERY_RESULT_64_BIT)
166 {
167 constexpr size_t stride = sizeof(ResultsVector::value_type);
168 const size_t totalSize = stride * output.size();
169 result = vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, totalSize, output.data(), stride, flags);
170 }
171 else
172 {
173 using IntermediateVector = vector<deUint32>;
174
175 IntermediateVector intermediate(queryCount);
176
177 // Try to preserve existing data if possible.
178 std::transform(begin(output), end(output), begin(intermediate), [](deUint64 v) { return static_cast<deUint32>(v); });
179
180 constexpr size_t stride = sizeof(decltype(intermediate)::value_type);
181 const size_t totalSize = stride * intermediate.size();
182
183 // Get and copy results.
184 result = vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, totalSize, intermediate.data(), stride, flags);
185 std::copy(begin(intermediate), end(intermediate), begin(output));
186 }
187
188 return result;
189 }
190
191 // Same as the normal GetQueryPoolResultsVector but returning the availability
192 // bit associated to each query in addition to the query value.
GetQueryPoolResultsVector(ResultsVectorWithAvailability & output,const DeviceInterface & vk,vk::VkDevice device,vk::VkQueryPool queryPool,deUint32 firstQuery,deUint32 queryCount,VkQueryResultFlags flags)193 vk::VkResult GetQueryPoolResultsVector(
194 ResultsVectorWithAvailability& output, const DeviceInterface& vk, vk::VkDevice device, vk::VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkQueryResultFlags flags)
195 {
196 flags |= vk::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
197
198 vk::VkResult result;
199 output.resize(queryCount);
200
201 if (flags & vk::VK_QUERY_RESULT_64_BIT)
202 {
203 constexpr size_t stride = sizeof(ResultsVectorWithAvailability::value_type);
204 const size_t totalSize = stride * output.size();
205 result = vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, totalSize, output.data(), stride, flags);
206 }
207 else
208 {
209 using IntermediateVector = vector<Pair32>;
210
211 IntermediateVector intermediate(queryCount);
212
213 // Try to preserve existing output data if possible.
214 std::transform(begin(output), end(output), begin(intermediate), [](const Pair64& p) { return Pair32{static_cast<deUint32>(p.first), static_cast<deUint32>(p.second)}; });
215
216 constexpr size_t stride = sizeof(decltype(intermediate)::value_type);
217 const size_t totalSize = stride * intermediate.size();
218
219 // Get and copy.
220 result = vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, totalSize, intermediate.data(), stride, flags);
221 std::transform(begin(intermediate), end(intermediate), begin(output), [](const Pair32& p) { return Pair64{p.first, p.second}; });
222 }
223
224 return result;
225 }
226
227 // Get query pool results as a vector. Note results are always converted to
228 // deUint64, but the actual vkCmdCopyQueryPoolResults call will use the 64-bits flag
229 // or not depending on your preferences.
cmdCopyQueryPoolResultsVector(ResultsVector & output,const DeviceInterface & vk,vk::VkDevice device,const vk::Allocation & allocation,deUint32 queryCount,VkQueryResultFlags flags,deBool dstOffset)230 void cmdCopyQueryPoolResultsVector(
231 ResultsVector& output, const DeviceInterface& vk, vk::VkDevice device, const vk::Allocation& allocation, deUint32 queryCount, VkQueryResultFlags flags, deBool dstOffset)
232 {
233 if (flags & vk::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)
234 TCU_THROW(InternalError, "Availability flag passed when expecting results as ResultsVector");
235
236 output.resize(queryCount);
237
238 void* allocationData = allocation.getHostPtr();
239 vk::invalidateAlloc(vk, device, allocation);
240
241 if (flags & vk::VK_QUERY_RESULT_64_BIT)
242 {
243 constexpr size_t stride = sizeof(ResultsVector::value_type);
244 const size_t totalSize = stride * output.size();
245 const deUint32 offset = dstOffset ? 1u : 0u;
246 deMemcpy(output.data(), (reinterpret_cast<ResultsVector::value_type*>(allocationData) + offset), totalSize);
247 }
248 else
249 {
250 using IntermediateVector = vector<deUint32>;
251
252 IntermediateVector intermediate(queryCount);
253
254 // Try to preserve existing data if possible.
255 std::transform(begin(output), end(output), begin(intermediate), [](deUint64 v) { return static_cast<deUint32>(v); });
256
257 constexpr size_t stride = sizeof(decltype(intermediate)::value_type);
258 const size_t totalSize = stride * intermediate.size();
259 const deUint32 offset = dstOffset ? 1u : 0u;
260 // Get and copy results.
261 deMemcpy(intermediate.data(), (reinterpret_cast<decltype(intermediate)::value_type*>(allocationData) + offset), totalSize);
262 std::copy(begin(intermediate), end(intermediate), begin(output));
263 }
264 }
265
266 // Same as the normal cmdCopyQueryPoolResultsVector but returning the availability
267 // bit associated to each query in addition to the query value.
cmdCopyQueryPoolResultsVector(ResultsVectorWithAvailability & output,const DeviceInterface & vk,vk::VkDevice device,const vk::Allocation & allocation,deUint32 queryCount,VkQueryResultFlags flags,deBool dstOffset)268 void cmdCopyQueryPoolResultsVector(
269 ResultsVectorWithAvailability& output, const DeviceInterface& vk, vk::VkDevice device, const vk::Allocation& allocation, deUint32 queryCount, VkQueryResultFlags flags, deBool dstOffset)
270 {
271 flags |= vk::VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
272
273 output.resize(queryCount);
274
275 void* allocationData = allocation.getHostPtr();
276 vk::invalidateAlloc(vk, device, allocation);
277
278 if (flags & vk::VK_QUERY_RESULT_64_BIT)
279 {
280 constexpr size_t stride = sizeof(ResultsVectorWithAvailability::value_type);
281 const size_t totalSize = stride * output.size();
282 const deUint32 offset = dstOffset ? 1u : 0u;
283 deMemcpy(output.data(), (reinterpret_cast<ResultsVectorWithAvailability::value_type*>(allocationData) + offset), totalSize);
284 }
285 else
286 {
287 using IntermediateVector = vector<Pair32>;
288
289 IntermediateVector intermediate(queryCount);
290
291 // Try to preserve existing output data if possible.
292 std::transform(begin(output), end(output), begin(intermediate), [](const Pair64& p) { return Pair32{static_cast<deUint32>(p.first), static_cast<deUint32>(p.second)}; });
293
294 constexpr size_t stride = sizeof(decltype(intermediate)::value_type);
295 const size_t totalSize = stride * intermediate.size();
296 const deUint32 offset = dstOffset ? 1u : 0u;
297
298 // Get and copy.
299 deMemcpy(intermediate.data(), (reinterpret_cast<decltype(intermediate)::value_type*>(allocationData) + offset), totalSize);
300 std::transform(begin(intermediate), end(intermediate), begin(output), [](const Pair32& p) { return Pair64{p.first, p.second}; });
301 }
302 }
303
304 // Generic parameters structure.
305 struct GenericParameters
306 {
307 ResetType resetType;
308 CopyType copyType;
309 deBool query64Bits;
310 deBool dstOffset;
311 StrideType strideType;
312
GenericParametersvkt::QueryPool::__anon17cda4650111::GenericParameters313 GenericParameters (ResetType resetType_, CopyType copyType_, deBool query64Bits_, deBool dstOffset_, StrideType strideType_)
314 : resetType{resetType_}, copyType{copyType_}, query64Bits{query64Bits_}, dstOffset{dstOffset_}, strideType{strideType_}
315 {}
316
querySizeFlagsvkt::QueryPool::__anon17cda4650111::GenericParameters317 VkQueryResultFlags querySizeFlags () const
318 {
319 return (query64Bits ? static_cast<VkQueryResultFlags>(vk::VK_QUERY_RESULT_64_BIT) : 0u);
320 }
321 };
322
beginSecondaryCommandBuffer(const DeviceInterface & vk,const VkCommandBuffer commandBuffer,const VkQueryPipelineStatisticFlags queryFlags,const VkRenderPass renderPass=(VkRenderPass)0u,const VkFramebuffer framebuffer=(VkFramebuffer)0u,const VkCommandBufferUsageFlags bufferUsageFlags=VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)323 void beginSecondaryCommandBuffer (const DeviceInterface& vk,
324 const VkCommandBuffer commandBuffer,
325 const VkQueryPipelineStatisticFlags queryFlags,
326 const VkRenderPass renderPass = (VkRenderPass)0u,
327 const VkFramebuffer framebuffer = (VkFramebuffer)0u,
328 const VkCommandBufferUsageFlags bufferUsageFlags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
329 {
330 const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
331 {
332 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
333 DE_NULL,
334 renderPass, // renderPass
335 0u, // subpass
336 framebuffer, // framebuffer
337 VK_FALSE, // occlusionQueryEnable
338 (VkQueryControlFlags)0u, // queryFlags
339 queryFlags, // pipelineStatistics
340 };
341
342 const VkCommandBufferBeginInfo info =
343 {
344 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
345 DE_NULL, // const void* pNext;
346 bufferUsageFlags, // VkCommandBufferUsageFlags flags;
347 &secCmdBufInheritInfo, // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
348 };
349 VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
350 }
351
makeQueryPool(const DeviceInterface & vk,const VkDevice device,deUint32 queryCount,VkQueryPipelineStatisticFlags statisticFlags)352 Move<VkQueryPool> makeQueryPool (const DeviceInterface& vk, const VkDevice device, deUint32 queryCount, VkQueryPipelineStatisticFlags statisticFlags )
353 {
354 const VkQueryPoolCreateInfo queryPoolCreateInfo =
355 {
356 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType
357 DE_NULL, // const void* pNext
358 (VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags
359 VK_QUERY_TYPE_PIPELINE_STATISTICS , // VkQueryType queryType
360 queryCount, // deUint32 entryCount
361 statisticFlags, // VkQueryPipelineStatisticFlags pipelineStatistics
362 };
363 return createQueryPool(vk, device, &queryPoolCreateInfo);
364 }
365
calculatePearsonCorrelation(const std::vector<deUint64> & x,const ResultsVector & y)366 double calculatePearsonCorrelation(const std::vector<deUint64>& x, const ResultsVector& y)
367 {
368 // This function calculates Pearson correlation coefficient ( https://en.wikipedia.org/wiki/Pearson_correlation_coefficient )
369 // Two statistical variables are linear ( == fully corellated ) when fabs( Pearson corelation coefficient ) == 1
370 // Two statistical variables are independent when pearson corelation coefficient == 0
371 // If fabs( Pearson coefficient ) is > 0.8 then these two variables are almost linear
372
373 DE_ASSERT(x.size() == y.size());
374 DE_ASSERT(x.size() > 1);
375
376 // calculate mean values
377 double xMean = 0.0, yMean = 0.0;
378 for (deUint32 i = 0; i < x.size(); ++i)
379 {
380 xMean += static_cast<double>(x[i]);
381 yMean += static_cast<double>(y[i]);
382 }
383 xMean /= static_cast<double>(x.size());
384 yMean /= static_cast<double>(x.size());
385
386 // calculate standard deviations
387 double xS = 0.0, yS = 0.0;
388 for (deUint32 i = 0; i < x.size(); ++i)
389 {
390 double xv = static_cast<double>(x[i]) - xMean;
391 double yv = static_cast<double>(y[i]) - yMean;
392
393 xS += xv * xv;
394 yS += yv * yv;
395 }
396 xS = sqrt( xS / static_cast<double>(x.size() - 1) );
397 yS = sqrt( yS / static_cast<double>(x.size() - 1) );
398
399 // calculate Pearson coefficient
400 double pearson = 0.0;
401 for (deUint32 i = 0; i < x.size(); ++i)
402 {
403 double xv = (static_cast<double>(x[i]) - xMean ) / xS;
404 double yv = (static_cast<double>(y[i]) - yMean ) / yS;
405 pearson += xv * yv;
406 }
407
408 return pearson / static_cast<double>(x.size() - 1);
409 }
410
calculatePearsonCorrelation(const std::vector<deUint64> & x,const ResultsVectorWithAvailability & ya)411 double calculatePearsonCorrelation(const std::vector<deUint64>& x, const ResultsVectorWithAvailability& ya)
412 {
413 ResultsVector y;
414 for (const auto& elt : ya)
415 y.push_back(elt.first);
416 return calculatePearsonCorrelation(x, y);
417 }
418
clearBuffer(const DeviceInterface & vk,const VkDevice device,const de::SharedPtr<Buffer> buffer,const VkDeviceSize bufferSizeBytes)419 void clearBuffer (const DeviceInterface& vk, const VkDevice device, const de::SharedPtr<Buffer> buffer, const VkDeviceSize bufferSizeBytes)
420 {
421 const std::vector<deUint8> data ((size_t)bufferSizeBytes, 0u);
422 const Allocation& allocation = buffer->getBoundMemory();
423 void* allocationData = allocation.getHostPtr();
424 invalidateAlloc(vk, device, allocation);
425 deMemcpy(allocationData, &data[0], (size_t)bufferSizeBytes);
426 flushAlloc(vk, device, allocation);
427 }
428
429 class StatisticQueryTestInstance : public TestInstance
430 {
431 public:
432 StatisticQueryTestInstance (Context& context, deUint32 queryCount, deBool dstOffset);
433
434 protected:
435 struct ValueAndAvailability
436 {
437 deUint64 value;
438 deUint64 availability;
439 };
440
441 VkDeviceSize m_resetBufferSize;
442 de::SharedPtr<Buffer> m_resetBuffer;
443 deBool dstOffset;
444
445 virtual void checkExtensions (deBool hostResetQueryEnabled);
446 tcu::TestStatus verifyUnavailable ();
447 };
448
StatisticQueryTestInstance(Context & context,deUint32 queryCount,deBool dstOffset_)449 StatisticQueryTestInstance::StatisticQueryTestInstance (Context& context, deUint32 queryCount, deBool dstOffset_)
450 : TestInstance (context)
451 , m_resetBufferSize((queryCount + (dstOffset_ ? 1u : 0u)) * sizeof(ValueAndAvailability))
452 , m_resetBuffer (Buffer::createAndAlloc(context.getDeviceInterface(),
453 context.getDevice(),
454 BufferCreateInfo(m_resetBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT),
455 context.getDefaultAllocator(),
456 vk::MemoryRequirement::HostVisible))
457 , dstOffset (dstOffset_)
458 {
459 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
460 void* allocationData = allocation.getHostPtr();
461 deMemset(allocationData, 0xff, static_cast<size_t>(m_resetBufferSize));
462 flushAlloc(context.getDeviceInterface(), context.getDevice(), allocation);
463 }
464
checkExtensions(deBool hostResetQueryEnabled)465 void StatisticQueryTestInstance::checkExtensions (deBool hostResetQueryEnabled)
466 {
467 if (!m_context.getDeviceFeatures().pipelineStatisticsQuery)
468 throw tcu::NotSupportedError("Pipeline statistics queries are not supported");
469
470 if (hostResetQueryEnabled == DE_TRUE)
471 {
472 // Check VK_EXT_host_query_reset is supported
473 m_context.requireDeviceFunctionality("VK_EXT_host_query_reset");
474 if(m_context.getHostQueryResetFeatures().hostQueryReset == VK_FALSE)
475 throw tcu::NotSupportedError(std::string("Implementation doesn't support resetting queries from the host").c_str());
476 }
477 }
478
verifyUnavailable()479 tcu::TestStatus StatisticQueryTestInstance::verifyUnavailable ()
480 {
481 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
482 const void* allocationData = allocation.getHostPtr();
483 deUint32 size = dstOffset ? 2 : 1;
484 std::vector<ValueAndAvailability> va;
485 va.resize(size);
486
487 vk::invalidateAlloc(m_context.getDeviceInterface(), m_context.getDevice(), allocation);
488 deMemcpy(va.data(), allocationData, size * sizeof(ValueAndAvailability));
489
490 deBool failed = false;
491 for (deUint32 idx = 0u; idx < size; idx++)
492 {
493 if (dstOffset && idx == 0)
494 {
495 // Check that the contents between 0 and dstOffset were not overwritten.
496 failed |= va[idx].availability != 0xfffffffffffffffful || va[idx].value != 0xfffffffffffffffful;
497 continue;
498 }
499
500 failed |= va[idx].availability != 0;
501 }
502
503 return failed ? tcu::TestStatus::fail("Availability bit nonzero after resetting query or dstOffset wrong values") : tcu::TestStatus::pass("Pass");
504 }
505
506 class ComputeInvocationsTestInstance : public StatisticQueryTestInstance
507 {
508 public:
509 struct ParametersCompute : public GenericParameters
510 {
ParametersComputevkt::QueryPool::__anon17cda4650111::ComputeInvocationsTestInstance::ParametersCompute511 ParametersCompute (const tcu::UVec3& localSize_, const tcu::UVec3& groupSize_, const std::string& shaderName_, ResetType resetType_, CopyType copyType_, deBool query64Bits_, bool dstOffset_, StrideType strideType_)
512 : GenericParameters{resetType_, copyType_, query64Bits_, dstOffset_, strideType_}
513 , localSize(localSize_)
514 , groupSize(groupSize_)
515 , shaderName(shaderName_)
516 {}
517
518 tcu::UVec3 localSize;
519 tcu::UVec3 groupSize;
520 std::string shaderName;
521 };
522 ComputeInvocationsTestInstance (Context& context, const std::vector<ParametersCompute>& parameters);
523 tcu::TestStatus iterate (void);
524 protected:
525 virtual tcu::TestStatus executeTest (const VkCommandPool& cmdPool,
526 const VkPipelineLayout pipelineLayout,
527 const VkDescriptorSet& descriptorSet,
528 const de::SharedPtr<Buffer> buffer,
529 const VkDeviceSize bufferSizeBytes);
getComputeExecution(const ParametersCompute & parm) const530 deUint32 getComputeExecution (const ParametersCompute& parm) const
531 {
532 return parm.localSize.x() * parm.localSize.y() *parm.localSize.z() * parm.groupSize.x() * parm.groupSize.y() * parm.groupSize.z();
533 }
534 const std::vector<ParametersCompute>& m_parameters;
535 };
536
ComputeInvocationsTestInstance(Context & context,const std::vector<ParametersCompute> & parameters)537 ComputeInvocationsTestInstance::ComputeInvocationsTestInstance (Context& context, const std::vector<ParametersCompute>& parameters)
538 : StatisticQueryTestInstance (context, 1u, parameters[0].dstOffset)
539 , m_parameters (parameters)
540 {
541 }
542
iterate(void)543 tcu::TestStatus ComputeInvocationsTestInstance::iterate (void)
544 {
545 checkExtensions((m_parameters[0].resetType == RESET_TYPE_HOST)? DE_TRUE : DE_FALSE);
546 const DeviceInterface& vk = m_context.getDeviceInterface();
547 const VkDevice device = m_context.getDevice();
548 deUint32 maxSize = 0u;
549
550 for(size_t parametersNdx = 0; parametersNdx < m_parameters.size(); ++parametersNdx)
551 maxSize = deMaxu32(maxSize, getComputeExecution(m_parameters[parametersNdx]));
552
553 const VkDeviceSize bufferSizeBytes = static_cast<VkDeviceSize>(deAlignSize(static_cast<size_t>(sizeof(deUint32) * maxSize),
554 static_cast<size_t>(m_context.getDeviceProperties().limits.nonCoherentAtomSize)));
555 de::SharedPtr<Buffer> buffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(bufferSizeBytes, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT),
556 m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
557
558 const Unique<VkDescriptorSetLayout> descriptorSetLayout (DescriptorSetLayoutBuilder()
559 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)
560 .build(vk, device));
561
562 const Unique<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout));
563
564 const Unique<VkDescriptorPool> descriptorPool (DescriptorPoolBuilder()
565 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
566 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
567
568 const VkDescriptorSetAllocateInfo allocateParams =
569 {
570 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
571 DE_NULL, // const void* pNext;
572 *descriptorPool, // VkDescriptorPool descriptorPool;
573 1u, // deUint32 setLayoutCount;
574 &(*descriptorSetLayout), // const VkDescriptorSetLayout* pSetLayouts;
575 };
576
577 const Unique<VkDescriptorSet> descriptorSet (allocateDescriptorSet(vk, device, &allocateParams));
578 const VkDescriptorBufferInfo descriptorInfo =
579 {
580 buffer->object(), //VkBuffer buffer;
581 0ull, //VkDeviceSize offset;
582 bufferSizeBytes, //VkDeviceSize range;
583 };
584
585 DescriptorSetUpdateBuilder()
586 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorInfo)
587 .update(vk, device);
588
589 const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex());
590 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, &cmdPoolCreateInfo));
591
592 return executeTest (*cmdPool, *pipelineLayout, *descriptorSet, buffer, bufferSizeBytes);
593 }
594
executeTest(const VkCommandPool & cmdPool,const VkPipelineLayout pipelineLayout,const VkDescriptorSet & descriptorSet,const de::SharedPtr<Buffer> buffer,const VkDeviceSize bufferSizeBytes)595 tcu::TestStatus ComputeInvocationsTestInstance::executeTest (const VkCommandPool& cmdPool,
596 const VkPipelineLayout pipelineLayout,
597 const VkDescriptorSet& descriptorSet,
598 const de::SharedPtr<Buffer> buffer,
599 const VkDeviceSize bufferSizeBytes)
600 {
601 const DeviceInterface& vk = m_context.getDeviceInterface();
602 const VkDevice device = m_context.getDevice();
603 const VkQueue queue = m_context.getUniversalQueue();
604 const VkBufferMemoryBarrier computeFinishBarrier =
605 {
606 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
607 DE_NULL, // const void* pNext;
608 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags srcAccessMask;
609 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
610 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
611 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
612 buffer->object(), // VkBuffer buffer;
613 0ull, // VkDeviceSize offset;
614 bufferSizeBytes, // VkDeviceSize size;
615 };
616
617 for(size_t parametersNdx = 0u; parametersNdx < m_parameters.size(); ++parametersNdx)
618 {
619 clearBuffer(vk, device, buffer, bufferSizeBytes);
620 const Unique<VkShaderModule> shaderModule (createShaderModule(vk, device,
621 m_context.getBinaryCollection().get(m_parameters[parametersNdx].shaderName), (VkShaderModuleCreateFlags)0u));
622
623 const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
624 {
625 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
626 DE_NULL, // const void* pNext;
627 (VkPipelineShaderStageCreateFlags)0u, // VkPipelineShaderStageCreateFlags flags;
628 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
629 *shaderModule, // VkShaderModule module;
630 "main", // const char* pName;
631 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
632 };
633
634 const VkComputePipelineCreateInfo pipelineCreateInfo =
635 {
636 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
637 DE_NULL, // const void* pNext;
638 (VkPipelineCreateFlags)0u, // VkPipelineCreateFlags flags;
639 pipelineShaderStageParams, // VkPipelineShaderStageCreateInfo stage;
640 pipelineLayout, // VkPipelineLayout layout;
641 DE_NULL, // VkPipeline basePipelineHandle;
642 0, // deInt32 basePipelineIndex;
643 };
644 const Unique<VkPipeline> pipeline(createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo));
645
646 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
647 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, 1u, VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT));
648
649 beginCommandBuffer(vk, *cmdBuffer);
650 if (m_parameters[0].resetType != RESET_TYPE_HOST)
651 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, 1u);
652
653 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
654 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
655
656 vk.cmdBeginQuery(*cmdBuffer, *queryPool, 0u, (VkQueryControlFlags)0u);
657 vk.cmdDispatch(*cmdBuffer, m_parameters[parametersNdx].groupSize.x(), m_parameters[parametersNdx].groupSize.y(), m_parameters[parametersNdx].groupSize.z());
658 vk.cmdEndQuery(*cmdBuffer, *queryPool, 0u);
659
660 if (m_parameters[0].resetType == RESET_TYPE_BEFORE_COPY || m_parameters[0].resetType == RESET_TYPE_AFTER_COPY || m_parameters[0].copyType == COPY_TYPE_CMD)
661 {
662 VkDeviceSize stride = m_parameters[0].querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
663 vk::VkQueryResultFlags flags = m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
664
665 if (m_parameters[0].resetType == RESET_TYPE_HOST)
666 {
667 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
668 stride *= 2u;
669 }
670
671 if (m_parameters[0].resetType == RESET_TYPE_BEFORE_COPY)
672 {
673 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, 1u);
674 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
675 stride = sizeof(ValueAndAvailability);
676 }
677
678 VkDeviceSize dstOffsetQuery = (m_parameters[0].dstOffset) ? stride : 0;
679 VkDeviceSize copyStride = stride;
680
681 if (m_parameters[0].strideType == STRIDE_TYPE_ZERO)
682 copyStride = 0u;
683
684 vk.cmdCopyQueryPoolResults(*cmdBuffer, *queryPool, 0, 1u, m_resetBuffer->object(), dstOffsetQuery, copyStride, flags);
685
686 if (m_parameters[0].resetType == RESET_TYPE_AFTER_COPY)
687 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, 1u);
688
689 const VkBufferMemoryBarrier barrier =
690 {
691 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
692 DE_NULL, // const void* pNext;
693 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
694 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
695 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
696 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
697 m_resetBuffer->object(), // VkBuffer buffer;
698 0u, // VkDeviceSize offset;
699 1u * stride + dstOffsetQuery, // VkDeviceSize size;
700 };
701 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
702 }
703
704 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
705 (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &computeFinishBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
706
707 endCommandBuffer(vk, *cmdBuffer);
708
709 m_context.getTestContext().getLog() << tcu::TestLog::Message << "Compute shader invocations: " << getComputeExecution(m_parameters[parametersNdx]) << tcu::TestLog::EndMessage;
710
711 if (m_parameters[0].resetType == RESET_TYPE_HOST)
712 vk.resetQueryPool(device, *queryPool, 0u, 1u);
713
714 // Wait for completion
715 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
716
717 // Validate the results
718 const Allocation& bufferAllocation = buffer->getBoundMemory();
719 invalidateAlloc(vk, device, bufferAllocation);
720
721 if (m_parameters[0].resetType == RESET_TYPE_NORMAL || m_parameters[0].resetType == RESET_TYPE_AFTER_COPY)
722 {
723 ResultsVector data;
724
725 if (m_parameters[0].copyType == COPY_TYPE_CMD)
726 {
727 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
728 cmdCopyQueryPoolResultsVector(data, vk, device, allocation, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags()), m_parameters[0].dstOffset);
729 }
730 else
731 {
732 VK_CHECK(GetQueryPoolResultsVector(data, vk, device, *queryPool, 0u, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags())));
733 }
734
735 if (getComputeExecution(m_parameters[parametersNdx]) != data[0])
736 return tcu::TestStatus::fail("QueryPoolResults incorrect");
737 }
738 else if (m_parameters[0].resetType == RESET_TYPE_HOST)
739 {
740 ResultsVectorWithAvailability data;
741
742 if (m_parameters[0].copyType == COPY_TYPE_CMD)
743 {
744 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
745 cmdCopyQueryPoolResultsVector(data, vk, device, allocation, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT), m_parameters[0].dstOffset);
746 }
747 else
748 {
749 VK_CHECK(GetQueryPoolResultsVector(data, vk, device, *queryPool, 0u, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)));
750 }
751
752 if (getComputeExecution(m_parameters[parametersNdx]) != data[0].first || data[0].second == 0)
753 return tcu::TestStatus::fail("QueryPoolResults incorrect");
754
755 deUint64 temp = data[0].first;
756
757 vk.resetQueryPool(device, *queryPool, 0, 1u);
758 vk::VkResult res = GetQueryPoolResultsVector(data, vk, device, *queryPool, 0u, 1u, (m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT));
759 /* From Vulkan spec:
760 *
761 * If VK_QUERY_RESULT_WAIT_BIT and VK_QUERY_RESULT_PARTIAL_BIT are both not set then no result values are written to pData
762 * for queries that are in the unavailable state at the time of the call, and vkGetQueryPoolResults returns VK_NOT_READY.
763 * However, availability state is still written to pData for those queries if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set.
764 */
765 if (res != vk::VK_NOT_READY || data[0].first != temp || data[0].second != 0u)
766 return tcu::TestStatus::fail("QueryPoolResults incorrect reset");
767 }
768 else
769 {
770 // With RESET_TYPE_BEFORE_COPY, we only need to verify the result after the copy include an availability bit set as zero.
771 return verifyUnavailable();
772 }
773
774 const deUint32* bufferPtr = static_cast<deUint32*>(bufferAllocation.getHostPtr());
775 for (deUint32 ndx = 0u; ndx < getComputeExecution(m_parameters[parametersNdx]); ++ndx)
776 {
777 if (bufferPtr[ndx] != ndx)
778 return tcu::TestStatus::fail("Compute shader didn't write data to the buffer");
779 }
780 }
781 return tcu::TestStatus::pass("Pass");
782 }
783
784 class ComputeInvocationsSecondaryTestInstance : public ComputeInvocationsTestInstance
785 {
786 public:
787 ComputeInvocationsSecondaryTestInstance (Context& context, const std::vector<ParametersCompute>& parameters);
788 protected:
789 tcu::TestStatus executeTest (const VkCommandPool& cmdPool,
790 const VkPipelineLayout pipelineLayout,
791 const VkDescriptorSet& descriptorSet,
792 const de::SharedPtr<Buffer> buffer,
793 const VkDeviceSize bufferSizeBytes);
794 virtual tcu::TestStatus checkResult (const de::SharedPtr<Buffer> buffer,
795 const VkQueryPool queryPool);
796 };
797
ComputeInvocationsSecondaryTestInstance(Context & context,const std::vector<ParametersCompute> & parameters)798 ComputeInvocationsSecondaryTestInstance::ComputeInvocationsSecondaryTestInstance (Context& context, const std::vector<ParametersCompute>& parameters)
799 : ComputeInvocationsTestInstance (context, parameters)
800 {
801 }
802
executeTest(const VkCommandPool & cmdPool,const VkPipelineLayout pipelineLayout,const VkDescriptorSet & descriptorSet,const de::SharedPtr<Buffer> buffer,const VkDeviceSize bufferSizeBytes)803 tcu::TestStatus ComputeInvocationsSecondaryTestInstance::executeTest (const VkCommandPool& cmdPool,
804 const VkPipelineLayout pipelineLayout,
805 const VkDescriptorSet& descriptorSet,
806 const de::SharedPtr<Buffer> buffer,
807 const VkDeviceSize bufferSizeBytes)
808 {
809 typedef de::SharedPtr<Unique<VkShaderModule> > VkShaderModuleSp;
810 typedef de::SharedPtr<Unique<VkPipeline> > VkPipelineSp;
811
812 const DeviceInterface& vk = m_context.getDeviceInterface();
813 const VkDevice device = m_context.getDevice();
814 const VkQueue queue = m_context.getUniversalQueue();
815
816 const VkBufferMemoryBarrier computeShaderWriteBarrier =
817 {
818 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
819 DE_NULL, // const void* pNext;
820 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags srcAccessMask;
821 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
822 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
823 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
824 buffer->object(), // VkBuffer buffer;
825 0ull, // VkDeviceSize offset;
826 bufferSizeBytes, // VkDeviceSize size;
827 };
828
829 const VkBufferMemoryBarrier computeFinishBarrier =
830 {
831 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
832 DE_NULL, // const void* pNext;
833 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags srcAccessMask;
834 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
835 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
836 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
837 buffer->object(), // VkBuffer buffer;
838 0ull, // VkDeviceSize offset;
839 bufferSizeBytes, // VkDeviceSize size;
840 };
841
842 std::vector<VkShaderModuleSp> shaderModule;
843 std::vector<VkPipelineSp> pipeline;
844 for(size_t parametersNdx = 0; parametersNdx < m_parameters.size(); ++parametersNdx)
845 {
846 shaderModule.push_back(VkShaderModuleSp(new Unique<VkShaderModule>(createShaderModule(vk, device, m_context.getBinaryCollection().get(m_parameters[parametersNdx].shaderName), (VkShaderModuleCreateFlags)0u))));
847 const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
848 {
849 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
850 DE_NULL, // const void* pNext;
851 0u, // VkPipelineShaderStageCreateFlags flags;
852 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
853 shaderModule.back().get()->get(), // VkShaderModule module;
854 "main", // const char* pName;
855 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
856 };
857
858 const VkComputePipelineCreateInfo pipelineCreateInfo =
859 {
860 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
861 DE_NULL, // const void* pNext;
862 0u, // VkPipelineCreateFlags flags;
863 pipelineShaderStageParams, // VkPipelineShaderStageCreateInfo stage;
864 pipelineLayout, // VkPipelineLayout layout;
865 DE_NULL, // VkPipeline basePipelineHandle;
866 0, // deInt32 basePipelineIndex;
867 };
868 pipeline.push_back(VkPipelineSp(new Unique<VkPipeline>(createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo))));
869 }
870
871 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
872 const Unique<VkCommandBuffer> secondaryCmdBuffer (allocateCommandBuffer(vk, device, cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY));
873
874 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, 1u, VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT));
875
876 clearBuffer(vk, device, buffer, bufferSizeBytes);
877 beginSecondaryCommandBuffer(vk, *secondaryCmdBuffer, VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT);
878 vk.cmdBindDescriptorSets(*secondaryCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
879 if (m_parameters[0].resetType != RESET_TYPE_HOST)
880 vk.cmdResetQueryPool(*secondaryCmdBuffer, *queryPool, 0u, 1u);
881 vk.cmdBeginQuery(*secondaryCmdBuffer, *queryPool, 0u, (VkQueryControlFlags)0u);
882 for(size_t parametersNdx = 0; parametersNdx < m_parameters.size(); ++parametersNdx)
883 {
884 vk.cmdBindPipeline(*secondaryCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline[parametersNdx].get()->get());
885 vk.cmdDispatch(*secondaryCmdBuffer, m_parameters[parametersNdx].groupSize.x(), m_parameters[parametersNdx].groupSize.y(), m_parameters[parametersNdx].groupSize.z());
886
887 vk.cmdPipelineBarrier(*secondaryCmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
888 (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &computeShaderWriteBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
889 }
890 vk.cmdEndQuery(*secondaryCmdBuffer, *queryPool, 0u);
891
892 if (m_parameters[0].resetType == RESET_TYPE_BEFORE_COPY || m_parameters[0].resetType == RESET_TYPE_AFTER_COPY || m_parameters[0].copyType == COPY_TYPE_CMD)
893 {
894 VkDeviceSize stride = m_parameters[0].querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
895 vk::VkQueryResultFlags flags = m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
896
897 if (m_parameters[0].resetType == RESET_TYPE_HOST)
898 {
899 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
900 stride *= 2u;
901 }
902
903 if (m_parameters[0].resetType == RESET_TYPE_BEFORE_COPY)
904 {
905 vk.cmdResetQueryPool(*secondaryCmdBuffer, *queryPool, 0u, 1u);
906 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
907 stride = sizeof(ValueAndAvailability);
908 }
909
910 VkDeviceSize dstOffsetQuery = (m_parameters[0].dstOffset) ? stride : 0;
911 VkDeviceSize copyStride = stride;
912 if (m_parameters[0].strideType == STRIDE_TYPE_ZERO)
913 copyStride = 0u;
914
915 vk.cmdCopyQueryPoolResults(*secondaryCmdBuffer, *queryPool, 0, 1u, m_resetBuffer->object(), dstOffsetQuery, copyStride, flags);
916
917 if (m_parameters[0].resetType == RESET_TYPE_AFTER_COPY)
918 vk.cmdResetQueryPool(*secondaryCmdBuffer, *queryPool, 0u, 1u);
919
920 const VkBufferMemoryBarrier barrier =
921 {
922 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
923 DE_NULL, // const void* pNext;
924 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
925 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
926 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
927 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
928 m_resetBuffer->object(), // VkBuffer buffer;
929 0u, // VkDeviceSize offset;
930 1u * stride + dstOffsetQuery, // VkDeviceSize size;
931 };
932 vk.cmdPipelineBarrier(*secondaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
933 }
934
935 endCommandBuffer(vk, *secondaryCmdBuffer);
936
937 beginCommandBuffer(vk, *primaryCmdBuffer);
938 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &secondaryCmdBuffer.get());
939
940 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
941 (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &computeFinishBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
942
943 endCommandBuffer(vk, *primaryCmdBuffer);
944
945 // Secondary buffer is emitted only once, so it is safe to reset the query pool here.
946 if (m_parameters[0].resetType == RESET_TYPE_HOST)
947 vk.resetQueryPool(device, *queryPool, 0u, 1u);
948
949 // Wait for completion
950 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
951 return checkResult(buffer, *queryPool);
952 }
953
checkResult(const de::SharedPtr<Buffer> buffer,const VkQueryPool queryPool)954 tcu::TestStatus ComputeInvocationsSecondaryTestInstance::checkResult (const de::SharedPtr<Buffer> buffer, const VkQueryPool queryPool)
955 {
956 const DeviceInterface& vk = m_context.getDeviceInterface();
957 const VkDevice device = m_context.getDevice();
958 {
959 deUint64 expected = 0u;
960 for(size_t parametersNdx = 0; parametersNdx < m_parameters.size(); ++parametersNdx)
961 expected += getComputeExecution(m_parameters[parametersNdx]);
962
963 if (m_parameters[0].resetType == RESET_TYPE_NORMAL || m_parameters[0].resetType == RESET_TYPE_AFTER_COPY)
964 {
965 ResultsVector results;
966 if (m_parameters[0].copyType == COPY_TYPE_CMD)
967 {
968 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
969 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags()), m_parameters[0].dstOffset);
970 }
971 else
972 {
973 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags())));
974 }
975
976 if (expected != results[0])
977 return tcu::TestStatus::fail("QueryPoolResults incorrect");
978 }
979 else if (m_parameters[0].resetType == RESET_TYPE_HOST)
980 {
981 ResultsVectorWithAvailability results;
982
983 if (m_parameters[0].copyType == COPY_TYPE_CMD)
984 {
985 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
986 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT), m_parameters[0].dstOffset);
987 }
988 else
989 {
990 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, 1u, (VK_QUERY_RESULT_WAIT_BIT | m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)));
991 }
992
993 if (expected != results[0].first || results[0].second == 0u)
994 return tcu::TestStatus::fail("QueryPoolResults incorrect");
995
996 deUint64 temp = results[0].first;
997
998 vk.resetQueryPool(device, queryPool, 0u, 1u);
999 vk::VkResult res = GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, 1u, (m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT));
1000 /* From Vulkan spec:
1001 *
1002 * If VK_QUERY_RESULT_WAIT_BIT and VK_QUERY_RESULT_PARTIAL_BIT are both not set then no result values are written to pData
1003 * for queries that are in the unavailable state at the time of the call, and vkGetQueryPoolResults returns VK_NOT_READY.
1004 * However, availability state is still written to pData for those queries if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set.
1005 */
1006 if (res != vk::VK_NOT_READY || results[0].first != temp || results[0].second != 0u)
1007 return tcu::TestStatus::fail("QueryPoolResults incorrect reset");
1008 }
1009 else
1010 {
1011 // With RESET_TYPE_BEFORE_COPY, we only need to verify the result after the copy include an availability bit set as zero.
1012 return verifyUnavailable();
1013 }
1014
1015 }
1016
1017 {
1018 // Validate the results
1019 const Allocation& bufferAllocation = buffer->getBoundMemory();
1020 invalidateAlloc(vk, device, bufferAllocation);
1021 const deUint32* bufferPtr = static_cast<deUint32*>(bufferAllocation.getHostPtr());
1022 deUint32 minSize = ~0u;
1023 for(size_t parametersNdx = 0; parametersNdx < m_parameters.size(); ++parametersNdx)
1024 minSize = deMinu32(minSize, getComputeExecution(m_parameters[parametersNdx]));
1025 for (deUint32 ndx = 0u; ndx < minSize; ++ndx)
1026 {
1027 if (bufferPtr[ndx] != ndx * m_parameters.size())
1028 return tcu::TestStatus::fail("Compute shader didn't write data to the buffer");
1029 }
1030 }
1031 return tcu::TestStatus::pass("Pass");
1032 }
1033
1034 class ComputeInvocationsSecondaryInheritedTestInstance : public ComputeInvocationsSecondaryTestInstance
1035 {
1036 public:
1037 ComputeInvocationsSecondaryInheritedTestInstance (Context& context, const std::vector<ParametersCompute>& parameters);
1038 protected:
1039 virtual void checkExtensions (deBool hostResetQueryEnabled);
1040
1041 tcu::TestStatus executeTest (const VkCommandPool& cmdPool,
1042 const VkPipelineLayout pipelineLayout,
1043 const VkDescriptorSet& descriptorSet,
1044 const de::SharedPtr<Buffer> buffer,
1045 const VkDeviceSize bufferSizeBytes);
1046 };
1047
ComputeInvocationsSecondaryInheritedTestInstance(Context & context,const std::vector<ParametersCompute> & parameters)1048 ComputeInvocationsSecondaryInheritedTestInstance::ComputeInvocationsSecondaryInheritedTestInstance (Context& context, const std::vector<ParametersCompute>& parameters)
1049 : ComputeInvocationsSecondaryTestInstance (context, parameters)
1050 {
1051 }
1052
checkExtensions(deBool hostResetQueryEnabled)1053 void ComputeInvocationsSecondaryInheritedTestInstance::checkExtensions (deBool hostResetQueryEnabled)
1054 {
1055 StatisticQueryTestInstance::checkExtensions(hostResetQueryEnabled);
1056 if (!m_context.getDeviceFeatures().inheritedQueries)
1057 throw tcu::NotSupportedError("Inherited queries are not supported");
1058 }
1059
executeTest(const VkCommandPool & cmdPool,const VkPipelineLayout pipelineLayout,const VkDescriptorSet & descriptorSet,const de::SharedPtr<Buffer> buffer,const VkDeviceSize bufferSizeBytes)1060 tcu::TestStatus ComputeInvocationsSecondaryInheritedTestInstance::executeTest (const VkCommandPool& cmdPool,
1061 const VkPipelineLayout pipelineLayout,
1062 const VkDescriptorSet& descriptorSet,
1063 const de::SharedPtr<Buffer> buffer,
1064 const VkDeviceSize bufferSizeBytes)
1065 {
1066 typedef de::SharedPtr<Unique<VkShaderModule> > VkShaderModuleSp;
1067 typedef de::SharedPtr<Unique<VkPipeline> > VkPipelineSp;
1068
1069 const DeviceInterface& vk = m_context.getDeviceInterface();
1070 const VkDevice device = m_context.getDevice();
1071 const VkQueue queue = m_context.getUniversalQueue();
1072
1073 const VkBufferMemoryBarrier computeShaderWriteBarrier =
1074 {
1075 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1076 DE_NULL, // const void* pNext;
1077 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1078 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
1079 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1080 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1081 buffer->object(), // VkBuffer buffer;
1082 0ull, // VkDeviceSize offset;
1083 bufferSizeBytes, // VkDeviceSize size;
1084 };
1085
1086 const VkBufferMemoryBarrier computeFinishBarrier =
1087 {
1088 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1089 DE_NULL, // const void* pNext;
1090 VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1091 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1092 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1093 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1094 buffer->object(), // VkBuffer buffer;
1095 0ull, // VkDeviceSize offset;
1096 bufferSizeBytes, // VkDeviceSize size;
1097 };
1098
1099 std::vector<VkShaderModuleSp> shaderModule;
1100 std::vector<VkPipelineSp> pipeline;
1101 for(size_t parametersNdx = 0u; parametersNdx < m_parameters.size(); ++parametersNdx)
1102 {
1103 shaderModule.push_back(VkShaderModuleSp(new Unique<VkShaderModule>(createShaderModule(vk, device, m_context.getBinaryCollection().get(m_parameters[parametersNdx].shaderName), (VkShaderModuleCreateFlags)0u))));
1104 const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
1105 {
1106 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
1107 DE_NULL, // const void* pNext;
1108 0u, // VkPipelineShaderStageCreateFlags flags;
1109 VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
1110 shaderModule.back().get()->get(), // VkShaderModule module;
1111 "main", // const char* pName;
1112 DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
1113 };
1114
1115 const VkComputePipelineCreateInfo pipelineCreateInfo =
1116 {
1117 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
1118 DE_NULL, // const void* pNext;
1119 0u, // VkPipelineCreateFlags flags;
1120 pipelineShaderStageParams, // VkPipelineShaderStageCreateInfo stage;
1121 pipelineLayout, // VkPipelineLayout layout;
1122 DE_NULL, // VkPipeline basePipelineHandle;
1123 0, // deInt32 basePipelineIndex;
1124 };
1125 pipeline.push_back(VkPipelineSp(new Unique<VkPipeline>(createComputePipeline(vk, device, DE_NULL , &pipelineCreateInfo))));
1126 }
1127
1128 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1129 const Unique<VkCommandBuffer> secondaryCmdBuffer (allocateCommandBuffer(vk, device, cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY));
1130
1131 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, 1u, VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT));
1132
1133 clearBuffer(vk, device, buffer, bufferSizeBytes);
1134 beginSecondaryCommandBuffer(vk, *secondaryCmdBuffer, VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT);
1135 vk.cmdBindDescriptorSets(*secondaryCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
1136 for(size_t parametersNdx = 1; parametersNdx < m_parameters.size(); ++parametersNdx)
1137 {
1138 vk.cmdBindPipeline(*secondaryCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline[parametersNdx].get()->get());
1139 vk.cmdDispatch(*secondaryCmdBuffer, m_parameters[parametersNdx].groupSize.x(), m_parameters[parametersNdx].groupSize.y(), m_parameters[parametersNdx].groupSize.z());
1140
1141 vk.cmdPipelineBarrier(*secondaryCmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
1142 (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &computeShaderWriteBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
1143 }
1144 endCommandBuffer(vk, *secondaryCmdBuffer);
1145
1146 beginCommandBuffer(vk, *primaryCmdBuffer);
1147 if (m_parameters[0].resetType != RESET_TYPE_HOST)
1148 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, 1u);
1149 vk.cmdBindDescriptorSets(*primaryCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
1150 vk.cmdBindPipeline(*primaryCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline[0].get()->get());
1151
1152 vk.cmdBeginQuery(*primaryCmdBuffer, *queryPool, 0u, (VkQueryControlFlags)0u);
1153 vk.cmdDispatch(*primaryCmdBuffer, m_parameters[0].groupSize.x(), m_parameters[0].groupSize.y(), m_parameters[0].groupSize.z());
1154
1155 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
1156 (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &computeShaderWriteBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
1157
1158 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &secondaryCmdBuffer.get());
1159
1160 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
1161 (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &computeFinishBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
1162
1163 vk.cmdEndQuery(*primaryCmdBuffer, *queryPool, 0u);
1164
1165 if (m_parameters[0].resetType == RESET_TYPE_BEFORE_COPY || m_parameters[0].resetType == RESET_TYPE_AFTER_COPY || m_parameters[0].copyType == COPY_TYPE_CMD)
1166 {
1167 VkDeviceSize stride = m_parameters[0].querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
1168 vk::VkQueryResultFlags flags = m_parameters[0].querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
1169
1170 if (m_parameters[0].resetType == RESET_TYPE_HOST)
1171 {
1172 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
1173 stride *= 2u;
1174 }
1175
1176 if (m_parameters[0].resetType == RESET_TYPE_BEFORE_COPY)
1177 {
1178 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, 1u);
1179 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
1180 stride = sizeof(ValueAndAvailability);
1181 }
1182
1183 VkDeviceSize dstOffsetQuery = (m_parameters[0].dstOffset) ? stride : 0;
1184 VkDeviceSize copyStride = stride;
1185 if (m_parameters[0].strideType == STRIDE_TYPE_ZERO)
1186 copyStride = 0u;
1187
1188 vk.cmdCopyQueryPoolResults(*primaryCmdBuffer, *queryPool, 0, 1u, m_resetBuffer->object(), dstOffsetQuery, copyStride, flags);
1189
1190 if (m_parameters[0].resetType == RESET_TYPE_AFTER_COPY)
1191 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, 1u);
1192
1193 const VkBufferMemoryBarrier barrier =
1194 {
1195 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1196 DE_NULL, // const void* pNext;
1197 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1198 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1199 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1200 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1201 m_resetBuffer->object(), // VkBuffer buffer;
1202 0u, // VkDeviceSize offset;
1203 1u * stride + dstOffsetQuery, // VkDeviceSize size;
1204 };
1205 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1206 }
1207
1208 endCommandBuffer(vk, *primaryCmdBuffer);
1209
1210 if (m_parameters[0].resetType == RESET_TYPE_HOST)
1211 vk.resetQueryPool(device, *queryPool, 0u, 1u);
1212
1213 // Wait for completion
1214 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
1215 return checkResult(buffer, *queryPool);
1216 }
1217
1218 class GraphicBasicTestInstance : public StatisticQueryTestInstance
1219 {
1220 public:
1221 struct VertexData
1222 {
VertexDatavkt::QueryPool::__anon17cda4650111::GraphicBasicTestInstance::VertexData1223 VertexData (const tcu::Vec4 position_, const tcu::Vec4 color_)
1224 : position (position_)
1225 , color (color_)
1226 {}
1227 tcu::Vec4 position;
1228 tcu::Vec4 color;
1229 };
1230
1231 struct ParametersGraphic : public GenericParameters
1232 {
ParametersGraphicvkt::QueryPool::__anon17cda4650111::GraphicBasicTestInstance::ParametersGraphic1233 ParametersGraphic (const VkQueryPipelineStatisticFlags queryStatisticFlags_, const VkPrimitiveTopology primitiveTopology_, const ResetType resetType_, const CopyType copyType_, const deBool query64Bits_, const deBool vertexOnlyPipe_ = DE_FALSE, const deBool dstOffset_ = DE_FALSE, const ClearOperation clearOp_ = CLEAR_NOOP, const deBool noColorAttachments_ = DE_FALSE, const StrideType strideType_ = STRIDE_TYPE_VALID)
1234 : GenericParameters {resetType_, copyType_, query64Bits_, dstOffset_, strideType_}
1235 , queryStatisticFlags (queryStatisticFlags_)
1236 , primitiveTopology (primitiveTopology_)
1237 , vertexOnlyPipe (vertexOnlyPipe_)
1238 , clearOp (clearOp_)
1239 , noColorAttachments (noColorAttachments_)
1240 {}
1241
1242 VkQueryPipelineStatisticFlags queryStatisticFlags;
1243 VkPrimitiveTopology primitiveTopology;
1244 deBool vertexOnlyPipe;
1245 ClearOperation clearOp;
1246 deBool noColorAttachments;
1247 };
1248 GraphicBasicTestInstance (vkt::Context& context,
1249 const std::vector<VertexData>& data,
1250 const ParametersGraphic& parametersGraphic,
1251 const std::vector<deUint64>& drawRepeats );
1252 tcu::TestStatus iterate (void);
1253 protected:
1254 de::SharedPtr<Buffer> creatAndFillVertexBuffer (void);
1255 virtual void createPipeline (void) = 0;
1256 void commandClearAttachment (const vk::DeviceInterface& vk,
1257 const vk::VkCommandBuffer commandBuffer);
1258 void creatColorAttachmentAndRenderPass (void);
1259 bool checkImage (void);
1260 virtual tcu::TestStatus executeTest (void) = 0;
1261 virtual tcu::TestStatus checkResult (VkQueryPool queryPool) = 0;
1262 virtual void draw (VkCommandBuffer cmdBuffer) = 0;
1263
1264 const VkFormat m_colorAttachmentFormat;
1265 de::SharedPtr<Image> m_colorAttachmentImage;
1266 de::SharedPtr<Image> m_depthImage;
1267 Move<VkImageView> m_attachmentView;
1268 Move<VkImageView> m_depthView;
1269 Move<VkRenderPass> m_renderPass;
1270 Move<VkFramebuffer> m_framebuffer;
1271 Move<VkPipeline> m_pipeline;
1272 Move<VkPipelineLayout> m_pipelineLayout;
1273 const std::vector<VertexData>& m_data;
1274 const ParametersGraphic& m_parametersGraphic;
1275 std::vector<deUint64> m_drawRepeats;
1276 };
1277
GraphicBasicTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)1278 GraphicBasicTestInstance::GraphicBasicTestInstance (vkt::Context& context,
1279 const std::vector<VertexData>& data,
1280 const ParametersGraphic& parametersGraphic,
1281 const std::vector<deUint64>& drawRepeats )
1282 : StatisticQueryTestInstance (context, static_cast<deUint32>(drawRepeats.size()), parametersGraphic.dstOffset)
1283 , m_colorAttachmentFormat (VK_FORMAT_R8G8B8A8_UNORM)
1284 , m_data (data)
1285 , m_parametersGraphic (parametersGraphic)
1286 , m_drawRepeats (drawRepeats)
1287 {
1288 }
1289
iterate(void)1290 tcu::TestStatus GraphicBasicTestInstance::iterate (void)
1291 {
1292 checkExtensions((m_parametersGraphic.resetType == RESET_TYPE_HOST)? DE_TRUE : DE_FALSE);
1293 creatColorAttachmentAndRenderPass();
1294 createPipeline();
1295 return executeTest();
1296 }
1297
creatAndFillVertexBuffer(void)1298 de::SharedPtr<Buffer> GraphicBasicTestInstance::creatAndFillVertexBuffer (void)
1299 {
1300 const DeviceInterface& vk = m_context.getDeviceInterface();
1301 const VkDevice device = m_context.getDevice();
1302
1303 const VkDeviceSize dataSize = static_cast<VkDeviceSize>(deAlignSize(static_cast<size_t>( m_data.size() * sizeof(VertexData)),
1304 static_cast<size_t>(m_context.getDeviceProperties().limits.nonCoherentAtomSize)));
1305
1306 de::SharedPtr<Buffer> vertexBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize,
1307 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
1308
1309 deUint8* ptr = reinterpret_cast<deUint8*>(vertexBuffer->getBoundMemory().getHostPtr());
1310 deMemcpy(ptr, &m_data[0], static_cast<size_t>( m_data.size() * sizeof(VertexData)));
1311
1312 flushMappedMemoryRange(vk, device, vertexBuffer->getBoundMemory().getMemory(), vertexBuffer->getBoundMemory().getOffset(), dataSize);
1313 return vertexBuffer;
1314 }
1315
commandClearAttachment(const vk::DeviceInterface & vk,const vk::VkCommandBuffer commandBuffer)1316 void GraphicBasicTestInstance::commandClearAttachment (const vk::DeviceInterface& vk,
1317 const vk::VkCommandBuffer commandBuffer)
1318 {
1319 const vk::VkOffset2D offset = vk::makeOffset2D(0, 0);
1320 const vk::VkExtent2D extent = vk::makeExtent2D(WIDTH, HEIGHT);
1321
1322 const vk::VkClearAttachment attachment =
1323 {
1324 m_parametersGraphic.clearOp == CLEAR_COLOR ? vk::VK_IMAGE_ASPECT_COLOR_BIT : vk::VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
1325 m_parametersGraphic.clearOp == CLEAR_COLOR ? 0u : 1u, // uint32_t colorAttachment;
1326 m_parametersGraphic.clearOp == CLEAR_COLOR ? vk::makeClearValueColor(tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)) :
1327 vk::makeClearValueDepthStencil(0.0f, 0u) // VkClearValue clearValue;
1328 };
1329
1330 const vk::VkClearRect rect =
1331 {
1332 { offset, extent }, // VkRect2D rect;
1333 0u, // uint32_t baseArrayLayer;
1334 1u, // uint32_t layerCount;
1335 };
1336
1337 vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
1338 }
1339
creatColorAttachmentAndRenderPass(void)1340 void GraphicBasicTestInstance::creatColorAttachmentAndRenderPass (void)
1341 {
1342 const DeviceInterface& vk = m_context.getDeviceInterface();
1343 const VkDevice device = m_context.getDevice();
1344
1345 VkExtent3D imageExtent =
1346 {
1347 WIDTH, // width;
1348 HEIGHT, // height;
1349 1u // depth;
1350 };
1351
1352 if (!m_parametersGraphic.noColorAttachments)
1353 {
1354
1355 const ImageCreateInfo colorImageCreateInfo (VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL,
1356 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
1357
1358 m_colorAttachmentImage = Image::createAndAlloc(vk, device, colorImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
1359
1360 const ImageViewCreateInfo attachmentViewInfo (m_colorAttachmentImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat);
1361 m_attachmentView = createImageView(vk, device, &attachmentViewInfo);
1362 }
1363
1364
1365 ImageCreateInfo depthImageCreateInfo (vk::VK_IMAGE_TYPE_2D, VK_FORMAT_D16_UNORM, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
1366 vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
1367 m_depthImage = Image::createAndAlloc(vk, device, depthImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
1368
1369 // Construct a depth view from depth image
1370 const ImageViewCreateInfo depthViewInfo (m_depthImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_D16_UNORM);
1371 m_depthView = vk::createImageView(vk, device, &depthViewInfo);
1372
1373 // Renderpass and Framebuffer
1374 if (m_parametersGraphic.noColorAttachments)
1375 {
1376 RenderPassCreateInfo renderPassCreateInfo;
1377
1378 renderPassCreateInfo.addAttachment(AttachmentDescription(VK_FORMAT_D16_UNORM, // format
1379 vk::VK_SAMPLE_COUNT_1_BIT, // samples
1380 vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
1381 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
1382 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
1383 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
1384 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // initialLauout
1385 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); // finalLayout
1386
1387 const VkAttachmentReference depthAttachmentReference =
1388 {
1389 0u, // attachment
1390 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // layout
1391 };
1392
1393 renderPassCreateInfo.addSubpass(SubpassDescription(vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
1394 0, // flags
1395 0, // inputCount
1396 DE_NULL, // pInputAttachments
1397 0, // colorCount
1398 DE_NULL, // pColorAttachments
1399 DE_NULL, // pResolveAttachments
1400 depthAttachmentReference, // depthStencilAttachment
1401 0, // preserveCount
1402 DE_NULL)); // preserveAttachments
1403 m_renderPass = vk::createRenderPass(vk, device, &renderPassCreateInfo);
1404
1405 std::vector<vk::VkImageView> attachments(1);
1406 attachments[0] = *m_depthView;
1407
1408 FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, WIDTH, HEIGHT, 1);
1409 m_framebuffer = vk::createFramebuffer(vk, device, &framebufferCreateInfo);
1410 }
1411 else
1412 {
1413 RenderPassCreateInfo renderPassCreateInfo;
1414 renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat, // format
1415 VK_SAMPLE_COUNT_1_BIT, // samples
1416 VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
1417 VK_ATTACHMENT_STORE_OP_STORE , // storeOp
1418 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
1419 VK_ATTACHMENT_STORE_OP_STORE , // stencilLoadOp
1420 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // initialLauout
1421 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)); // finalLayout
1422
1423 renderPassCreateInfo.addAttachment(AttachmentDescription(VK_FORMAT_D16_UNORM, // format
1424 vk::VK_SAMPLE_COUNT_1_BIT, // samples
1425 vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
1426 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
1427 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
1428 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
1429 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // initialLauout
1430 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); // finalLayout
1431
1432 const VkAttachmentReference colorAttachmentReference =
1433 {
1434 0u, // attachment
1435 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // layout
1436 };
1437
1438 const VkAttachmentReference depthAttachmentReference =
1439 {
1440 1u, // attachment
1441 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // layout
1442 };
1443
1444 const VkSubpassDescription subpass =
1445 {
1446 (VkSubpassDescriptionFlags) 0, //VkSubpassDescriptionFlags flags;
1447 VK_PIPELINE_BIND_POINT_GRAPHICS, //VkPipelineBindPoint pipelineBindPoint;
1448 0u, //deUint32 inputAttachmentCount;
1449 DE_NULL, //const VkAttachmentReference* pInputAttachments;
1450 1u, //deUint32 colorAttachmentCount;
1451 &colorAttachmentReference, //const VkAttachmentReference* pColorAttachments;
1452 DE_NULL, //const VkAttachmentReference* pResolveAttachments;
1453 &depthAttachmentReference, //const VkAttachmentReference* pDepthStencilAttachment;
1454 0u, //deUint32 preserveAttachmentCount;
1455 DE_NULL, //const deUint32* pPreserveAttachments;
1456 };
1457
1458 renderPassCreateInfo.addSubpass(subpass);
1459 m_renderPass = createRenderPass(vk, device, &renderPassCreateInfo);
1460
1461 std::vector<vk::VkImageView> attachments(2);
1462 attachments[0] = *m_attachmentView;
1463 attachments[1] = *m_depthView;
1464
1465 FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, WIDTH, HEIGHT, 1);
1466 m_framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
1467 }
1468 }
1469
checkImage(void)1470 bool GraphicBasicTestInstance::checkImage (void)
1471 {
1472 if (m_parametersGraphic.vertexOnlyPipe)
1473 return true;
1474
1475 const VkQueue queue = m_context.getUniversalQueue();
1476 const VkOffset3D zeroOffset = { 0, 0, 0 };
1477 const tcu::ConstPixelBufferAccess renderedFrame = m_colorAttachmentImage->readSurface(queue, m_context.getDefaultAllocator(),
1478 VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, VK_IMAGE_ASPECT_COLOR_BIT);
1479 int colorNdx = 0;
1480 tcu::Texture2D referenceFrame (mapVkFormat(m_colorAttachmentFormat), WIDTH, HEIGHT);
1481 referenceFrame.allocLevel(0);
1482
1483 for (int y = 0; y < HEIGHT/2; ++y)
1484 for (int x = 0; x < WIDTH/2; ++x)
1485 referenceFrame.getLevel(0).setPixel(m_data[colorNdx].color, x, y);
1486
1487 colorNdx += 4;
1488 for (int y = HEIGHT/2; y < HEIGHT; ++y)
1489 for (int x = 0; x < WIDTH/2; ++x)
1490 referenceFrame.getLevel(0).setPixel(m_data[colorNdx].color, x, y);
1491
1492 colorNdx += 4;
1493 for (int y = 0; y < HEIGHT/2; ++y)
1494 for (int x = WIDTH/2; x < WIDTH; ++x)
1495 referenceFrame.getLevel(0).setPixel(m_data[colorNdx].color, x, y);
1496
1497 colorNdx += 4;
1498 for (int y = HEIGHT/2; y < HEIGHT; ++y)
1499 for (int x = WIDTH/2; x < WIDTH; ++x)
1500 referenceFrame.getLevel(0).setPixel(m_data[colorNdx].color, x, y);
1501
1502 return tcu::floatThresholdCompare(m_context.getTestContext().getLog(), "Result", "Image comparison result", referenceFrame.getLevel(0), renderedFrame, tcu::Vec4(0.01f), tcu::COMPARE_LOG_ON_ERROR);
1503 }
1504
1505 class VertexShaderTestInstance : public GraphicBasicTestInstance
1506 {
1507 public:
1508 VertexShaderTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
1509 protected:
1510 virtual void createPipeline (void);
1511 virtual tcu::TestStatus executeTest (void);
1512 virtual tcu::TestStatus checkResult (VkQueryPool queryPool);
1513 void draw (VkCommandBuffer cmdBuffer);
1514 };
1515
VertexShaderTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)1516 VertexShaderTestInstance::VertexShaderTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
1517 : GraphicBasicTestInstance (context, data, parametersGraphic, drawRepeats )
1518 {
1519 }
1520
createPipeline(void)1521 void VertexShaderTestInstance::createPipeline (void)
1522 {
1523 const DeviceInterface& vk = m_context.getDeviceInterface();
1524 const VkDevice device = m_context.getDevice();
1525
1526 switch (m_parametersGraphic.primitiveTopology)
1527 {
1528 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
1529 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
1530 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
1531 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
1532 if (!m_context.getDeviceFeatures().geometryShader)
1533 throw tcu::NotSupportedError("Geometry shader are not supported");
1534 break;
1535 default:
1536 break;
1537 }
1538
1539 // Pipeline
1540 Unique<VkShaderModule> vs(createShaderModule(vk, device, m_context.getBinaryCollection().get("vertex"), 0));
1541 Move<VkShaderModule> fs;
1542
1543 if (!m_parametersGraphic.vertexOnlyPipe)
1544 fs = createShaderModule(vk, device, m_context.getBinaryCollection().get("fragment"), 0);
1545
1546 const PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
1547
1548 const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
1549 m_pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
1550
1551 const VkVertexInputBindingDescription vertexInputBindingDescription =
1552 {
1553 0, // binding;
1554 static_cast<deUint32>(sizeof(VertexData)), // stride;
1555 VK_VERTEX_INPUT_RATE_VERTEX // inputRate
1556 };
1557
1558 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
1559 {
1560 {
1561 0u,
1562 0u,
1563 VK_FORMAT_R32G32B32A32_SFLOAT,
1564 0u
1565 }, // VertexElementData::position
1566 {
1567 1u,
1568 0u,
1569 VK_FORMAT_R32G32B32A32_SFLOAT,
1570 static_cast<deUint32>(sizeof(tcu::Vec4))
1571 }, // VertexElementData::color
1572 };
1573
1574 const VkPipelineVertexInputStateCreateInfo vf_info =
1575 { // sType;
1576 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext;
1577 NULL, // flags;
1578 0u, // vertexBindingDescriptionCount;
1579 1u, // pVertexBindingDescriptions;
1580 &vertexInputBindingDescription, // vertexAttributeDescriptionCount;
1581 2u, // pVertexAttributeDescriptions;
1582 vertexInputAttributeDescriptions
1583 };
1584
1585 PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, (VkPipelineCreateFlags)0);
1586 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
1587 if (!m_parametersGraphic.vertexOnlyPipe)
1588 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
1589 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
1590 pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(m_parametersGraphic.primitiveTopology));
1591 pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &attachmentState));
1592
1593 const VkViewport viewport = makeViewport(WIDTH, HEIGHT);
1594 const VkRect2D scissor = makeRect2D(WIDTH, HEIGHT);
1595 pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1u, std::vector<VkViewport>(1, viewport), std::vector<VkRect2D>(1, scissor)));
1596 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
1597 pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
1598 pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
1599 pipelineCreateInfo.addState(vf_info);
1600 m_pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
1601 }
1602
executeTest(void)1603 tcu::TestStatus VertexShaderTestInstance::executeTest (void)
1604 {
1605 const DeviceInterface& vk = m_context.getDeviceInterface();
1606 const VkDevice device = m_context.getDevice();
1607 const VkQueue queue = m_context.getUniversalQueue();
1608 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
1609
1610 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
1611 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
1612 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
1613 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
1614
1615 const VkDeviceSize vertexBufferOffset = 0u;
1616 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
1617 const VkBuffer vertexBuffer = vertexBufferSp->object();
1618
1619 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1620
1621 beginCommandBuffer(vk, *cmdBuffer);
1622 {
1623 std::vector<VkClearValue> renderPassClearValues (2);
1624 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
1625
1626 if (!m_parametersGraphic.noColorAttachments)
1627 initialTransitionColor2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1628 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
1629 initialTransitionDepth2DImage(vk, *cmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1630 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
1631
1632 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
1633 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
1634
1635 beginRenderPass(vk, *cmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0]);
1636
1637 for (deUint32 i = 0; i < queryCount; ++i)
1638 {
1639 vk.cmdBeginQuery(*cmdBuffer, *queryPool, i, (VkQueryControlFlags)0u);
1640 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
1641 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
1642
1643 for(deUint64 j=0; j<m_drawRepeats[i]; ++j)
1644 draw(*cmdBuffer);
1645
1646 commandClearAttachment(vk, *cmdBuffer);
1647 vk.cmdEndQuery(*cmdBuffer, *queryPool, i);
1648 }
1649
1650 endRenderPass(vk, *cmdBuffer);
1651
1652 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
1653 {
1654 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
1655 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
1656
1657 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
1658 {
1659 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
1660 stride *= 2u;
1661 }
1662
1663 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
1664 {
1665 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
1666 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
1667 stride = sizeof(ValueAndAvailability);
1668 }
1669
1670 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
1671 vk.cmdCopyQueryPoolResults(*cmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
1672
1673 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
1674 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
1675
1676 const VkBufferMemoryBarrier barrier =
1677 {
1678 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1679 DE_NULL, // const void* pNext;
1680 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1681 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1682 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1683 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1684 m_resetBuffer->object(), // VkBuffer buffer;
1685 0u, // VkDeviceSize offset;
1686 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
1687 };
1688 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1689 }
1690
1691 if (!m_parametersGraphic.noColorAttachments)
1692 transition2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
1693 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
1694 }
1695 endCommandBuffer(vk, *cmdBuffer);
1696
1697 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
1698 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
1699
1700 // Wait for completion
1701 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
1702 return checkResult (*queryPool);
1703 }
1704
checkResult(VkQueryPool queryPool)1705 tcu::TestStatus VertexShaderTestInstance::checkResult (VkQueryPool queryPool)
1706 {
1707 const DeviceInterface& vk = m_context.getDeviceInterface();
1708 const VkDevice device = m_context.getDevice();
1709 deUint64 expectedMin = 0u;
1710
1711 switch(m_parametersGraphic.queryStatisticFlags)
1712 {
1713 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT:
1714 expectedMin = 16u;
1715 break;
1716 case VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT:
1717 expectedMin = m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST ? 15u :
1718 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY ? 8u :
1719 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY ? 14u :
1720 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY ? 6u :
1721 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY ? 8u :
1722 16u;
1723 break;
1724 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT:
1725 expectedMin = m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST ? 16u :
1726 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ? 8u :
1727 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP ? 15u :
1728 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST ? 5u :
1729 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP ? 8u :
1730 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN ? 14u :
1731 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY ? 4u :
1732 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY ? 13u :
1733 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY ? 2u :
1734 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY ? 6u :
1735 0u;
1736 break;
1737 case VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT:
1738 expectedMin = m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST ? 9u :
1739 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ? 192u :
1740 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP ? 448u :
1741 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST ? 2016u :
1742 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP ? 4096u :
1743 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN ? 10208u :
1744 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY ? 128u :
1745 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY ? 416u :
1746 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY ? 992u :
1747 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY ? 3072u :
1748 0u;
1749 break;
1750 default:
1751 DE_FATAL("Unexpected type of statistics query");
1752 break;
1753 }
1754
1755 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
1756
1757 if (m_parametersGraphic.resetType == RESET_TYPE_NORMAL || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
1758 {
1759 ResultsVector results(queryCount, 0u);
1760
1761 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
1762 {
1763 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
1764 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags()), m_parametersGraphic.dstOffset);
1765 }
1766 else
1767 {
1768 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags())));
1769 }
1770
1771 if (results[0] < expectedMin)
1772 return tcu::TestStatus::fail("QueryPoolResults incorrect");
1773 if (queryCount > 1)
1774 {
1775 double pearson = calculatePearsonCorrelation(m_drawRepeats, results);
1776 if ( fabs( pearson ) < 0.8 )
1777 return tcu::TestStatus::fail("QueryPoolResults are nonlinear");
1778 }
1779 }
1780 else if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
1781 {
1782 ResultsVectorWithAvailability results(queryCount, pair<deUint64, deUint64>(0u,0u));
1783
1784 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
1785 {
1786 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
1787 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT), m_parametersGraphic.dstOffset);
1788 }
1789 else
1790 {
1791 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)));
1792 }
1793
1794 if (results[0].first < expectedMin || results[0].second == 0)
1795 return tcu::TestStatus::fail("QueryPoolResults incorrect");
1796
1797 if (queryCount > 1)
1798 {
1799 double pearson = calculatePearsonCorrelation(m_drawRepeats, results);
1800 if ( fabs( pearson ) < 0.8 )
1801 return tcu::TestStatus::fail("QueryPoolResults are nonlinear");
1802 }
1803
1804 deUint64 temp = results[0].first;
1805
1806 vk.resetQueryPool(device, queryPool, 0, queryCount);
1807 vk::VkResult res = GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT));
1808 /* From Vulkan spec:
1809 *
1810 * If VK_QUERY_RESULT_WAIT_BIT and VK_QUERY_RESULT_PARTIAL_BIT are both not set then no result values are written to pData
1811 * for queries that are in the unavailable state at the time of the call, and vkGetQueryPoolResults returns VK_NOT_READY.
1812 * However, availability state is still written to pData for those queries if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set.
1813 */
1814 if (res != vk::VK_NOT_READY || results[0].first != temp || results[0].second != 0)
1815 return tcu::TestStatus::fail("QueryPoolResults incorrect reset");
1816 }
1817 else
1818 {
1819 // With RESET_TYPE_BEFORE_COPY, we only need to verify the result after the copy include an availability bit set as zero.
1820 return verifyUnavailable();
1821 }
1822
1823 // Don't need to check the result image when clearing operations are executed.
1824 if (m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP && m_parametersGraphic.clearOp == CLEAR_NOOP && !m_parametersGraphic.noColorAttachments && !checkImage())
1825 return tcu::TestStatus::fail("Result image doesn't match expected image.");
1826
1827 return tcu::TestStatus::pass("Pass");
1828 }
1829
draw(VkCommandBuffer cmdBuffer)1830 void VertexShaderTestInstance::draw (VkCommandBuffer cmdBuffer)
1831 {
1832 const DeviceInterface& vk = m_context.getDeviceInterface();
1833 switch(m_parametersGraphic.primitiveTopology)
1834 {
1835 case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
1836 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
1837 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
1838 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
1839 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
1840 case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
1841 case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY:
1842 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
1843 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY:
1844 vk.cmdDraw(cmdBuffer, 16u, 1u, 0u, 0u);
1845 break;
1846 case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
1847 vk.cmdDraw(cmdBuffer, 4u, 1u, 0u, 0u);
1848 vk.cmdDraw(cmdBuffer, 4u, 1u, 4u, 1u);
1849 vk.cmdDraw(cmdBuffer, 4u, 1u, 8u, 2u);
1850 vk.cmdDraw(cmdBuffer, 4u, 1u, 12u, 3u);
1851 break;
1852 default:
1853 DE_ASSERT(0);
1854 break;
1855 }
1856 }
1857
1858 class VertexShaderSecondaryTestInstance : public VertexShaderTestInstance
1859 {
1860 public:
1861 VertexShaderSecondaryTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
1862 protected:
1863 virtual tcu::TestStatus executeTest (void);
1864 };
1865
VertexShaderSecondaryTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)1866 VertexShaderSecondaryTestInstance::VertexShaderSecondaryTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
1867 : VertexShaderTestInstance (context, data, parametersGraphic, drawRepeats)
1868 {
1869 }
1870
1871 typedef de::SharedPtr<vk::Unique<VkCommandBuffer>> VkCommandBufferSp;
1872
executeTest(void)1873 tcu::TestStatus VertexShaderSecondaryTestInstance::executeTest (void)
1874 {
1875 const DeviceInterface& vk = m_context.getDeviceInterface();
1876 const VkDevice device = m_context.getDevice();
1877 const VkQueue queue = m_context.getUniversalQueue();
1878 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
1879
1880 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
1881 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
1882 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
1883 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
1884
1885 const VkDeviceSize vertexBufferOffset = 0u;
1886 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
1887 const VkBuffer vertexBuffer = vertexBufferSp->object();
1888
1889 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
1890 std::vector<VkCommandBufferSp> secondaryCmdBuffers(queryCount);
1891
1892 for (deUint32 i = 0; i < queryCount; ++i)
1893 secondaryCmdBuffers[i] = VkCommandBufferSp(new vk::Unique<VkCommandBuffer>(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY)));
1894
1895 for (deUint32 i = 0; i < queryCount; ++i)
1896 {
1897 beginSecondaryCommandBuffer(vk, secondaryCmdBuffers[i]->get(), m_parametersGraphic.queryStatisticFlags, *m_renderPass, *m_framebuffer, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
1898 vk.cmdBeginQuery(secondaryCmdBuffers[i]->get(), *queryPool, i, (VkQueryControlFlags)0u);
1899 vk.cmdBindPipeline(secondaryCmdBuffers[i]->get(), VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
1900 vk.cmdBindVertexBuffers(secondaryCmdBuffers[i]->get(), 0u, 1u, &vertexBuffer, &vertexBufferOffset);
1901 for(deUint32 j=0; j<m_drawRepeats[i]; ++j)
1902 draw(secondaryCmdBuffers[i]->get());
1903 commandClearAttachment(vk, secondaryCmdBuffers[i]->get());
1904 vk.cmdEndQuery(secondaryCmdBuffers[i]->get(), *queryPool, i);
1905 endCommandBuffer(vk, secondaryCmdBuffers[i]->get());
1906 }
1907
1908 beginCommandBuffer(vk, *primaryCmdBuffer);
1909 {
1910 std::vector<VkClearValue> renderPassClearValues (2);
1911 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
1912
1913 if (!m_parametersGraphic.noColorAttachments)
1914 initialTransitionColor2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1915 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
1916
1917 initialTransitionDepth2DImage(vk, *primaryCmdBuffer, m_depthImage->object(), vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1918 vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
1919
1920 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
1921 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
1922
1923 beginRenderPass(vk, *primaryCmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0], VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
1924 for (deUint32 i = 0; i < queryCount; ++i)
1925 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &(secondaryCmdBuffers[i]->get()));
1926 endRenderPass(vk, *primaryCmdBuffer);
1927
1928 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
1929 {
1930 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
1931 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
1932
1933 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
1934 {
1935 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
1936 stride *= 2u;
1937 }
1938
1939 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
1940 {
1941 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
1942 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
1943 stride = sizeof(ValueAndAvailability);
1944 }
1945
1946 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
1947 vk.cmdCopyQueryPoolResults(*primaryCmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
1948
1949 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
1950 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
1951
1952 const VkBufferMemoryBarrier barrier =
1953 {
1954 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
1955 DE_NULL, // const void* pNext;
1956 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
1957 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
1958 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
1959 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
1960 m_resetBuffer->object(), // VkBuffer buffer;
1961 0u, // VkDeviceSize offset;
1962 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
1963 };
1964 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
1965 }
1966
1967 if (!m_parametersGraphic.noColorAttachments)
1968 transition2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
1969 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
1970 }
1971 endCommandBuffer(vk, *primaryCmdBuffer);
1972
1973 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
1974 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
1975
1976 // Wait for completion
1977 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
1978 return checkResult (*queryPool);
1979 }
1980
1981 class VertexShaderSecondaryInheritedTestInstance : public VertexShaderTestInstance
1982 {
1983 public:
1984 VertexShaderSecondaryInheritedTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
1985 protected:
1986 virtual void checkExtensions (deBool hostQueryResetEnabled);
1987 virtual tcu::TestStatus executeTest (void);
1988 };
1989
VertexShaderSecondaryInheritedTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)1990 VertexShaderSecondaryInheritedTestInstance::VertexShaderSecondaryInheritedTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
1991 : VertexShaderTestInstance (context, data, parametersGraphic, drawRepeats)
1992 {
1993 }
1994
checkExtensions(deBool hostQueryResetEnabled)1995 void VertexShaderSecondaryInheritedTestInstance::checkExtensions (deBool hostQueryResetEnabled)
1996 {
1997 StatisticQueryTestInstance::checkExtensions(hostQueryResetEnabled);
1998 if (!m_context.getDeviceFeatures().inheritedQueries)
1999 throw tcu::NotSupportedError("Inherited queries are not supported");
2000 }
2001
executeTest(void)2002 tcu::TestStatus VertexShaderSecondaryInheritedTestInstance::executeTest (void)
2003 {
2004 const DeviceInterface& vk = m_context.getDeviceInterface();
2005 const VkDevice device = m_context.getDevice();
2006 const VkQueue queue = m_context.getUniversalQueue();
2007 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
2008
2009 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
2010 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
2011 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
2012 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
2013
2014 const VkDeviceSize vertexBufferOffset = 0u;
2015 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
2016 const VkBuffer vertexBuffer = vertexBufferSp->object();
2017
2018 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
2019 std::vector<VkCommandBufferSp> secondaryCmdBuffers(queryCount);
2020
2021 for (deUint32 i = 0; i < queryCount; ++i)
2022 secondaryCmdBuffers[i] = VkCommandBufferSp(new vk::Unique<VkCommandBuffer>(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY)));
2023
2024 for (deUint32 i = 0; i < queryCount; ++i)
2025 {
2026 beginSecondaryCommandBuffer(vk, secondaryCmdBuffers[i]->get(), m_parametersGraphic.queryStatisticFlags, *m_renderPass, *m_framebuffer, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
2027 vk.cmdBindPipeline(secondaryCmdBuffers[i]->get(), VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
2028 vk.cmdBindVertexBuffers(secondaryCmdBuffers[i]->get(), 0u, 1u, &vertexBuffer, &vertexBufferOffset);
2029 for (deUint32 j = 0; j<m_drawRepeats[i]; ++j)
2030 draw(secondaryCmdBuffers[i]->get());
2031 endCommandBuffer(vk, secondaryCmdBuffers[i]->get());
2032 }
2033
2034 beginCommandBuffer(vk, *primaryCmdBuffer);
2035 {
2036 std::vector<VkClearValue> renderPassClearValues (2);
2037 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
2038
2039 if (!m_parametersGraphic.noColorAttachments)
2040 initialTransitionColor2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2041 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
2042 initialTransitionDepth2DImage(vk, *primaryCmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
2043 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
2044
2045 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
2046 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2047
2048 for (deUint32 i = 0; i < queryCount; ++i)
2049 {
2050 vk.cmdBeginQuery(*primaryCmdBuffer, *queryPool, i, (VkQueryControlFlags)0u);
2051 beginRenderPass(vk, *primaryCmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0], VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
2052 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &(secondaryCmdBuffers[i]->get()));
2053 endRenderPass(vk, *primaryCmdBuffer);
2054 vk.cmdEndQuery(*primaryCmdBuffer, *queryPool, i);
2055 }
2056
2057 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
2058 {
2059 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
2060 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
2061
2062 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2063 {
2064 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2065 stride *= 2u;
2066 }
2067
2068 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
2069 {
2070 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2071 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2072 stride = sizeof(ValueAndAvailability);
2073 }
2074
2075 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
2076 vk.cmdCopyQueryPoolResults(*primaryCmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
2077
2078 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
2079 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2080
2081 const VkBufferMemoryBarrier barrier =
2082 {
2083 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
2084 DE_NULL, // const void* pNext;
2085 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2086 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
2087 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2088 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
2089 m_resetBuffer->object(), // VkBuffer buffer;
2090 0u, // VkDeviceSize offset;
2091 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
2092 };
2093 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
2094 }
2095
2096 if (!m_parametersGraphic.noColorAttachments)
2097 transition2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
2098 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
2099 }
2100 endCommandBuffer(vk, *primaryCmdBuffer);
2101
2102 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2103 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
2104
2105 // Wait for completion
2106 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
2107 return checkResult (*queryPool);
2108 }
2109
2110 class GeometryShaderTestInstance : public GraphicBasicTestInstance
2111 {
2112 public:
2113 GeometryShaderTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
2114 protected:
2115 virtual void checkExtensions (deBool hostQueryResetEnabled);
2116 virtual void createPipeline (void);
2117 virtual tcu::TestStatus executeTest (void);
2118 tcu::TestStatus checkResult (VkQueryPool queryPool);
2119 void draw (VkCommandBuffer cmdBuffer);
2120 };
2121
GeometryShaderTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)2122 GeometryShaderTestInstance::GeometryShaderTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
2123 : GraphicBasicTestInstance(context, data, parametersGraphic, drawRepeats)
2124 {
2125 }
2126
checkExtensions(deBool hostQueryResetEnabled)2127 void GeometryShaderTestInstance::checkExtensions (deBool hostQueryResetEnabled)
2128 {
2129 StatisticQueryTestInstance::checkExtensions(hostQueryResetEnabled);
2130 if (!m_context.getDeviceFeatures().geometryShader)
2131 throw tcu::NotSupportedError("Geometry shader are not supported");
2132 }
2133
createPipeline(void)2134 void GeometryShaderTestInstance::createPipeline (void)
2135 {
2136 const DeviceInterface& vk = m_context.getDeviceInterface();
2137 const VkDevice device = m_context.getDevice();
2138 const VkBool32 useGeomPointSize = m_context.getDeviceFeatures().shaderTessellationAndGeometryPointSize && (m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST);
2139
2140 // Pipeline
2141 Unique<VkShaderModule> vs(createShaderModule(vk, device, m_context.getBinaryCollection().get("vertex"), (VkShaderModuleCreateFlags)0));
2142 Unique<VkShaderModule> gs(createShaderModule(vk, device, m_context.getBinaryCollection().get(useGeomPointSize ? "geometry_point_size" : "geometry"), (VkShaderModuleCreateFlags)0));
2143 Unique<VkShaderModule> fs(createShaderModule(vk, device, m_context.getBinaryCollection().get("fragment"), (VkShaderModuleCreateFlags)0));
2144
2145 const PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
2146
2147 const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
2148 m_pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
2149
2150 const VkVertexInputBindingDescription vertexInputBindingDescription =
2151 {
2152 0u, // binding;
2153 static_cast<deUint32>(sizeof(VertexData)), // stride;
2154 VK_VERTEX_INPUT_RATE_VERTEX // inputRate
2155 };
2156
2157 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
2158 {
2159 {
2160 0u,
2161 0u,
2162 VK_FORMAT_R32G32B32A32_SFLOAT,
2163 0u
2164 }, // VertexElementData::position
2165 {
2166 1u,
2167 0u,
2168 VK_FORMAT_R32G32B32A32_SFLOAT,
2169 static_cast<deUint32>(sizeof(tcu::Vec4))
2170 }, // VertexElementData::color
2171 };
2172
2173 const VkPipelineVertexInputStateCreateInfo vf_info =
2174 { // sType;
2175 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext;
2176 NULL, // flags;
2177 0u, // vertexBindingDescriptionCount;
2178 1, // pVertexBindingDescriptions;
2179 &vertexInputBindingDescription, // vertexAttributeDescriptionCount;
2180 2, // pVertexAttributeDescriptions;
2181 vertexInputAttributeDescriptions
2182 };
2183
2184 PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, (VkPipelineCreateFlags)0);
2185 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
2186 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*gs, "main", VK_SHADER_STAGE_GEOMETRY_BIT));
2187 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
2188 pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(m_parametersGraphic.primitiveTopology));
2189 pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &attachmentState));
2190
2191 const VkViewport viewport = makeViewport(WIDTH, HEIGHT);
2192 const VkRect2D scissor = makeRect2D(WIDTH, HEIGHT);
2193
2194 pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, std::vector<VkViewport>(1, viewport), std::vector<VkRect2D>(1, scissor)));
2195
2196 if (m_context.getDeviceFeatures().depthBounds)
2197 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState(true, true, VK_COMPARE_OP_GREATER_OR_EQUAL, true));
2198 else
2199 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
2200
2201 pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState(false));
2202 pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
2203 pipelineCreateInfo.addState(vf_info);
2204 m_pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
2205 }
2206
executeTest(void)2207 tcu::TestStatus GeometryShaderTestInstance::executeTest (void)
2208 {
2209 const DeviceInterface& vk = m_context.getDeviceInterface();
2210 const VkDevice device = m_context.getDevice();
2211 const VkQueue queue = m_context.getUniversalQueue();
2212 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
2213
2214 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
2215 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
2216 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
2217 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
2218
2219 const VkDeviceSize vertexBufferOffset = 0u;
2220 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
2221 const VkBuffer vertexBuffer = vertexBufferSp->object();
2222
2223 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
2224
2225 beginCommandBuffer(vk, *cmdBuffer);
2226 {
2227 std::vector<VkClearValue> renderPassClearValues (2);
2228 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
2229
2230 if (!m_parametersGraphic.noColorAttachments)
2231 initialTransitionColor2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2232 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
2233
2234 initialTransitionDepth2DImage(vk, *cmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
2235 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
2236
2237 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
2238 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
2239
2240 beginRenderPass(vk, *cmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0]);
2241
2242 for (deUint32 i = 0; i < queryCount; ++i)
2243 {
2244 vk.cmdBeginQuery(*cmdBuffer, *queryPool, i, (VkQueryControlFlags)0u);
2245 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
2246 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
2247
2248 for (deUint64 j = 0; j<m_drawRepeats[i]; ++j)
2249 draw(*cmdBuffer);
2250
2251 vk.cmdEndQuery(*cmdBuffer, *queryPool, i);
2252 }
2253
2254 endRenderPass(vk, *cmdBuffer);
2255
2256 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
2257 {
2258 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
2259 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
2260
2261 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2262 {
2263 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2264 stride *= 2u;
2265 }
2266
2267 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
2268 {
2269 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
2270 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2271 stride = sizeof(ValueAndAvailability);
2272 }
2273
2274 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
2275 vk.cmdCopyQueryPoolResults(*cmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
2276
2277 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
2278 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
2279
2280 const VkBufferMemoryBarrier barrier =
2281 {
2282 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
2283 DE_NULL, // const void* pNext;
2284 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2285 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
2286 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2287 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
2288 m_resetBuffer->object(), // VkBuffer buffer;
2289 0u, // VkDeviceSize offset;
2290 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
2291 };
2292 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
2293 }
2294
2295 if (!m_parametersGraphic.noColorAttachments)
2296 transition2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
2297 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
2298 }
2299 endCommandBuffer(vk, *cmdBuffer);
2300
2301 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2302 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
2303
2304 // Wait for completion
2305 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
2306 return checkResult(*queryPool);
2307 }
2308
checkResult(VkQueryPool queryPool)2309 tcu::TestStatus GeometryShaderTestInstance::checkResult (VkQueryPool queryPool)
2310 {
2311 const DeviceInterface& vk = m_context.getDeviceInterface();
2312 const VkDevice device = m_context.getDevice();
2313 deUint64 expectedMin = 0u;
2314
2315 switch(m_parametersGraphic.queryStatisticFlags)
2316 {
2317 case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT:
2318 expectedMin = m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST ? 16u :
2319 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ? 8u :
2320 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP ? 15u :
2321 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST ? 4u :
2322 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP ? 4u :
2323 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN ? 14u :
2324 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY ? 4u :
2325 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY ? 13u :
2326 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY ? 2u :
2327 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY ? 6u :
2328 0u;
2329 break;
2330 case VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT:
2331 case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT:
2332 case VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT:
2333 expectedMin = m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST ? 112u :
2334 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ? 32u :
2335 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP ? 60u :
2336 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST ? 8u :
2337 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP ? 8u :
2338 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN ? 28u :
2339 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY ? 16u :
2340 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY ? 52u :
2341 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY ? 4u :
2342 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY ? 12u :
2343 0u;
2344 break;
2345 default:
2346 DE_FATAL("Unexpected type of statistics query");
2347 break;
2348 }
2349
2350 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
2351
2352 if (m_parametersGraphic.resetType == RESET_TYPE_NORMAL || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
2353 {
2354 ResultsVector results(queryCount, 0u);
2355
2356 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
2357 {
2358 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
2359 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags()), m_parametersGraphic.dstOffset);
2360 }
2361 else
2362 {
2363 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags())));
2364 }
2365
2366 if (results[0] < expectedMin)
2367 return tcu::TestStatus::fail("QueryPoolResults incorrect");
2368 if (queryCount > 1)
2369 {
2370 double pearson = calculatePearsonCorrelation(m_drawRepeats, results);
2371 if ( fabs( pearson ) < 0.8 )
2372 return tcu::TestStatus::fail("QueryPoolResults are nonlinear");
2373 }
2374 }
2375 else if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2376 {
2377 ResultsVectorWithAvailability results(queryCount, pair<deUint64, deUint64>(0u, 0u));
2378 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
2379 {
2380 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
2381 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT), m_parametersGraphic.dstOffset);
2382 }
2383 else
2384 {
2385 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)));
2386 }
2387
2388 if (results[0].first < expectedMin || results[0].second == 0u)
2389 return tcu::TestStatus::fail("QueryPoolResults incorrect");
2390
2391 if (queryCount > 1)
2392 {
2393 double pearson = calculatePearsonCorrelation(m_drawRepeats, results);
2394 if ( fabs( pearson ) < 0.8 )
2395 return tcu::TestStatus::fail("QueryPoolResults are nonlinear");
2396 }
2397
2398 deUint64 temp = results[0].first;
2399
2400 vk.resetQueryPool(device, queryPool, 0, queryCount);
2401 vk::VkResult res = GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT));
2402 /* From Vulkan spec:
2403 *
2404 * If VK_QUERY_RESULT_WAIT_BIT and VK_QUERY_RESULT_PARTIAL_BIT are both not set then no result values are written to pData
2405 * for queries that are in the unavailable state at the time of the call, and vkGetQueryPoolResults returns VK_NOT_READY.
2406 * However, availability state is still written to pData for those queries if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set.
2407 */
2408 if (res != vk::VK_NOT_READY || results[0].first != temp || results[0].second != 0u)
2409 return tcu::TestStatus::fail("QueryPoolResults incorrect reset");
2410 }
2411 else
2412 {
2413 // With RESET_TYPE_BEFORE_COPY, we only need to verify the result after the copy include an availability bit set as zero.
2414 return verifyUnavailable();
2415 }
2416
2417 if ( (m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST || m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP ) && !checkImage())
2418 return tcu::TestStatus::fail("Result image doesn't match expected image.");
2419
2420 return tcu::TestStatus::pass("Pass");
2421 }
2422
draw(VkCommandBuffer cmdBuffer)2423 void GeometryShaderTestInstance::draw (VkCommandBuffer cmdBuffer)
2424 {
2425 const DeviceInterface& vk = m_context.getDeviceInterface();
2426 if (m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP ||
2427 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
2428 {
2429 vk.cmdDraw(cmdBuffer, 3u, 1u, 0u, 1u);
2430 vk.cmdDraw(cmdBuffer, 3u, 1u, 4u, 1u);
2431 vk.cmdDraw(cmdBuffer, 3u, 1u, 8u, 2u);
2432 vk.cmdDraw(cmdBuffer, 3u, 1u, 12u, 3u);
2433 }
2434 else
2435 {
2436 vk.cmdDraw(cmdBuffer, 16u, 1u, 0u, 0u);
2437 }
2438 }
2439
2440 class GeometryShaderSecondaryTestInstance : public GeometryShaderTestInstance
2441 {
2442 public:
2443 GeometryShaderSecondaryTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
2444 protected:
2445 virtual tcu::TestStatus executeTest (void);
2446 };
2447
GeometryShaderSecondaryTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)2448 GeometryShaderSecondaryTestInstance::GeometryShaderSecondaryTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
2449 : GeometryShaderTestInstance (context, data, parametersGraphic, drawRepeats)
2450 {
2451 }
2452
executeTest(void)2453 tcu::TestStatus GeometryShaderSecondaryTestInstance::executeTest (void)
2454 {
2455 const DeviceInterface& vk = m_context.getDeviceInterface();
2456 const VkDevice device = m_context.getDevice();
2457 const VkQueue queue = m_context.getUniversalQueue();
2458 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
2459
2460 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
2461 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
2462 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
2463 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
2464
2465 const VkDeviceSize vertexBufferOffset = 0;
2466 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
2467 const VkBuffer vertexBuffer = vertexBufferSp->object();
2468
2469 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
2470 std::vector<VkCommandBufferSp> secondaryCmdBuffers(queryCount);
2471
2472 for (deUint32 i = 0; i < queryCount; ++i)
2473 secondaryCmdBuffers[i] = VkCommandBufferSp(new vk::Unique<VkCommandBuffer>(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY)));
2474
2475 for (deUint32 i = 0; i < queryCount; ++i)
2476 {
2477 beginSecondaryCommandBuffer(vk, secondaryCmdBuffers[i]->get(), m_parametersGraphic.queryStatisticFlags, *m_renderPass, *m_framebuffer, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
2478 vk.cmdBeginQuery(secondaryCmdBuffers[i]->get(), *queryPool, i, (VkQueryControlFlags)0u);
2479 vk.cmdBindPipeline(secondaryCmdBuffers[i]->get(), VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
2480 vk.cmdBindVertexBuffers(secondaryCmdBuffers[i]->get(), 0u, 1u, &vertexBuffer, &vertexBufferOffset);
2481 for (deUint32 j = 0; j<m_drawRepeats[i]; ++j)
2482 draw(secondaryCmdBuffers[i]->get());
2483 vk.cmdEndQuery(secondaryCmdBuffers[i]->get(), *queryPool, i);
2484 endCommandBuffer(vk, secondaryCmdBuffers[i]->get());
2485 }
2486
2487 beginCommandBuffer(vk, *primaryCmdBuffer);
2488 {
2489 std::vector<VkClearValue> renderPassClearValues (2);
2490 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
2491
2492 if (!m_parametersGraphic.noColorAttachments)
2493 initialTransitionColor2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2494 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
2495
2496 initialTransitionDepth2DImage(vk, *primaryCmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
2497 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
2498
2499 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
2500 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2501 beginRenderPass(vk, *primaryCmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0], VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
2502 for (deUint32 i = 0; i < queryCount; ++i)
2503 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &(secondaryCmdBuffers[i]->get()));
2504 endRenderPass(vk, *primaryCmdBuffer);
2505
2506 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
2507 {
2508 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
2509 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
2510
2511 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2512 {
2513 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2514 stride *= 2u;
2515 }
2516
2517 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
2518 {
2519 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2520 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2521 stride = sizeof(ValueAndAvailability);
2522 }
2523
2524 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
2525 vk.cmdCopyQueryPoolResults(*primaryCmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
2526
2527 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
2528 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2529
2530 const VkBufferMemoryBarrier barrier =
2531 {
2532 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
2533 DE_NULL, // const void* pNext;
2534 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2535 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
2536 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2537 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
2538 m_resetBuffer->object(), // VkBuffer buffer;
2539 0u, // VkDeviceSize offset;
2540 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
2541 };
2542 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
2543 }
2544
2545 if (!m_parametersGraphic.noColorAttachments)
2546 transition2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
2547 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
2548 }
2549 endCommandBuffer(vk, *primaryCmdBuffer);
2550
2551 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2552 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
2553
2554 // Wait for completion
2555 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
2556 return checkResult(*queryPool);
2557 }
2558
2559 class GeometryShaderSecondaryInheritedTestInstance : public GeometryShaderTestInstance
2560 {
2561 public:
2562 GeometryShaderSecondaryInheritedTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
2563 protected:
2564 virtual void checkExtensions (deBool hostQueryResetEnabled);
2565 virtual tcu::TestStatus executeTest (void);
2566 };
2567
GeometryShaderSecondaryInheritedTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)2568 GeometryShaderSecondaryInheritedTestInstance::GeometryShaderSecondaryInheritedTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
2569 : GeometryShaderTestInstance (context, data, parametersGraphic, drawRepeats)
2570 {
2571 }
2572
checkExtensions(deBool hostQueryResetEnabled)2573 void GeometryShaderSecondaryInheritedTestInstance::checkExtensions (deBool hostQueryResetEnabled)
2574 {
2575 GeometryShaderTestInstance::checkExtensions(hostQueryResetEnabled);
2576 if (!m_context.getDeviceFeatures().inheritedQueries)
2577 throw tcu::NotSupportedError("Inherited queries are not supported");
2578 }
2579
executeTest(void)2580 tcu::TestStatus GeometryShaderSecondaryInheritedTestInstance::executeTest (void)
2581 {
2582 const DeviceInterface& vk = m_context.getDeviceInterface();
2583 const VkDevice device = m_context.getDevice();
2584 const VkQueue queue = m_context.getUniversalQueue();
2585 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
2586
2587 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
2588 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
2589 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
2590 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
2591
2592 const VkDeviceSize vertexBufferOffset = 0u;
2593 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
2594 const VkBuffer vertexBuffer = vertexBufferSp->object();
2595
2596 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
2597 std::vector<VkCommandBufferSp> secondaryCmdBuffers(queryCount);
2598
2599 for (deUint32 i = 0; i < queryCount; ++i)
2600 secondaryCmdBuffers[i] = VkCommandBufferSp(new vk::Unique<VkCommandBuffer>(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY)));
2601
2602 for (deUint32 i = 0; i < queryCount; ++i)
2603 {
2604 beginSecondaryCommandBuffer(vk, secondaryCmdBuffers[i]->get(), m_parametersGraphic.queryStatisticFlags, *m_renderPass, *m_framebuffer, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
2605 vk.cmdBindPipeline(secondaryCmdBuffers[i]->get(), VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
2606 vk.cmdBindVertexBuffers(secondaryCmdBuffers[i]->get(), 0u, 1u, &vertexBuffer, &vertexBufferOffset);
2607 for (deUint32 j = 0; j<m_drawRepeats[i]; ++j)
2608 draw(secondaryCmdBuffers[i]->get());
2609 endCommandBuffer(vk, secondaryCmdBuffers[i]->get());
2610 }
2611
2612 beginCommandBuffer(vk, *primaryCmdBuffer);
2613 {
2614 std::vector<VkClearValue> renderPassClearValues (2);
2615 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
2616
2617 if (!m_parametersGraphic.noColorAttachments)
2618 initialTransitionColor2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2619 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
2620
2621 initialTransitionDepth2DImage(vk, *primaryCmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
2622 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
2623
2624 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
2625 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2626
2627 for (deUint32 i = 0; i < queryCount; ++i)
2628 {
2629 vk.cmdBeginQuery(*primaryCmdBuffer, *queryPool, i, (VkQueryControlFlags)0u);
2630 beginRenderPass(vk, *primaryCmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0], VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
2631 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &(secondaryCmdBuffers[i]->get()));
2632 endRenderPass(vk, *primaryCmdBuffer);
2633 vk.cmdEndQuery(*primaryCmdBuffer, *queryPool, i);
2634 }
2635
2636 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
2637 {
2638 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
2639 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
2640
2641 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2642 {
2643 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2644 stride *= 2u;
2645 }
2646
2647 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
2648 {
2649 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2650 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2651 stride = sizeof(ValueAndAvailability);
2652 }
2653
2654 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
2655 vk.cmdCopyQueryPoolResults(*primaryCmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
2656
2657 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
2658 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
2659
2660 const VkBufferMemoryBarrier barrier =
2661 {
2662 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
2663 DE_NULL, // const void* pNext;
2664 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2665 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
2666 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2667 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
2668 m_resetBuffer->object(), // VkBuffer buffer;
2669 0u, // VkDeviceSize offset;
2670 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
2671 };
2672 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
2673 }
2674
2675 if (!m_parametersGraphic.noColorAttachments)
2676 transition2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
2677 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
2678 }
2679 endCommandBuffer(vk, *primaryCmdBuffer);
2680
2681 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2682 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
2683
2684 // Wait for completion
2685 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
2686 return checkResult(*queryPool);
2687 }
2688
2689 class TessellationShaderTestInstance : public GraphicBasicTestInstance
2690 {
2691 public:
2692 TessellationShaderTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
2693 protected:
2694 virtual void checkExtensions (deBool hostQueryResetEnabled);
2695 virtual void createPipeline (void);
2696 virtual tcu::TestStatus executeTest (void);
2697 virtual tcu::TestStatus checkResult (VkQueryPool queryPool);
2698 void draw (VkCommandBuffer cmdBuffer);
2699 };
2700
TessellationShaderTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)2701 TessellationShaderTestInstance::TessellationShaderTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
2702 : GraphicBasicTestInstance (context, data, parametersGraphic, drawRepeats)
2703 {
2704 }
2705
checkExtensions(deBool hostQueryResetEnabled)2706 void TessellationShaderTestInstance::checkExtensions (deBool hostQueryResetEnabled)
2707 {
2708 StatisticQueryTestInstance::checkExtensions(hostQueryResetEnabled);
2709 if (!m_context.getDeviceFeatures().tessellationShader)
2710 throw tcu::NotSupportedError("Tessellation shader are not supported");
2711 }
2712
2713
createPipeline(void)2714 void TessellationShaderTestInstance::createPipeline (void)
2715 {
2716 const DeviceInterface& vk = m_context.getDeviceInterface();
2717 const VkDevice device = m_context.getDevice();
2718
2719 // Pipeline
2720 Unique<VkShaderModule> vs(createShaderModule(vk, device, m_context.getBinaryCollection().get("vertex"), (VkShaderModuleCreateFlags)0));
2721 Unique<VkShaderModule> tc(createShaderModule(vk, device, m_context.getBinaryCollection().get("tessellation_control"), (VkShaderModuleCreateFlags)0));
2722 Unique<VkShaderModule> te(createShaderModule(vk, device, m_context.getBinaryCollection().get("tessellation_evaluation"), (VkShaderModuleCreateFlags)0));
2723 Unique<VkShaderModule> fs(createShaderModule(vk, device, m_context.getBinaryCollection().get("fragment"), (VkShaderModuleCreateFlags)0));
2724
2725 const PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
2726
2727 const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
2728 m_pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
2729
2730 const VkVertexInputBindingDescription vertexInputBindingDescription =
2731 {
2732 0u, // binding;
2733 static_cast<deUint32>(sizeof(VertexData)), // stride;
2734 VK_VERTEX_INPUT_RATE_VERTEX // inputRate
2735 };
2736
2737 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
2738 {
2739 {
2740 0u,
2741 0u,
2742 VK_FORMAT_R32G32B32A32_SFLOAT,
2743 0u
2744 }, // VertexElementData::position
2745 {
2746 1u,
2747 0u,
2748 VK_FORMAT_R32G32B32A32_SFLOAT,
2749 static_cast<deUint32>(sizeof(tcu::Vec4))
2750 }, // VertexElementData::color
2751 };
2752
2753 const VkPipelineVertexInputStateCreateInfo vf_info =
2754 { // sType;
2755 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext;
2756 NULL, // flags;
2757 0u, // vertexBindingDescriptionCount;
2758 1u, // pVertexBindingDescriptions;
2759 &vertexInputBindingDescription, // vertexAttributeDescriptionCount;
2760 2u, // pVertexAttributeDescriptions;
2761 vertexInputAttributeDescriptions
2762 };
2763
2764 PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, (VkPipelineCreateFlags)0);
2765 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
2766 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*tc, "main", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT));
2767 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*te, "main", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT));
2768 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
2769 pipelineCreateInfo.addState (PipelineCreateInfo::TessellationState(4));
2770 pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(VK_PRIMITIVE_TOPOLOGY_PATCH_LIST));
2771 pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &attachmentState));
2772
2773 const VkViewport viewport = makeViewport(WIDTH, HEIGHT);
2774 const VkRect2D scissor = makeRect2D(WIDTH, HEIGHT);
2775
2776 pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, std::vector<VkViewport>(1, viewport), std::vector<VkRect2D>(1, scissor)));
2777 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
2778 pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
2779 pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
2780 pipelineCreateInfo.addState(vf_info);
2781 m_pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
2782 }
2783
executeTest(void)2784 tcu::TestStatus TessellationShaderTestInstance::executeTest (void)
2785 {
2786 const DeviceInterface& vk = m_context.getDeviceInterface();
2787 const VkDevice device = m_context.getDevice();
2788 const VkQueue queue = m_context.getUniversalQueue();
2789 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
2790
2791 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
2792 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
2793 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
2794 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
2795
2796 const VkDeviceSize vertexBufferOffset = 0u;
2797 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
2798 const VkBuffer vertexBuffer = vertexBufferSp->object();
2799
2800 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
2801
2802 beginCommandBuffer(vk, *cmdBuffer);
2803 {
2804 std::vector<VkClearValue> renderPassClearValues (2);
2805 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
2806
2807 if (!m_parametersGraphic.noColorAttachments)
2808 initialTransitionColor2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2809 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
2810
2811 initialTransitionDepth2DImage(vk, *cmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
2812 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
2813
2814 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
2815 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
2816
2817 beginRenderPass(vk, *cmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0]);
2818
2819 for (deUint32 i = 0; i < queryCount; ++i)
2820 {
2821 vk.cmdBeginQuery(*cmdBuffer, *queryPool, i, (VkQueryControlFlags)0u);
2822 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
2823 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
2824
2825 for (deUint64 j = 0; j<m_drawRepeats[i]; ++j)
2826 draw(*cmdBuffer);
2827
2828 vk.cmdEndQuery(*cmdBuffer, *queryPool, i);
2829 }
2830
2831 endRenderPass(vk, *cmdBuffer);
2832
2833 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
2834 {
2835 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
2836 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
2837
2838 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2839 {
2840 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2841 stride *= 2u;
2842 }
2843
2844 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
2845 {
2846 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
2847 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
2848 stride = sizeof(ValueAndAvailability);
2849 }
2850
2851 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
2852 vk.cmdCopyQueryPoolResults(*cmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
2853
2854 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
2855 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, queryCount);
2856
2857 const VkBufferMemoryBarrier barrier =
2858 {
2859 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
2860 DE_NULL, // const void* pNext;
2861 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
2862 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
2863 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
2864 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
2865 m_resetBuffer->object(), // VkBuffer buffer;
2866 0u, // VkDeviceSize offset;
2867 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
2868 };
2869 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
2870 }
2871
2872 if (!m_parametersGraphic.noColorAttachments)
2873 transition2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
2874 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
2875 }
2876 endCommandBuffer(vk, *cmdBuffer);
2877
2878 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2879 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
2880
2881 // Wait for completion
2882 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
2883 return checkResult (*queryPool);
2884 }
2885
checkResult(VkQueryPool queryPool)2886 tcu::TestStatus TessellationShaderTestInstance::checkResult (VkQueryPool queryPool)
2887 {
2888 const DeviceInterface& vk = m_context.getDeviceInterface();
2889 const VkDevice device = m_context.getDevice();
2890 deUint64 expectedMin = 0u;
2891
2892 switch(m_parametersGraphic.queryStatisticFlags)
2893 {
2894 case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT:
2895 expectedMin = 4u;
2896 break;
2897 case VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT:
2898 expectedMin = 100u;
2899 break;
2900 default:
2901 DE_FATAL("Unexpected type of statistics query");
2902 break;
2903 }
2904
2905 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
2906
2907 if (m_parametersGraphic.resetType == RESET_TYPE_NORMAL || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
2908 {
2909 ResultsVector results(queryCount, 0u);
2910 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
2911 {
2912 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
2913 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags()), m_parametersGraphic.dstOffset);
2914 }
2915 else
2916 {
2917 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags())));
2918 }
2919
2920 if (results[0] < expectedMin)
2921 return tcu::TestStatus::fail("QueryPoolResults incorrect");
2922 if (queryCount > 1)
2923 {
2924 double pearson = calculatePearsonCorrelation(m_drawRepeats, results);
2925 if ( fabs( pearson ) < 0.8 )
2926 return tcu::TestStatus::fail("QueryPoolResults are nonlinear");
2927 }
2928
2929 if (!m_parametersGraphic.noColorAttachments && !checkImage())
2930 return tcu::TestStatus::fail("Result image doesn't match expected image.");
2931 }
2932 else if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
2933 {
2934 ResultsVectorWithAvailability results(queryCount, pair<deUint64,deUint64>(0u,0u));
2935 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
2936 {
2937 const vk::Allocation& allocation = m_resetBuffer->getBoundMemory();
2938 cmdCopyQueryPoolResultsVector(results, vk, device, allocation, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT), m_parametersGraphic.dstOffset);
2939 }
2940 else
2941 {
2942 VK_CHECK(GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (VK_QUERY_RESULT_WAIT_BIT | m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)));
2943 }
2944
2945 if (results[0].first < expectedMin || results[0].second == 0u)
2946 return tcu::TestStatus::fail("QueryPoolResults incorrect");
2947
2948 if (queryCount > 1)
2949 {
2950 double pearson = calculatePearsonCorrelation(m_drawRepeats, results);
2951 if ( fabs( pearson ) < 0.8 )
2952 return tcu::TestStatus::fail("QueryPoolResults are nonlinear");
2953 }
2954
2955 deUint64 temp = results[0].first;
2956
2957 vk.resetQueryPool(device, queryPool, 0, queryCount);
2958 vk::VkResult res = GetQueryPoolResultsVector(results, vk, device, queryPool, 0u, queryCount, (m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT));
2959 /* From Vulkan spec:
2960 *
2961 * If VK_QUERY_RESULT_WAIT_BIT and VK_QUERY_RESULT_PARTIAL_BIT are both not set then no result values are written to pData
2962 * for queries that are in the unavailable state at the time of the call, and vkGetQueryPoolResults returns VK_NOT_READY.
2963 * However, availability state is still written to pData for those queries if VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set.
2964 */
2965 if (res != vk::VK_NOT_READY || results[0].first != temp || results[0].second != 0u)
2966 return tcu::TestStatus::fail("QueryPoolResults incorrect reset");
2967 }
2968 else
2969 {
2970 // With RESET_TYPE_BEFORE_COPY, we only need to verify the result after the copy include an availability bit set as zero.
2971 return verifyUnavailable();
2972 }
2973 return tcu::TestStatus::pass("Pass");
2974 }
2975
draw(VkCommandBuffer cmdBuffer)2976 void TessellationShaderTestInstance::draw (VkCommandBuffer cmdBuffer)
2977 {
2978 const DeviceInterface& vk = m_context.getDeviceInterface();
2979 vk.cmdDraw(cmdBuffer, static_cast<deUint32>(m_data.size()), 1u, 0u, 0u);
2980 }
2981
2982 class TessellationShaderSecondrayTestInstance : public TessellationShaderTestInstance
2983 {
2984 public:
2985 TessellationShaderSecondrayTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
2986 protected:
2987 virtual tcu::TestStatus executeTest (void);
2988 };
2989
TessellationShaderSecondrayTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)2990 TessellationShaderSecondrayTestInstance::TessellationShaderSecondrayTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
2991 : TessellationShaderTestInstance (context, data, parametersGraphic, drawRepeats)
2992 {
2993 }
2994
executeTest(void)2995 tcu::TestStatus TessellationShaderSecondrayTestInstance::executeTest (void)
2996 {
2997 const DeviceInterface& vk = m_context.getDeviceInterface();
2998 const VkDevice device = m_context.getDevice();
2999 const VkQueue queue = m_context.getUniversalQueue();
3000 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
3001
3002 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
3003 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
3004 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
3005 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
3006
3007 const VkDeviceSize vertexBufferOffset = 0u;
3008 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
3009 const VkBuffer vertexBuffer = vertexBufferSp->object();
3010
3011 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
3012 std::vector<VkCommandBufferSp> secondaryCmdBuffers(queryCount);
3013
3014 for (deUint32 i = 0; i < queryCount; ++i)
3015 secondaryCmdBuffers[i] = VkCommandBufferSp(new vk::Unique<VkCommandBuffer>(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY)));
3016
3017 for (deUint32 i = 0; i < queryCount; ++i)
3018 {
3019 beginSecondaryCommandBuffer(vk, secondaryCmdBuffers[i]->get(), m_parametersGraphic.queryStatisticFlags, *m_renderPass, *m_framebuffer, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
3020 vk.cmdBeginQuery(secondaryCmdBuffers[i]->get(), *queryPool, i, (VkQueryControlFlags)0u);
3021 vk.cmdBindPipeline(secondaryCmdBuffers[i]->get(), VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
3022 vk.cmdBindVertexBuffers(secondaryCmdBuffers[i]->get(), 0u, 1u, &vertexBuffer, &vertexBufferOffset);
3023 for (deUint32 j = 0; j<m_drawRepeats[i]; ++j)
3024 draw(secondaryCmdBuffers[i]->get());
3025 vk.cmdEndQuery(secondaryCmdBuffers[i]->get(), *queryPool, i);
3026 endCommandBuffer(vk, secondaryCmdBuffers[i]->get());
3027 }
3028
3029 beginCommandBuffer(vk, *primaryCmdBuffer);
3030 {
3031 std::vector<VkClearValue> renderPassClearValues (2);
3032 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
3033
3034 if (!m_parametersGraphic.noColorAttachments)
3035 initialTransitionColor2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
3036 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
3037
3038 initialTransitionDepth2DImage(vk, *primaryCmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
3039 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
3040
3041 vk.cmdBindVertexBuffers(*primaryCmdBuffer, 0u, 1u, &vertexBuffer, &vertexBufferOffset);
3042 vk.cmdBindPipeline(*primaryCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
3043
3044 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
3045 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
3046
3047 beginRenderPass(vk, *primaryCmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0], VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
3048 for (deUint32 i = 0; i < queryCount; ++i)
3049 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &(secondaryCmdBuffers[i]->get()));
3050 endRenderPass(vk, *primaryCmdBuffer);
3051
3052 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
3053 {
3054 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
3055 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
3056 deUint32 queryCountTess = queryCount;
3057
3058 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
3059 {
3060 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
3061 stride *= 2u;
3062 }
3063
3064 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
3065 {
3066 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
3067 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
3068 stride = sizeof(ValueAndAvailability);
3069 queryCountTess = 1u;
3070 }
3071
3072 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
3073 vk.cmdCopyQueryPoolResults(*primaryCmdBuffer, *queryPool, 0, queryCountTess, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
3074
3075 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
3076 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
3077
3078 const VkBufferMemoryBarrier barrier =
3079 {
3080 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
3081 DE_NULL, // const void* pNext;
3082 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
3083 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
3084 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
3085 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
3086 m_resetBuffer->object(), // VkBuffer buffer;
3087 0u, // VkDeviceSize offset;
3088 queryCountTess * stride + dstOffsetQuery, // VkDeviceSize size;
3089 };
3090 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
3091 }
3092
3093 if (!m_parametersGraphic.noColorAttachments)
3094 transition2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
3095 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
3096 }
3097 endCommandBuffer(vk, *primaryCmdBuffer);
3098
3099 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
3100 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
3101
3102 // Wait for completion
3103 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
3104 return checkResult (*queryPool);
3105 }
3106
3107 class TessellationShaderSecondrayInheritedTestInstance : public TessellationShaderTestInstance
3108 {
3109 public:
3110 TessellationShaderSecondrayInheritedTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats);
3111 protected:
3112 virtual void checkExtensions (deBool hostQueryResetEnabled);
3113 virtual tcu::TestStatus executeTest (void);
3114 };
3115
TessellationShaderSecondrayInheritedTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic,const std::vector<deUint64> & drawRepeats)3116 TessellationShaderSecondrayInheritedTestInstance::TessellationShaderSecondrayInheritedTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic, const std::vector<deUint64>& drawRepeats)
3117 : TessellationShaderTestInstance (context, data, parametersGraphic, drawRepeats)
3118 {
3119 }
3120
checkExtensions(deBool hostQueryResetEnabled)3121 void TessellationShaderSecondrayInheritedTestInstance::checkExtensions (deBool hostQueryResetEnabled)
3122 {
3123 TessellationShaderTestInstance::checkExtensions(hostQueryResetEnabled);
3124 if (!m_context.getDeviceFeatures().inheritedQueries)
3125 throw tcu::NotSupportedError("Inherited queries are not supported");
3126 }
3127
executeTest(void)3128 tcu::TestStatus TessellationShaderSecondrayInheritedTestInstance::executeTest (void)
3129 {
3130 const DeviceInterface& vk = m_context.getDeviceInterface();
3131 const VkDevice device = m_context.getDevice();
3132 const VkQueue queue = m_context.getUniversalQueue();
3133 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
3134
3135 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
3136 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
3137 const deUint32 queryCount = static_cast<deUint32>(m_drawRepeats.size());
3138 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, queryCount, m_parametersGraphic.queryStatisticFlags));
3139
3140 const VkDeviceSize vertexBufferOffset = 0u;
3141 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
3142 const VkBuffer vertexBuffer = vertexBufferSp->object();
3143
3144 const Unique<VkCommandBuffer> primaryCmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
3145 std::vector<VkCommandBufferSp> secondaryCmdBuffers(queryCount);
3146
3147 for (deUint32 i = 0; i < queryCount; ++i)
3148 secondaryCmdBuffers[i] = VkCommandBufferSp(new vk::Unique<VkCommandBuffer>(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY)));
3149
3150 for (deUint32 i = 0; i < queryCount; ++i)
3151 {
3152 beginSecondaryCommandBuffer(vk, secondaryCmdBuffers[i]->get(), m_parametersGraphic.queryStatisticFlags, *m_renderPass, *m_framebuffer, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT);
3153 vk.cmdBindPipeline(secondaryCmdBuffers[i]->get(), VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
3154 vk.cmdBindVertexBuffers(secondaryCmdBuffers[i]->get(), 0u, 1u, &vertexBuffer, &vertexBufferOffset);
3155 for (deUint32 j = 0; j<m_drawRepeats[i]; ++j)
3156 draw(secondaryCmdBuffers[i]->get());
3157 endCommandBuffer(vk, secondaryCmdBuffers[i]->get());
3158 }
3159
3160 beginCommandBuffer(vk, *primaryCmdBuffer);
3161 {
3162 std::vector<VkClearValue> renderPassClearValues (2);
3163 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
3164
3165 if (!m_parametersGraphic.noColorAttachments)
3166 initialTransitionColor2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
3167 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
3168
3169 initialTransitionDepth2DImage(vk, *primaryCmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
3170 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
3171
3172 if (m_parametersGraphic.resetType != RESET_TYPE_HOST)
3173 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
3174
3175 for (deUint32 i = 0; i < queryCount; ++i)
3176 {
3177 vk.cmdBeginQuery(*primaryCmdBuffer, *queryPool, i, (VkQueryControlFlags)0u);
3178 beginRenderPass(vk, *primaryCmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0], VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
3179 vk.cmdExecuteCommands(*primaryCmdBuffer, 1u, &(secondaryCmdBuffers[i]->get()));
3180 endRenderPass(vk, *primaryCmdBuffer);
3181 vk.cmdEndQuery(*primaryCmdBuffer, *queryPool, i);
3182 }
3183
3184 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY || m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY || m_parametersGraphic.copyType == COPY_TYPE_CMD)
3185 {
3186 VkDeviceSize stride = m_parametersGraphic.querySizeFlags() ? sizeof(deUint64) : sizeof(deUint32);
3187 vk::VkQueryResultFlags flags = m_parametersGraphic.querySizeFlags() | VK_QUERY_RESULT_WAIT_BIT;
3188
3189 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
3190 {
3191 flags |= VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
3192 stride *= 2u;
3193 }
3194
3195 if (m_parametersGraphic.resetType == RESET_TYPE_BEFORE_COPY)
3196 {
3197 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
3198 flags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT;
3199 stride = sizeof(ValueAndAvailability);
3200 }
3201
3202 VkDeviceSize dstOffsetQuery = (m_parametersGraphic.dstOffset) ? stride : 0;
3203 vk.cmdCopyQueryPoolResults(*primaryCmdBuffer, *queryPool, 0, queryCount, m_resetBuffer->object(), dstOffsetQuery, stride, flags);
3204
3205 if (m_parametersGraphic.resetType == RESET_TYPE_AFTER_COPY)
3206 vk.cmdResetQueryPool(*primaryCmdBuffer, *queryPool, 0u, queryCount);
3207
3208 const VkBufferMemoryBarrier barrier =
3209 {
3210 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
3211 DE_NULL, // const void* pNext;
3212 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
3213 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
3214 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
3215 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
3216 m_resetBuffer->object(), // VkBuffer buffer;
3217 0u, // VkDeviceSize offset;
3218 queryCount * stride + dstOffsetQuery, // VkDeviceSize size;
3219 };
3220 vk.cmdPipelineBarrier(*primaryCmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
3221 }
3222
3223 if (!m_parametersGraphic.noColorAttachments)
3224 transition2DImage(vk, *primaryCmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
3225 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
3226 }
3227 endCommandBuffer(vk, *primaryCmdBuffer);
3228
3229 if (m_parametersGraphic.resetType == RESET_TYPE_HOST)
3230 vk.resetQueryPool(device, *queryPool, 0u, queryCount);
3231
3232 // Wait for completion
3233 submitCommandsAndWait(vk, device, queue, *primaryCmdBuffer);
3234 return checkResult (*queryPool);
3235 }
3236
3237 template<class Instance>
3238 class QueryPoolStatisticsTest : public TestCase
3239 {
3240 public:
QueryPoolStatisticsTest(tcu::TestContext & context,const std::string & name,const std::string & description,const ResetType resetType,const CopyType copyType,deBool query64Bits,deBool dstOffset=DE_FALSE,const StrideType strideType=STRIDE_TYPE_VALID)3241 QueryPoolStatisticsTest (tcu::TestContext &context, const std::string& name, const std::string& description, const ResetType resetType, const CopyType copyType, deBool query64Bits, deBool dstOffset = DE_FALSE, const StrideType strideType = STRIDE_TYPE_VALID)
3242 : TestCase (context, name.c_str(), description.c_str())
3243 {
3244 const tcu::UVec3 localSize[] =
3245 {
3246 tcu::UVec3 (2u, 2u, 2u),
3247 tcu::UVec3 (1u, 1u, 1u),
3248 tcu::UVec3 (WIDTH/(7u*3u), 7u, 3u),
3249 };
3250
3251 const tcu::UVec3 groupSize[] =
3252 {
3253 tcu::UVec3 (2u, 2u, 2u),
3254 tcu::UVec3 (WIDTH/(7u*3u), 7u, 3u),
3255 tcu::UVec3 (1u, 1u, 1u),
3256 };
3257
3258 DE_ASSERT(DE_LENGTH_OF_ARRAY(localSize) == DE_LENGTH_OF_ARRAY(groupSize));
3259
3260 for(int shaderNdx = 0; shaderNdx < DE_LENGTH_OF_ARRAY(localSize); ++shaderNdx)
3261 {
3262 std::ostringstream shaderName;
3263 shaderName<< "compute_" << shaderNdx;
3264 const ComputeInvocationsTestInstance::ParametersCompute parameters(
3265 localSize[shaderNdx],
3266 groupSize[shaderNdx],
3267 shaderName.str(),
3268 resetType,
3269 copyType,
3270 query64Bits,
3271 dstOffset,
3272 strideType
3273 );
3274 m_parameters.push_back(parameters);
3275 }
3276 }
3277
createInstance(vkt::Context & context) const3278 vkt::TestInstance* createInstance (vkt::Context& context) const
3279 {
3280 return new Instance(context, m_parameters);
3281 }
3282
initPrograms(SourceCollections & sourceCollections) const3283 void initPrograms(SourceCollections& sourceCollections) const
3284 {
3285 std::ostringstream source;
3286 source << "layout(binding = 0) writeonly buffer Output {\n"
3287 << " uint values[];\n"
3288 << "} sb_out;\n\n"
3289 << "void main (void) {\n"
3290 << " uvec3 indexUvec3 = uvec3 (gl_GlobalInvocationID.x,\n"
3291 << " gl_GlobalInvocationID.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x,\n"
3292 << " gl_GlobalInvocationID.z * gl_NumWorkGroups.x * gl_NumWorkGroups.y * gl_WorkGroupSize.x * gl_WorkGroupSize.y);\n"
3293 << " uint index = indexUvec3.x + indexUvec3.y + indexUvec3.z;\n"
3294 << " sb_out.values[index] += index;\n"
3295 << "}\n";
3296
3297 for(size_t shaderNdx = 0; shaderNdx < m_parameters.size(); ++shaderNdx)
3298 {
3299 std::ostringstream src;
3300 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n"
3301 << "layout (local_size_x = " << m_parameters[shaderNdx].localSize.x() << ", local_size_y = " << m_parameters[shaderNdx].localSize.y() << ", local_size_z = " << m_parameters[shaderNdx].localSize.z() << ") in;\n"
3302 << source.str();
3303 sourceCollections.glslSources.add(m_parameters[shaderNdx].shaderName) << glu::ComputeSource(src.str());
3304 }
3305 }
3306 private:
3307 std::vector<ComputeInvocationsTestInstance::ParametersCompute> m_parameters;
3308 };
3309
3310 template<class Instance>
3311 class QueryPoolGraphicStatisticsTest : public TestCase
3312 {
3313 public:
QueryPoolGraphicStatisticsTest(tcu::TestContext & context,const std::string & name,const std::string & description,const GraphicBasicTestInstance::ParametersGraphic parametersGraphic,const std::vector<deUint64> & drawRepeats)3314 QueryPoolGraphicStatisticsTest (tcu::TestContext &context, const std::string& name, const std::string& description, const GraphicBasicTestInstance::ParametersGraphic parametersGraphic, const std::vector<deUint64>& drawRepeats)
3315 : TestCase (context, name.c_str(), description.c_str())
3316 , m_parametersGraphic (parametersGraphic)
3317 , m_drawRepeats ( drawRepeats )
3318 {
3319 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4(-1.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
3320 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4(-1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
3321 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
3322 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
3323
3324 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4(-1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
3325 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
3326 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
3327 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
3328
3329 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
3330 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
3331 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 1.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
3332 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
3333
3334 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
3335 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 0.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
3336 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
3337 m_data.push_back(GraphicBasicTestInstance::VertexData(tcu::Vec4( 1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
3338 }
3339
checkSupport(vkt::Context & context) const3340 void checkSupport (vkt::Context& context) const
3341 {
3342 #ifndef CTS_USES_VULKANSC
3343 if (m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN &&
3344 context.isDeviceFunctionalitySupported("VK_KHR_portability_subset") &&
3345 !context.getPortabilitySubsetFeatures().triangleFans)
3346 {
3347 TCU_THROW(NotSupportedError, "VK_KHR_portability_subset: Triangle fans are not supported by this implementation");
3348 }
3349 #else
3350 DE_UNREF(context);
3351 #endif // CTS_USES_VULKANSC
3352 }
3353
createInstance(vkt::Context & context) const3354 vkt::TestInstance* createInstance (vkt::Context& context) const
3355 {
3356 return new Instance(context, m_data, m_parametersGraphic, m_drawRepeats);
3357 }
3358
initPrograms(SourceCollections & sourceCollections) const3359 void initPrograms(SourceCollections& sourceCollections) const
3360 {
3361 { // Vertex Shader
3362 std::ostringstream source;
3363 source << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n"
3364 << "layout(location = 0) in highp vec4 in_position;\n"
3365 << "layout(location = 1) in vec4 in_color;\n"
3366 << "layout(location = 0) out vec4 out_color;\n"
3367 << "void main (void)\n"
3368 << "{\n"
3369 << " gl_PointSize = 1.0;\n"
3370 << " gl_Position = in_position;\n"
3371 << " out_color = in_color;\n"
3372 << "}\n";
3373 sourceCollections.glslSources.add("vertex") << glu::VertexSource(source.str());
3374 }
3375
3376 if (m_parametersGraphic.queryStatisticFlags & (VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT|
3377 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT))
3378 {// Tessellation control & evaluation
3379 std::ostringstream source_tc;
3380 source_tc << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
3381 << "#extension GL_EXT_tessellation_shader : require\n"
3382 << "layout(vertices = 4) out;\n"
3383 << "layout(location = 0) in vec4 in_color[];\n"
3384 << "layout(location = 0) out vec4 out_color[];\n"
3385 << "\n"
3386 << "void main (void)\n"
3387 << "{\n"
3388 << " if( gl_InvocationID == 0 )\n"
3389 << " {\n"
3390 << " gl_TessLevelInner[0] = 4.0f;\n"
3391 << " gl_TessLevelInner[1] = 4.0f;\n"
3392 << " gl_TessLevelOuter[0] = 4.0f;\n"
3393 << " gl_TessLevelOuter[1] = 4.0f;\n"
3394 << " gl_TessLevelOuter[2] = 4.0f;\n"
3395 << " gl_TessLevelOuter[3] = 4.0f;\n"
3396 << " }\n"
3397 << " out_color[gl_InvocationID] = in_color[gl_InvocationID];\n"
3398 << " gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
3399 << "}\n";
3400 sourceCollections.glslSources.add("tessellation_control") << glu::TessellationControlSource(source_tc.str());
3401
3402 std::ostringstream source_te;
3403 source_te << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
3404 << "#extension GL_EXT_tessellation_shader : require\n"
3405 << "layout( quads, equal_spacing, ccw ) in;\n"
3406 << "layout(location = 0) in vec4 in_color[];\n"
3407 << "layout(location = 0) out vec4 out_color;\n"
3408 << "void main (void)\n"
3409 << "{\n"
3410 << " const float u = gl_TessCoord.x;\n"
3411 << " const float v = gl_TessCoord.y;\n"
3412 << " const float w = gl_TessCoord.z;\n"
3413 << " gl_Position = (1 - u) * (1 - v) * gl_in[0].gl_Position +(1 - u) * v * gl_in[1].gl_Position + u * (1 - v) * gl_in[2].gl_Position + u * v * gl_in[3].gl_Position;\n"
3414 << " out_color = in_color[0];\n"
3415 << "}\n";
3416 sourceCollections.glslSources.add("tessellation_evaluation") << glu::TessellationEvaluationSource(source_te.str());
3417 }
3418
3419 if(m_parametersGraphic.queryStatisticFlags & (VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT | VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT |
3420 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT | VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT))
3421 { // Geometry Shader
3422 const bool isTopologyPointSize = m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
3423 std::ostringstream source;
3424 source << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n"
3425 << "layout("<<inputTypeToGLString(m_parametersGraphic.primitiveTopology)<<") in;\n"
3426 << "layout("<<outputTypeToGLString (m_parametersGraphic.primitiveTopology)<<", max_vertices = 16) out;\n"
3427 << "layout(location = 0) in vec4 in_color[];\n"
3428 << "layout(location = 0) out vec4 out_color;\n"
3429 << "void main (void)\n"
3430 << "{\n"
3431 << " out_color = in_color[0];\n"
3432 << (isTopologyPointSize ? "${pointSize}" : "" )
3433 << " gl_Position = gl_in[0].gl_Position;\n"
3434 << " EmitVertex();\n"
3435 << " EndPrimitive();\n"
3436 << "\n"
3437 << " out_color = in_color[0];\n"
3438 << (isTopologyPointSize ? "${pointSize}" : "")
3439 << " gl_Position = vec4(1.0, 1.0, 1.0, 1.0);\n"
3440 << " EmitVertex();\n"
3441 << " out_color = in_color[0];\n"
3442 << (isTopologyPointSize ? "${pointSize}" : "")
3443 << " gl_Position = vec4(-1.0, -1.0, 1.0, 1.0);\n"
3444 << " EmitVertex();\n"
3445 << " EndPrimitive();\n"
3446 << "\n";
3447 if (m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP ||
3448 m_parametersGraphic.primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
3449 {
3450 source << "\n"
3451 << " out_color = in_color[0];\n"
3452 << " gl_Position = gl_in[0].gl_Position;\n"
3453 << " EmitVertex();\n"
3454 << " out_color = in_color[0];\n"
3455 << " gl_Position = gl_in[1].gl_Position;\n"
3456 << " EmitVertex();\n"
3457 << " out_color = in_color[0];\n"
3458 << " gl_Position = gl_in[2].gl_Position;\n"
3459 << " EmitVertex();\n"
3460 << " out_color = in_color[0];\n"
3461 << " gl_Position = vec4(gl_in[2].gl_Position.x, gl_in[1].gl_Position.y, 1.0, 1.0);\n"
3462 << " EmitVertex();\n"
3463 << " EndPrimitive();\n";
3464 }
3465 else
3466 {
3467 source << " out_color = in_color[0];\n"
3468 << (isTopologyPointSize ? "${pointSize}" : "")
3469 << " gl_Position = vec4(1.0, 1.0, 1.0, 1.0);\n"
3470 << " EmitVertex();\n"
3471 << " out_color = in_color[0];\n"
3472 << (isTopologyPointSize ? "${pointSize}" : "")
3473 << " gl_Position = vec4(1.0, -1.0, 1.0, 1.0);\n"
3474 << " EmitVertex();\n"
3475 << " out_color = in_color[0];\n"
3476 << (isTopologyPointSize ? "${pointSize}" : "")
3477 << " gl_Position = vec4(-1.0, 1.0, 1.0, 1.0);\n"
3478 << " EmitVertex();\n"
3479 << " out_color = in_color[0];\n"
3480 << (isTopologyPointSize ? "${pointSize}" : "")
3481 << " gl_Position = vec4(-1.0, -1.0, 1.0, 1.0);\n"
3482 << " EmitVertex();\n"
3483 << " EndPrimitive();\n";
3484 }
3485 source << "}\n";
3486
3487 if (isTopologyPointSize)
3488 {
3489 // Add geometry shader codes with and without gl_PointSize if the primitive topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST
3490
3491 tcu::StringTemplate sourceTemplate(source.str());
3492
3493 std::map<std::string, std::string> pointSize;
3494 std::map<std::string, std::string> noPointSize;
3495
3496 pointSize["pointSize"] = " gl_PointSize = gl_in[0].gl_PointSize;\n";
3497 noPointSize["pointSize"] = "";
3498
3499 sourceCollections.glslSources.add("geometry") << glu::GeometrySource(sourceTemplate.specialize(noPointSize));
3500 sourceCollections.glslSources.add("geometry_point_size") << glu::GeometrySource(sourceTemplate.specialize(pointSize));
3501 }
3502 else
3503 {
3504 sourceCollections.glslSources.add("geometry") << glu::GeometrySource(source.str());
3505 }
3506 }
3507
3508 if (!m_parametersGraphic.vertexOnlyPipe)
3509 { // Fragment Shader
3510 std::ostringstream source;
3511 source << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n"
3512 << "layout(location = 0) in vec4 in_color;\n"
3513 << "layout(location = 0) out vec4 out_color;\n"
3514 << "void main()\n"
3515 <<"{\n"
3516 << " out_color = in_color;\n"
3517 << "}\n";
3518 sourceCollections.glslSources.add("fragment") << glu::FragmentSource(source.str());
3519 }
3520 }
3521 private:
3522 std::vector<GraphicBasicTestInstance::VertexData> m_data;
3523 const GraphicBasicTestInstance::ParametersGraphic m_parametersGraphic;
3524 std::vector<deUint64> m_drawRepeats;
3525 };
3526
3527 #define NUM_QUERY_STATISTICS 4
3528
3529 class StatisticMultipleQueryTestInstance : public TestInstance
3530 {
3531 public:
3532 StatisticMultipleQueryTestInstance (Context& context, const deUint32 queryCount);
3533 protected:
3534 de::SharedPtr<Buffer> m_queryBuffer;
3535
3536 virtual void checkExtensions ();
3537 };
3538
StatisticMultipleQueryTestInstance(Context & context,const deUint32 queryCount)3539 StatisticMultipleQueryTestInstance::StatisticMultipleQueryTestInstance (Context& context, const deUint32 queryCount)
3540 : TestInstance (context)
3541 , m_queryBuffer (Buffer::createAndAlloc(context.getDeviceInterface(),
3542 context.getDevice(),
3543 BufferCreateInfo(NUM_QUERY_STATISTICS * sizeof(deUint64) * queryCount, VK_BUFFER_USAGE_TRANSFER_DST_BIT),
3544 context.getDefaultAllocator(),
3545 vk::MemoryRequirement::HostVisible))
3546 {
3547 const vk::Allocation& allocation = m_queryBuffer->getBoundMemory();
3548 void* allocationData = allocation.getHostPtr();
3549 deMemset(allocationData, 0xff, NUM_QUERY_STATISTICS * sizeof(deUint64) * queryCount);
3550 }
3551
checkExtensions()3552 void StatisticMultipleQueryTestInstance::checkExtensions ()
3553 {
3554 if (!m_context.getDeviceFeatures().pipelineStatisticsQuery)
3555 throw tcu::NotSupportedError("Pipeline statistics queries are not supported");
3556 }
3557
3558 class GraphicBasicMultipleQueryTestInstance : public StatisticMultipleQueryTestInstance
3559 {
3560 public:
3561 struct VertexData
3562 {
VertexDatavkt::QueryPool::__anon17cda4650111::GraphicBasicMultipleQueryTestInstance::VertexData3563 VertexData (const tcu::Vec4 position_, const tcu::Vec4 color_)
3564 : position (position_)
3565 , color (color_)
3566 {}
3567 tcu::Vec4 position;
3568 tcu::Vec4 color;
3569 };
3570
3571 struct ParametersGraphic : public GenericParameters
3572 {
ParametersGraphicvkt::QueryPool::__anon17cda4650111::GraphicBasicMultipleQueryTestInstance::ParametersGraphic3573 ParametersGraphic (const VkQueryPipelineStatisticFlags queryStatisticFlags_, const VkQueryResultFlags queryFlags_, const deUint32 queryCount_, const deBool vertexOnlyPipe_, const CopyType copyType_, const deUint32 dstOffset_, const StrideType strideType_, const ClearOperation clearOp_ = CLEAR_NOOP)
3574 : GenericParameters { RESET_TYPE_NORMAL, copyType_, (queryFlags_ & VK_QUERY_RESULT_64_BIT) != 0u, dstOffset_ != 0u, strideType_ }
3575 , queryStatisticFlags (queryStatisticFlags_)
3576 , vertexOnlyPipe (vertexOnlyPipe_)
3577 , queryFlags (queryFlags_)
3578 , queryCount (queryCount_)
3579 , dstOffset (dstOffset_)
3580 , clearOp (clearOp_)
3581 {}
3582
3583 VkQueryPipelineStatisticFlags queryStatisticFlags;
3584 VkPrimitiveTopology primitiveTopology;
3585 deBool vertexOnlyPipe;
3586 VkQueryResultFlags queryFlags;
3587 deUint32 queryCount;
3588 deUint32 dstOffset;
3589 ClearOperation clearOp;
3590 };
3591 GraphicBasicMultipleQueryTestInstance (vkt::Context& context,
3592 const std::vector<VertexData>& data,
3593 const ParametersGraphic& parametersGraphic);
3594 tcu::TestStatus iterate (void);
3595 protected:
3596 de::SharedPtr<Buffer> creatAndFillVertexBuffer (void);
3597 virtual void createPipeline (void) = 0;
3598 void creatColorAttachmentAndRenderPass (void);
3599 virtual tcu::TestStatus executeTest (void) = 0;
3600 virtual tcu::TestStatus checkResult (VkQueryPool queryPool) = 0;
3601 virtual void draw (VkCommandBuffer cmdBuffer) = 0;
3602
3603 const VkFormat m_colorAttachmentFormat;
3604 de::SharedPtr<Image> m_colorAttachmentImage;
3605 de::SharedPtr<Image> m_depthImage;
3606 Move<VkImageView> m_attachmentView;
3607 Move<VkImageView> m_depthView;
3608 Move<VkRenderPass> m_renderPass;
3609 Move<VkFramebuffer> m_framebuffer;
3610 Move<VkPipeline> m_pipeline;
3611 Move<VkPipelineLayout> m_pipelineLayout;
3612 const std::vector<VertexData>& m_data;
3613 const ParametersGraphic& m_parametersGraphic;
3614 };
3615
GraphicBasicMultipleQueryTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic)3616 GraphicBasicMultipleQueryTestInstance::GraphicBasicMultipleQueryTestInstance (vkt::Context& context,
3617 const std::vector<VertexData>& data,
3618 const ParametersGraphic& parametersGraphic)
3619 : StatisticMultipleQueryTestInstance (context, (parametersGraphic.queryCount + (parametersGraphic.dstOffset != 0u ? 1u : 0u)))
3620 , m_colorAttachmentFormat (VK_FORMAT_R8G8B8A8_UNORM)
3621 , m_data (data)
3622 , m_parametersGraphic (parametersGraphic)
3623 {
3624 }
3625
iterate(void)3626 tcu::TestStatus GraphicBasicMultipleQueryTestInstance::iterate (void)
3627 {
3628 checkExtensions();
3629 creatColorAttachmentAndRenderPass();
3630 createPipeline();
3631 return executeTest();
3632 }
3633
creatAndFillVertexBuffer(void)3634 de::SharedPtr<Buffer> GraphicBasicMultipleQueryTestInstance::creatAndFillVertexBuffer (void)
3635 {
3636 const DeviceInterface& vk = m_context.getDeviceInterface();
3637 const VkDevice device = m_context.getDevice();
3638
3639 const VkDeviceSize dataSize = static_cast<VkDeviceSize>(deAlignSize(static_cast<size_t>( m_data.size() * sizeof(VertexData)),
3640 static_cast<size_t>(m_context.getDeviceProperties().limits.nonCoherentAtomSize)));
3641
3642 de::SharedPtr<Buffer> vertexBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize,
3643 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
3644
3645 deUint8* ptr = reinterpret_cast<deUint8*>(vertexBuffer->getBoundMemory().getHostPtr());
3646 deMemcpy(ptr, &m_data[0], static_cast<size_t>( m_data.size() * sizeof(VertexData)));
3647
3648 flushMappedMemoryRange(vk, device, vertexBuffer->getBoundMemory().getMemory(), vertexBuffer->getBoundMemory().getOffset(), dataSize);
3649 return vertexBuffer;
3650 }
3651
creatColorAttachmentAndRenderPass(void)3652 void GraphicBasicMultipleQueryTestInstance::creatColorAttachmentAndRenderPass (void)
3653 {
3654 const DeviceInterface& vk = m_context.getDeviceInterface();
3655 const VkDevice device = m_context.getDevice();
3656
3657 {
3658 VkExtent3D imageExtent =
3659 {
3660 WIDTH, // width;
3661 HEIGHT, // height;
3662 1u // depth;
3663 };
3664
3665 const ImageCreateInfo colorImageCreateInfo (VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL,
3666 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
3667
3668 m_colorAttachmentImage = Image::createAndAlloc(vk, device, colorImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
3669
3670 const ImageViewCreateInfo attachmentViewInfo (m_colorAttachmentImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat);
3671 m_attachmentView = createImageView(vk, device, &attachmentViewInfo);
3672
3673 ImageCreateInfo depthImageCreateInfo (vk::VK_IMAGE_TYPE_2D, VK_FORMAT_D16_UNORM, imageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT, vk::VK_IMAGE_TILING_OPTIMAL,
3674 vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
3675
3676 m_depthImage = Image::createAndAlloc(vk, device, depthImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
3677
3678 // Construct a depth view from depth image
3679 const ImageViewCreateInfo depthViewInfo (m_depthImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_D16_UNORM);
3680 m_depthView = vk::createImageView(vk, device, &depthViewInfo);
3681 }
3682
3683 {
3684 // Renderpass and Framebuffer
3685 RenderPassCreateInfo renderPassCreateInfo;
3686 renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat, // format
3687 VK_SAMPLE_COUNT_1_BIT, // samples
3688 VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
3689 VK_ATTACHMENT_STORE_OP_STORE , // storeOp
3690 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
3691 VK_ATTACHMENT_STORE_OP_STORE , // stencilLoadOp
3692 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // initialLauout
3693 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)); // finalLayout
3694
3695 renderPassCreateInfo.addAttachment(AttachmentDescription(VK_FORMAT_D16_UNORM, // format
3696 vk::VK_SAMPLE_COUNT_1_BIT, // samples
3697 vk::VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
3698 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
3699 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
3700 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
3701 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // initialLauout
3702 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)); // finalLayout
3703
3704 const VkAttachmentReference colorAttachmentReference =
3705 {
3706 0u, // attachment
3707 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // layout
3708 };
3709
3710 const VkAttachmentReference depthAttachmentReference =
3711 {
3712 1u, // attachment
3713 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL // layout
3714 };
3715
3716 const VkSubpassDescription subpass =
3717 {
3718 (VkSubpassDescriptionFlags) 0, //VkSubpassDescriptionFlags flags;
3719 VK_PIPELINE_BIND_POINT_GRAPHICS, //VkPipelineBindPoint pipelineBindPoint;
3720 0u, //deUint32 inputAttachmentCount;
3721 DE_NULL, //const VkAttachmentReference* pInputAttachments;
3722 1u, //deUint32 colorAttachmentCount;
3723 &colorAttachmentReference, //const VkAttachmentReference* pColorAttachments;
3724 DE_NULL, //const VkAttachmentReference* pResolveAttachments;
3725 &depthAttachmentReference, //const VkAttachmentReference* pDepthStencilAttachment;
3726 0u, //deUint32 preserveAttachmentCount;
3727 DE_NULL, //const deUint32* pPreserveAttachments;
3728 };
3729
3730 renderPassCreateInfo.addSubpass(subpass);
3731 m_renderPass = createRenderPass(vk, device, &renderPassCreateInfo);
3732
3733 std::vector<vk::VkImageView> attachments(2);
3734 attachments[0] = *m_attachmentView;
3735 attachments[1] = *m_depthView;
3736
3737 FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, WIDTH, HEIGHT, 1);
3738 m_framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
3739 }
3740 }
3741
3742 class VertexShaderMultipleQueryTestInstance : public GraphicBasicMultipleQueryTestInstance
3743 {
3744 public:
3745 VertexShaderMultipleQueryTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic);
3746 protected:
3747 virtual void createPipeline (void);
3748 virtual tcu::TestStatus executeTest (void);
3749 virtual tcu::TestStatus checkResult (VkQueryPool queryPool);
3750 void draw (VkCommandBuffer cmdBuffer);
3751 deUint64 calculateExpectedMin (VkQueryResultFlags flag);
3752 deUint64 calculateExpectedMax (VkQueryResultFlags flag);
3753 };
3754
VertexShaderMultipleQueryTestInstance(vkt::Context & context,const std::vector<VertexData> & data,const ParametersGraphic & parametersGraphic)3755 VertexShaderMultipleQueryTestInstance::VertexShaderMultipleQueryTestInstance (vkt::Context& context, const std::vector<VertexData>& data, const ParametersGraphic& parametersGraphic)
3756 : GraphicBasicMultipleQueryTestInstance (context, data, parametersGraphic)
3757 {
3758 }
3759
createPipeline(void)3760 void VertexShaderMultipleQueryTestInstance::createPipeline (void)
3761 {
3762 const DeviceInterface& vk = m_context.getDeviceInterface();
3763 const VkDevice device = m_context.getDevice();
3764
3765 // Pipeline
3766 Unique<VkShaderModule> vs(createShaderModule(vk, device, m_context.getBinaryCollection().get("vertex"), 0));
3767 Move<VkShaderModule> fs;
3768
3769 if (!m_parametersGraphic.vertexOnlyPipe)
3770 fs = createShaderModule(vk, device, m_context.getBinaryCollection().get("fragment"), 0);
3771
3772 const PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
3773
3774 const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
3775 m_pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
3776
3777 const VkVertexInputBindingDescription vertexInputBindingDescription =
3778 {
3779 0, // binding;
3780 static_cast<deUint32>(sizeof(VertexData)), // stride;
3781 VK_VERTEX_INPUT_RATE_VERTEX // inputRate
3782 };
3783
3784 const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
3785 {
3786 {
3787 0u,
3788 0u,
3789 VK_FORMAT_R32G32B32A32_SFLOAT,
3790 0u
3791 }, // VertexElementData::position
3792 {
3793 1u,
3794 0u,
3795 VK_FORMAT_R32G32B32A32_SFLOAT,
3796 static_cast<deUint32>(sizeof(tcu::Vec4))
3797 }, // VertexElementData::color
3798 };
3799
3800 const VkPipelineVertexInputStateCreateInfo vf_info =
3801 { // sType;
3802 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // pNext;
3803 NULL, // flags;
3804 0u, // vertexBindingDescriptionCount;
3805 1u, // pVertexBindingDescriptions;
3806 &vertexInputBindingDescription, // vertexAttributeDescriptionCount;
3807 2u, // pVertexAttributeDescriptions;
3808 vertexInputAttributeDescriptions
3809 };
3810
3811 PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, (VkPipelineCreateFlags)0);
3812 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
3813 if (!m_parametersGraphic.vertexOnlyPipe)
3814 pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
3815 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
3816 pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST));
3817 pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &attachmentState));
3818
3819 const VkViewport viewport = makeViewport(WIDTH, HEIGHT);
3820 const VkRect2D scissor = makeRect2D(WIDTH, HEIGHT);
3821 pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1u, std::vector<VkViewport>(1, viewport), std::vector<VkRect2D>(1, scissor)));
3822 pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
3823 pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
3824 pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
3825 pipelineCreateInfo.addState(vf_info);
3826 m_pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
3827 }
3828
executeTest(void)3829 tcu::TestStatus VertexShaderMultipleQueryTestInstance::executeTest (void)
3830 {
3831 const DeviceInterface& vk = m_context.getDeviceInterface();
3832 const VkDevice device = m_context.getDevice();
3833 const VkQueue queue = m_context.getUniversalQueue();
3834 const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
3835
3836 const CmdPoolCreateInfo cmdPoolCreateInfo (queueFamilyIndex);
3837 const Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
3838 const Unique<VkQueryPool> queryPool (makeQueryPool(vk, device, m_parametersGraphic.queryCount, m_parametersGraphic.queryStatisticFlags));
3839
3840 const VkDeviceSize vertexBufferOffset = 0u;
3841 const de::SharedPtr<Buffer> vertexBufferSp = creatAndFillVertexBuffer();
3842 const VkBuffer vertexBuffer = vertexBufferSp->object();
3843
3844 const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
3845
3846 beginCommandBuffer(vk, *cmdBuffer);
3847 {
3848 std::vector<VkClearValue> renderPassClearValues (2);
3849 deMemset(&renderPassClearValues[0], 0, static_cast<int>(renderPassClearValues.size()) * sizeof(VkClearValue));
3850
3851 initialTransitionColor2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
3852 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
3853 initialTransitionDepth2DImage(vk, *cmdBuffer, m_depthImage->object(), VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
3854 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
3855
3856 vk.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, m_parametersGraphic.queryCount);
3857
3858 beginRenderPass(vk, *cmdBuffer, *m_renderPass, *m_framebuffer, makeRect2D(0, 0, WIDTH, HEIGHT), (deUint32)renderPassClearValues.size(), &renderPassClearValues[0]);
3859
3860 vk.cmdBeginQuery(*cmdBuffer, *queryPool, 0u, (VkQueryControlFlags)0u);
3861 vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
3862 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
3863
3864 draw(*cmdBuffer);
3865
3866 vk.cmdEndQuery(*cmdBuffer, *queryPool, 0u);
3867
3868 endRenderPass(vk, *cmdBuffer);
3869
3870 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
3871 {
3872 VkDeviceSize copyStride = NUM_QUERY_STATISTICS * sizeof(deUint64);
3873 if (m_parametersGraphic.queryCount == 1u && m_parametersGraphic.strideType == STRIDE_TYPE_ZERO)
3874 copyStride = 0u;
3875
3876 vk.cmdCopyQueryPoolResults(*cmdBuffer, *queryPool, 0, m_parametersGraphic.queryCount, m_queryBuffer->object(), m_parametersGraphic.dstOffset, copyStride, m_parametersGraphic.queryFlags);
3877
3878 const VkDeviceSize bufferSize = NUM_QUERY_STATISTICS * sizeof(deUint64) * m_parametersGraphic.queryCount;
3879 const VkBufferMemoryBarrier barrier =
3880 {
3881 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
3882 DE_NULL, // const void* pNext;
3883 VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
3884 VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
3885 VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
3886 VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
3887 m_queryBuffer->object(), // VkBuffer buffer;
3888 0u, // VkDeviceSize offset;
3889 bufferSize, // VkDeviceSize size;
3890 };
3891
3892 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
3893 }
3894
3895 transition2DImage(vk, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
3896 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
3897 }
3898 endCommandBuffer(vk, *cmdBuffer);
3899
3900 // Wait for completion
3901 submitCommandsAndWait(vk, device, queue, *cmdBuffer);
3902 return checkResult (*queryPool);
3903 }
3904
calculateExpectedMin(VkQueryResultFlags flag)3905 deUint64 VertexShaderMultipleQueryTestInstance::calculateExpectedMin(VkQueryResultFlags flag)
3906 {
3907 deUint64 expectedMin = 0u;
3908 switch (flag)
3909 {
3910 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT:
3911 expectedMin = 15u;
3912 break;
3913
3914 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT:
3915 expectedMin = 5u;
3916 break;
3917
3918 case VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT:
3919 expectedMin = 15u;
3920 break;
3921
3922 case VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT:
3923 expectedMin = 2016u;
3924 break;
3925 default:
3926 DE_FATAL("Unexpected type of statistics query");
3927 break;
3928 }
3929 return expectedMin;
3930 }
3931
3932 /* This is just to check that driver doesn't return garbage for the partial, no wait case.
3933 * TODO: adjust the values accordingly, in case some driver returns higher values.
3934 */
calculateExpectedMax(VkQueryResultFlags flag)3935 deUint64 VertexShaderMultipleQueryTestInstance::calculateExpectedMax(VkQueryResultFlags flag)
3936 {
3937 deUint64 expectedMax = 0u;
3938 switch (flag)
3939 {
3940 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT:
3941 expectedMax = 16u;
3942 break;
3943
3944 case VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT:
3945 expectedMax = 5u;
3946 break;
3947
3948 case VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT:
3949 expectedMax = 15u;
3950 break;
3951
3952 case VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT:
3953 expectedMax = 2304u;
3954 break;
3955 default:
3956 DE_FATAL("Unexpected type of statistics query");
3957 break;
3958 }
3959 return expectedMax;
3960 }
3961
checkResult(VkQueryPool queryPool)3962 tcu::TestStatus VertexShaderMultipleQueryTestInstance::checkResult (VkQueryPool queryPool)
3963 {
3964 const DeviceInterface& vk = m_context.getDeviceInterface();
3965 const VkDevice device = m_context.getDevice();
3966 deUint32 queryCount = (m_parametersGraphic.queryCount + (m_parametersGraphic.dstOffset ? 1u : 0u));
3967 deUint32 size = NUM_QUERY_STATISTICS * queryCount;
3968 std::vector<deUint64> results;
3969 results.resize(size);
3970
3971 deBool hasPartialFlag = (deBool)(m_parametersGraphic.queryFlags & VK_QUERY_RESULT_PARTIAL_BIT);
3972 deBool hasWaitFlag = (deBool)(m_parametersGraphic.queryFlags & VK_QUERY_RESULT_WAIT_BIT);
3973 // Use the last value of each query to store the availability bit for the vertexOnlyPipe case.
3974 VkQueryResultFlags queryFlags = m_parametersGraphic.queryFlags;
3975
3976 if (m_parametersGraphic.copyType == COPY_TYPE_CMD)
3977 {
3978 const vk::Allocation& allocation = m_queryBuffer->getBoundMemory();
3979 const void* allocationData = allocation.getHostPtr();
3980
3981 vk::invalidateAlloc(m_context.getDeviceInterface(), m_context.getDevice(), allocation);
3982 deMemcpy(results.data(), allocationData, size * sizeof(deUint64));
3983 }
3984 else
3985 {
3986 VkResult result = vk.getQueryPoolResults(device, queryPool, 0u, m_parametersGraphic.queryCount, size * sizeof(deUint64), results.data(), NUM_QUERY_STATISTICS * sizeof(deUint64), queryFlags);
3987
3988 if (!(result == VK_SUCCESS || (!hasWaitFlag && result == VK_NOT_READY)))
3989 return tcu::TestStatus::fail("Unexpected getQueryPoolResults() returned value: " + de::toString(getResultStr(result)));
3990 }
3991
3992 for (deUint32 queryIdx = 0; queryIdx < queryCount; queryIdx++)
3993 {
3994 deInt32 queryMask = m_parametersGraphic.queryStatisticFlags;
3995 deUint32 index = queryIdx * NUM_QUERY_STATISTICS;
3996 // Last element of each query is the availability value for the vertexOnlyPipe case.
3997 deBool availableQuery = results[index + (NUM_QUERY_STATISTICS - 1)] != 0u;
3998
3999 // Check dstOffset values were not overwritten.
4000 if (m_parametersGraphic.dstOffset != 0u && queryIdx == 0u)
4001 {
4002 const deUint64 refVal = 0xfffffffffffffffful;
4003 for (; index < NUM_QUERY_STATISTICS; index++)
4004 {
4005 if (results[index] != refVal)
4006 return tcu::TestStatus::fail("dstOffset values were overwritten");
4007 }
4008 continue;
4009 }
4010
4011 if (hasWaitFlag && !hasPartialFlag && !availableQuery)
4012 return tcu::TestStatus::fail("Results should be available");
4013
4014 while(queryMask)
4015 {
4016 deInt32 statisticBit = deInt32BitScan(&queryMask);
4017 deUint64 expectedMin = calculateExpectedMin((1u << statisticBit));
4018 deUint64 expectedMax = calculateExpectedMax((1u << statisticBit));
4019
4020 if (availableQuery && (results[index] < expectedMin))
4021 return tcu::TestStatus::fail("QueryPoolResults incorrect: wrong value (" + de::toString(results[index]) + ") is lower than expected (" + de::toString(expectedMin) + ")");
4022
4023 /* From the spec:
4024 *
4025 * If VK_QUERY_RESULT_PARTIAL_BIT is set, VK_QUERY_RESULT_WAIT_BIT is not set,
4026 * and the query's status is unavailable, an intermediate result value between zero
4027 * and the final result value is written to pData for that query.
4028 */
4029 if (hasPartialFlag && !hasWaitFlag && !availableQuery && results[index] > expectedMax)
4030 return tcu::TestStatus::fail("QueryPoolResults incorrect: wrong partial value (" + de::toString(results[index]) + ") is greater than expected (" + de::toString(expectedMax) + ")");
4031
4032 index++;
4033 }
4034 }
4035
4036 return tcu::TestStatus::pass("Pass");
4037 }
4038
draw(VkCommandBuffer cmdBuffer)4039 void VertexShaderMultipleQueryTestInstance::draw (VkCommandBuffer cmdBuffer)
4040 {
4041 const DeviceInterface& vk = m_context.getDeviceInterface();
4042 vk.cmdDraw(cmdBuffer, 16u, 1u, 0u, 0u);
4043 }
4044
4045 template<class Instance>
4046 class QueryPoolGraphicMultipleQueryStatisticsTest : public TestCase
4047 {
4048 public:
QueryPoolGraphicMultipleQueryStatisticsTest(tcu::TestContext & context,const std::string & name,const std::string & description,const GraphicBasicMultipleQueryTestInstance::ParametersGraphic parametersGraphic)4049 QueryPoolGraphicMultipleQueryStatisticsTest (tcu::TestContext &context, const std::string& name, const std::string& description, const GraphicBasicMultipleQueryTestInstance::ParametersGraphic parametersGraphic)
4050 : TestCase (context, name.c_str(), description.c_str())
4051 , m_parametersGraphic (parametersGraphic)
4052 {
4053 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4(-1.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
4054 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4(-1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
4055 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
4056 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::red().toVec()));
4057
4058 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4(-1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
4059 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4(-1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
4060 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
4061 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::green().toVec()));
4062
4063 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
4064 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
4065 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 1.0f,-1.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
4066 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::blue().toVec()));
4067
4068 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
4069 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 0.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
4070 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 1.0f, 0.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
4071 m_data.push_back(GraphicBasicMultipleQueryTestInstance::VertexData(tcu::Vec4( 1.0f, 1.0f, 1.0f, 1.0f), tcu::RGBA::gray().toVec()));
4072 }
4073
createInstance(vkt::Context & context) const4074 vkt::TestInstance* createInstance (vkt::Context& context) const
4075 {
4076 return new Instance(context, m_data, m_parametersGraphic);
4077 }
4078
initPrograms(SourceCollections & sourceCollections) const4079 void initPrograms(SourceCollections& sourceCollections) const
4080 {
4081 { // Vertex Shader
4082 std::ostringstream source;
4083 source << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n"
4084 << "layout(location = 0) in highp vec4 in_position;\n"
4085 << "layout(location = 1) in vec4 in_color;\n"
4086 << "layout(location = 0) out vec4 out_color;\n"
4087 << "void main (void)\n"
4088 << "{\n"
4089 << " gl_PointSize = 1.0;\n"
4090 << " gl_Position = in_position;\n"
4091 << " out_color = in_color;\n"
4092 << "}\n";
4093 sourceCollections.glslSources.add("vertex") << glu::VertexSource(source.str());
4094 }
4095
4096 if (!m_parametersGraphic.vertexOnlyPipe)
4097 { // Fragment Shader
4098 std::ostringstream source;
4099 source << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450)<<"\n"
4100 << "layout(location = 0) in vec4 in_color;\n"
4101 << "layout(location = 0) out vec4 out_color;\n"
4102 << "void main()\n"
4103 <<"{\n"
4104 << " out_color = in_color;\n"
4105 << "}\n";
4106 sourceCollections.glslSources.add("fragment") << glu::FragmentSource(source.str());
4107 }
4108 }
4109 private:
4110 std::vector<GraphicBasicMultipleQueryTestInstance::VertexData> m_data;
4111 const GraphicBasicMultipleQueryTestInstance::ParametersGraphic m_parametersGraphic;
4112 };
4113
4114 } //anonymous
4115
QueryPoolStatisticsTests(tcu::TestContext & testCtx)4116 QueryPoolStatisticsTests::QueryPoolStatisticsTests (tcu::TestContext &testCtx)
4117 : TestCaseGroup(testCtx, "statistics_query", "Tests for statistics queries")
4118 {
4119 }
4120
bitPrefix(deBool query64bits,deBool dstOffset)4121 inline std::string bitPrefix(deBool query64bits, deBool dstOffset)
4122 {
4123 std::string prefix = (query64bits ? "64bits_" : "32bits_");
4124 prefix += (dstOffset ? "dstoffset_" : "");
4125 return prefix;
4126 }
4127
init(void)4128 void QueryPoolStatisticsTests::init (void)
4129 {
4130 std::string topology_name [VK_PRIMITIVE_TOPOLOGY_LAST] =
4131 {
4132 "point_list",
4133 "line_list",
4134 "line_strip",
4135 "triangle_list",
4136 "triangle_strip",
4137 "triangle_fan",
4138 "line_list_with_adjacency",
4139 "line_strip_with_adjacency",
4140 "triangle_list_with_adjacency",
4141 "triangle_strip_with_adjacency",
4142 "patch_list"
4143 };
4144
4145 std::vector<deUint64> sixRepeats = { 1, 3, 5, 8, 15, 24 };
4146 de::MovePtr<TestCaseGroup> computeShaderInvocationsGroup (new TestCaseGroup(m_testCtx, "compute_shader_invocations", "Query pipeline statistic compute shader invocations"));
4147 de::MovePtr<TestCaseGroup> inputAssemblyVertices (new TestCaseGroup(m_testCtx, "input_assembly_vertices", "Query pipeline statistic input assembly vertices"));
4148 de::MovePtr<TestCaseGroup> inputAssemblyPrimitives (new TestCaseGroup(m_testCtx, "input_assembly_primitives", "Query pipeline statistic input assembly primitives"));
4149 de::MovePtr<TestCaseGroup> vertexShaderInvocations (new TestCaseGroup(m_testCtx, "vertex_shader_invocations", "Query pipeline statistic vertex shader invocation"));
4150 de::MovePtr<TestCaseGroup> fragmentShaderInvocations (new TestCaseGroup(m_testCtx, "fragment_shader_invocations", "Query pipeline statistic fragment shader invocation"));
4151 de::MovePtr<TestCaseGroup> geometryShaderInvocations (new TestCaseGroup(m_testCtx, "geometry_shader_invocations", "Query pipeline statistic geometry shader invocation"));
4152 de::MovePtr<TestCaseGroup> geometryShaderPrimitives (new TestCaseGroup(m_testCtx, "geometry_shader_primitives", "Query pipeline statistic geometry shader primitives"));
4153 de::MovePtr<TestCaseGroup> clippingInvocations (new TestCaseGroup(m_testCtx, "clipping_invocations", "Query pipeline statistic clipping invocations"));
4154 de::MovePtr<TestCaseGroup> clippingPrimitives (new TestCaseGroup(m_testCtx, "clipping_primitives", "Query pipeline statistic clipping primitives"));
4155 de::MovePtr<TestCaseGroup> tesControlPatches (new TestCaseGroup(m_testCtx, "tes_control_patches", "Query pipeline statistic tessellation control shader patches"));
4156 de::MovePtr<TestCaseGroup> tesEvaluationShaderInvocations (new TestCaseGroup(m_testCtx, "tes_evaluation_shader_invocations", "Query pipeline statistic tessellation evaluation shader invocations"));
4157
4158 de::MovePtr<TestCaseGroup> vertexOnlyGroup (new TestCaseGroup(m_testCtx, "vertex_only", "Use only vertex shader in a graphics pipeline"));
4159 de::MovePtr<TestCaseGroup> inputAssemblyVerticesVertexOnly (new TestCaseGroup(m_testCtx, "input_assembly_vertices", "Query pipeline statistic input assembly vertices"));
4160 de::MovePtr<TestCaseGroup> inputAssemblyPrimitivesVertexOnly (new TestCaseGroup(m_testCtx, "input_assembly_primitives", "Query pipeline statistic input assembly primitives"));
4161 de::MovePtr<TestCaseGroup> vertexShaderInvocationsVertexOnly (new TestCaseGroup(m_testCtx, "vertex_shader_invocations", "Query pipeline statistic vertex shader invocation"));
4162
4163 de::MovePtr<TestCaseGroup> hostQueryResetGroup (new TestCaseGroup(m_testCtx, "host_query_reset", "Check host query reset pipeline statistic compute shader invocations"));
4164 de::MovePtr<TestCaseGroup> computeShaderInvocationsGroupHostQueryReset (new TestCaseGroup(m_testCtx, "compute_shader_invocations", "Query pipeline statistic compute shader invocations"));
4165 de::MovePtr<TestCaseGroup> inputAssemblyVerticesHostQueryReset (new TestCaseGroup(m_testCtx, "input_assembly_vertices", "Query pipeline statistic input assembly vertices"));
4166 de::MovePtr<TestCaseGroup> inputAssemblyPrimitivesHostQueryReset (new TestCaseGroup(m_testCtx, "input_assembly_primitives", "Query pipeline statistic input assembly primitives"));
4167 de::MovePtr<TestCaseGroup> vertexShaderInvocationsHostQueryReset (new TestCaseGroup(m_testCtx, "vertex_shader_invocations", "Query pipeline statistic vertex shader invocation"));
4168 de::MovePtr<TestCaseGroup> fragmentShaderInvocationsHostQueryReset (new TestCaseGroup(m_testCtx, "fragment_shader_invocations", "Query pipeline statistic fragment shader invocation"));
4169 de::MovePtr<TestCaseGroup> geometryShaderInvocationsHostQueryReset (new TestCaseGroup(m_testCtx, "geometry_shader_invocations", "Query pipeline statistic geometry shader invocation"));
4170 de::MovePtr<TestCaseGroup> geometryShaderPrimitivesHostQueryReset (new TestCaseGroup(m_testCtx, "geometry_shader_primitives", "Query pipeline statistic geometry shader primitives"));
4171 de::MovePtr<TestCaseGroup> clippingInvocationsHostQueryReset (new TestCaseGroup(m_testCtx, "clipping_invocations", "Query pipeline statistic clipping invocations"));
4172 de::MovePtr<TestCaseGroup> clippingPrimitivesHostQueryReset (new TestCaseGroup(m_testCtx, "clipping_primitives", "Query pipeline statistic clipping primitives"));
4173 de::MovePtr<TestCaseGroup> tesControlPatchesHostQueryReset (new TestCaseGroup(m_testCtx, "tes_control_patches", "Query pipeline statistic tessellation control shader patches"));
4174 de::MovePtr<TestCaseGroup> tesEvaluationShaderInvocationsHostQueryReset (new TestCaseGroup(m_testCtx, "tes_evaluation_shader_invocations", "Query pipeline statistic tessellation evaluation shader invocations"));
4175
4176 de::MovePtr<TestCaseGroup> resetBeforeCopyGroup (new TestCaseGroup(m_testCtx, "reset_before_copy", "Check pipeline statistic unavailability when resetting before copying"));
4177 de::MovePtr<TestCaseGroup> computeShaderInvocationsGroupResetBeforeCopy (new TestCaseGroup(m_testCtx, "compute_shader_invocations", "Query pipeline statistic compute shader invocations"));
4178 de::MovePtr<TestCaseGroup> inputAssemblyVerticesResetBeforeCopy (new TestCaseGroup(m_testCtx, "input_assembly_vertices", "Query pipeline statistic input assembly vertices"));
4179 de::MovePtr<TestCaseGroup> inputAssemblyPrimitivesResetBeforeCopy (new TestCaseGroup(m_testCtx, "input_assembly_primitives", "Query pipeline statistic input assembly primitives"));
4180 de::MovePtr<TestCaseGroup> vertexShaderInvocationsResetBeforeCopy (new TestCaseGroup(m_testCtx, "vertex_shader_invocations", "Query pipeline statistic vertex shader invocation"));
4181 de::MovePtr<TestCaseGroup> fragmentShaderInvocationsResetBeforeCopy (new TestCaseGroup(m_testCtx, "fragment_shader_invocations", "Query pipeline statistic fragment shader invocation"));
4182 de::MovePtr<TestCaseGroup> geometryShaderInvocationsResetBeforeCopy (new TestCaseGroup(m_testCtx, "geometry_shader_invocations", "Query pipeline statistic geometry shader invocation"));
4183 de::MovePtr<TestCaseGroup> geometryShaderPrimitivesResetBeforeCopy (new TestCaseGroup(m_testCtx, "geometry_shader_primitives", "Query pipeline statistic geometry shader primitives"));
4184 de::MovePtr<TestCaseGroup> clippingInvocationsResetBeforeCopy (new TestCaseGroup(m_testCtx, "clipping_invocations", "Query pipeline statistic clipping invocations"));
4185 de::MovePtr<TestCaseGroup> clippingPrimitivesResetBeforeCopy (new TestCaseGroup(m_testCtx, "clipping_primitives", "Query pipeline statistic clipping primitives"));
4186 de::MovePtr<TestCaseGroup> tesControlPatchesResetBeforeCopy (new TestCaseGroup(m_testCtx, "tes_control_patches", "Query pipeline statistic tessellation control shader patches"));
4187 de::MovePtr<TestCaseGroup> tesEvaluationShaderInvocationsResetBeforeCopy (new TestCaseGroup(m_testCtx, "tes_evaluation_shader_invocations", "Query pipeline statistic tessellation evaluation shader invocations"));
4188
4189 de::MovePtr<TestCaseGroup> resetAfterCopyGroup (new TestCaseGroup(m_testCtx, "reset_after_copy", "Check pipeline statistic are not affected when resetting after copying"));
4190 de::MovePtr<TestCaseGroup> computeShaderInvocationsGroupResetAfterCopy (new TestCaseGroup(m_testCtx, "compute_shader_invocations", "Query pipeline statistic compute shader invocations"));
4191 de::MovePtr<TestCaseGroup> inputAssemblyVerticesResetAfterCopy (new TestCaseGroup(m_testCtx, "input_assembly_vertices", "Query pipeline statistic input assembly vertices"));
4192 de::MovePtr<TestCaseGroup> inputAssemblyPrimitivesResetAfterCopy (new TestCaseGroup(m_testCtx, "input_assembly_primitives", "Query pipeline statistic input assembly primitives"));
4193 de::MovePtr<TestCaseGroup> vertexShaderInvocationsResetAfterCopy (new TestCaseGroup(m_testCtx, "vertex_shader_invocations", "Query pipeline statistic vertex shader invocation"));
4194 de::MovePtr<TestCaseGroup> fragmentShaderInvocationsResetAfterCopy (new TestCaseGroup(m_testCtx, "fragment_shader_invocations", "Query pipeline statistic fragment shader invocation"));
4195 de::MovePtr<TestCaseGroup> geometryShaderInvocationsResetAfterCopy (new TestCaseGroup(m_testCtx, "geometry_shader_invocations", "Query pipeline statistic geometry shader invocation"));
4196 de::MovePtr<TestCaseGroup> geometryShaderPrimitivesResetAfterCopy (new TestCaseGroup(m_testCtx, "geometry_shader_primitives", "Query pipeline statistic geometry shader primitives"));
4197 de::MovePtr<TestCaseGroup> clippingInvocationsResetAfterCopy (new TestCaseGroup(m_testCtx, "clipping_invocations", "Query pipeline statistic clipping invocations"));
4198 de::MovePtr<TestCaseGroup> clippingPrimitivesResetAfterCopy (new TestCaseGroup(m_testCtx, "clipping_primitives", "Query pipeline statistic clipping primitives"));
4199 de::MovePtr<TestCaseGroup> tesControlPatchesResetAfterCopy (new TestCaseGroup(m_testCtx, "tes_control_patches", "Query pipeline statistic tessellation control shader patches"));
4200 de::MovePtr<TestCaseGroup> tesEvaluationShaderInvocationsResetAfterCopy (new TestCaseGroup(m_testCtx, "tes_evaluation_shader_invocations", "Query pipeline statistic tessellation evaluation shader invocations"));
4201
4202 de::MovePtr<TestCaseGroup> vertexShaderMultipleQueries (new TestCaseGroup(m_testCtx, "multiple_queries", "Query pipeline statistics related to vertex and fragment shaders"));
4203
4204 CopyType copyType[] = { COPY_TYPE_GET, COPY_TYPE_CMD };
4205 std::string copyTypeStr[] = { "", "cmdcopyquerypoolresults_" };
4206
4207 StrideType strideType[] = { STRIDE_TYPE_VALID, STRIDE_TYPE_ZERO };
4208 std::string strideTypeStr[] = { "", "stride_zero_" };
4209
4210 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4211 {
4212 for (deUint32 i = 0; i < 4; ++i)
4213 {
4214 deBool query64Bits = (i & 1);
4215 deBool dstOffset = (i & 2);
4216 std::string prefix = bitPrefix(query64Bits, dstOffset);
4217
4218 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4219 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4220 continue;
4221
4222 for (deUint32 strideTypeIdx = 0; strideTypeIdx < DE_LENGTH_OF_ARRAY(strideType); strideTypeIdx++)
4223 {
4224 if (strideType[strideTypeIdx] == STRIDE_TYPE_ZERO && copyType[copyTypeIdx] != COPY_TYPE_CMD)
4225 continue;
4226
4227 computeShaderInvocationsGroup->addChild(new QueryPoolStatisticsTest<ComputeInvocationsTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + strideTypeStr[strideTypeIdx] + "primary", "", RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, dstOffset, strideType[strideTypeIdx]));
4228 computeShaderInvocationsGroup->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + strideTypeStr[strideTypeIdx] + "secondary", "", RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, dstOffset, strideType[strideTypeIdx]));
4229 computeShaderInvocationsGroup->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + strideTypeStr[strideTypeIdx] + "secondary_inherited", "", RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, dstOffset, strideType[strideTypeIdx]));
4230 }
4231
4232 computeShaderInvocationsGroupHostQueryReset->addChild(new QueryPoolStatisticsTest<ComputeInvocationsTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary", "", RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, dstOffset));
4233 computeShaderInvocationsGroupHostQueryReset->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary", "", RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, dstOffset));
4234 computeShaderInvocationsGroupHostQueryReset->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, dstOffset));
4235
4236 computeShaderInvocationsGroupResetBeforeCopy->addChild(new QueryPoolStatisticsTest<ComputeInvocationsTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary", "", RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, dstOffset));
4237 computeShaderInvocationsGroupResetBeforeCopy->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary", "", RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, dstOffset));
4238 computeShaderInvocationsGroupResetBeforeCopy->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryInheritedTestInstance>(m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, dstOffset));
4239
4240 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4241 {
4242 computeShaderInvocationsGroupResetAfterCopy->addChild(new QueryPoolStatisticsTest<ComputeInvocationsTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary", "", RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, dstOffset));
4243 computeShaderInvocationsGroupResetAfterCopy->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary", "", RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, dstOffset));
4244 computeShaderInvocationsGroupResetAfterCopy->addChild(new QueryPoolStatisticsTest<ComputeInvocationsSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, dstOffset));
4245 }
4246
4247 //VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT
4248
4249 // Tests with no attachments for only primary command to reduce # of test cases.
4250 inputAssemblyVertices->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4251 inputAssemblyVerticesVertexOnly->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4252 inputAssemblyVerticesHostQueryReset->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4253 inputAssemblyVerticesResetBeforeCopy->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4254
4255 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4256 inputAssemblyVerticesResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4257
4258 /* Tests for clear operation within a statistics query activated.
4259 * The query shouldn't count internal driver operations relevant to the clear operations.
4260 */
4261 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4262 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4263
4264 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4265 inputAssemblyVertices->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4266 inputAssemblyVertices->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4267
4268 inputAssemblyVerticesVertexOnly->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4269 inputAssemblyVerticesVertexOnly->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4270
4271 inputAssemblyVerticesHostQueryReset->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4272 inputAssemblyVerticesHostQueryReset->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4273
4274 inputAssemblyVerticesResetBeforeCopy->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4275 inputAssemblyVerticesResetBeforeCopy->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4276
4277 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4278 {
4279 inputAssemblyVerticesResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "primary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4280 inputAssemblyVerticesResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4281 }
4282 }
4283
4284 inputAssemblyVertices->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4285
4286 inputAssemblyVerticesVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset), sixRepeats));
4287
4288 inputAssemblyVerticesHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance>(m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4289
4290 inputAssemblyVerticesResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4291
4292 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4293 inputAssemblyVerticesResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4294 }
4295 }
4296
4297 //VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT
4298 {
4299 de::MovePtr<TestCaseGroup> primary (new TestCaseGroup(m_testCtx, "primary", ""));
4300 de::MovePtr<TestCaseGroup> secondary (new TestCaseGroup(m_testCtx, "secondary", ""));
4301 de::MovePtr<TestCaseGroup> secondaryInherited (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4302
4303 de::MovePtr<TestCaseGroup> primaryVertexOnly (new TestCaseGroup(m_testCtx, "primary", ""));
4304 de::MovePtr<TestCaseGroup> secondaryVertexOnly (new TestCaseGroup(m_testCtx, "secondary", ""));
4305 de::MovePtr<TestCaseGroup> secondaryInheritedVertexOnly (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4306
4307 de::MovePtr<TestCaseGroup> primaryHostQueryReset (new TestCaseGroup(m_testCtx, "primary", ""));
4308 de::MovePtr<TestCaseGroup> secondaryHostQueryReset (new TestCaseGroup(m_testCtx, "secondary", ""));
4309 de::MovePtr<TestCaseGroup> secondaryInheritedHostQueryReset (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4310
4311 de::MovePtr<TestCaseGroup> primaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4312 de::MovePtr<TestCaseGroup> secondaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4313 de::MovePtr<TestCaseGroup> secondaryInheritedResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4314
4315 de::MovePtr<TestCaseGroup> primaryResetAfterCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4316 de::MovePtr<TestCaseGroup> secondaryResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4317 de::MovePtr<TestCaseGroup> secondaryInheritedResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4318
4319 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4320 {
4321 for (int topologyNdx = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; topologyNdx < VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; ++topologyNdx)
4322 {
4323 for (deUint32 i = 0; i < 4; ++i)
4324 {
4325 deBool query64Bits = (i & 1);
4326 deBool dstOffset = (i & 2);
4327 std::string prefix = bitPrefix(query64Bits, dstOffset);
4328
4329 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4330 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4331 continue;
4332
4333 // Tests with no attachments for only primary command to reduce # of test cases.
4334 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4335
4336 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4337
4338 primaryVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4339
4340 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4341
4342 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4343 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4344
4345 /* Tests for clear operation within a statistics query activated.
4346 * Nothing for secondary_inherited cases can be done since it violates the specification.
4347 *
4348 * The query shouldn't count internal driver operations relevant to the clear operations.
4349 */
4350 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4351 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4352
4353 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4354 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4355 secondary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4356
4357 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4358 secondaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4359
4360 primaryVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4361 secondaryVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4362
4363 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4364 secondaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4365
4366 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4367 {
4368 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4369 secondaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4370 }
4371 }
4372
4373 secondaryInherited->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4374 secondaryInheritedHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4375 secondaryInheritedVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset), sixRepeats));
4376 secondaryInheritedResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4377 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4378 secondaryInheritedResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4379 }
4380 }
4381 }
4382
4383 inputAssemblyPrimitives->addChild(primary.release());
4384 inputAssemblyPrimitives->addChild(secondary.release());
4385 inputAssemblyPrimitives->addChild(secondaryInherited.release());
4386
4387 inputAssemblyPrimitivesVertexOnly->addChild(primaryVertexOnly.release());
4388 inputAssemblyPrimitivesVertexOnly->addChild(secondaryVertexOnly.release());
4389 inputAssemblyPrimitivesVertexOnly->addChild(secondaryInheritedVertexOnly.release());
4390
4391 inputAssemblyPrimitivesHostQueryReset->addChild(primaryHostQueryReset.release());
4392 inputAssemblyPrimitivesHostQueryReset->addChild(secondaryHostQueryReset.release());
4393 inputAssemblyPrimitivesHostQueryReset->addChild(secondaryInheritedHostQueryReset.release());
4394
4395 inputAssemblyPrimitivesResetBeforeCopy->addChild(primaryResetBeforeCopy.release());
4396 inputAssemblyPrimitivesResetBeforeCopy->addChild(secondaryResetBeforeCopy.release());
4397 inputAssemblyPrimitivesResetBeforeCopy->addChild(secondaryInheritedResetBeforeCopy.release());
4398
4399 inputAssemblyPrimitivesResetAfterCopy->addChild(primaryResetAfterCopy.release());
4400 inputAssemblyPrimitivesResetAfterCopy->addChild(secondaryResetAfterCopy.release());
4401 inputAssemblyPrimitivesResetAfterCopy->addChild(secondaryInheritedResetAfterCopy.release());
4402 }
4403
4404 //VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT
4405 {
4406 de::MovePtr<TestCaseGroup> primary (new TestCaseGroup(m_testCtx, "primary", ""));
4407 de::MovePtr<TestCaseGroup> secondary (new TestCaseGroup(m_testCtx, "secondary", ""));
4408 de::MovePtr<TestCaseGroup> secondaryInherited (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4409
4410 de::MovePtr<TestCaseGroup> primaryVertexOnly (new TestCaseGroup(m_testCtx, "primary", ""));
4411 de::MovePtr<TestCaseGroup> secondaryVertexOnly (new TestCaseGroup(m_testCtx, "secondary", ""));
4412 de::MovePtr<TestCaseGroup> secondaryInheritedVertexOnly (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4413
4414 de::MovePtr<TestCaseGroup> primaryHostQueryReset (new TestCaseGroup(m_testCtx, "primary", ""));
4415 de::MovePtr<TestCaseGroup> secondaryHostQueryReset (new TestCaseGroup(m_testCtx, "secondary", ""));
4416 de::MovePtr<TestCaseGroup> secondaryInheritedHostQueryReset (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4417
4418 de::MovePtr<TestCaseGroup> primaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4419 de::MovePtr<TestCaseGroup> secondaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4420 de::MovePtr<TestCaseGroup> secondaryInheritedResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4421
4422 de::MovePtr<TestCaseGroup> primaryResetAfterCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4423 de::MovePtr<TestCaseGroup> secondaryResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4424 de::MovePtr<TestCaseGroup> secondaryInheritedResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4425
4426 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4427 {
4428 for (int topologyNdx = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; topologyNdx < VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; ++topologyNdx)
4429 {
4430 for (deUint32 i = 0; i < 4; ++i)
4431 {
4432 deBool query64Bits = (i & 1);
4433 deBool dstOffset = (i & 2);
4434 std::string prefix = bitPrefix(query64Bits, dstOffset);
4435
4436 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4437 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4438 continue;
4439
4440 // Tests with no attachments for only primary command to reduce # of test cases.
4441 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4442
4443 primaryVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4444
4445 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4446
4447 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4448
4449 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4450 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4451
4452 /* Tests for clear operation within a statistics query activated.
4453 * Nothing for secondary_inherited cases can be done since it violates the specification.
4454 *
4455 * The query shouldn't count internal driver operations relevant to the clear operations.
4456 */
4457 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4458 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4459
4460 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4461 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4462 secondary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4463
4464 primaryVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4465 secondaryVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4466
4467 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4468 secondaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4469
4470 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4471 secondaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4472
4473 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4474 {
4475 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4476 secondaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4477 }
4478 }
4479
4480 secondaryInherited->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4481 secondaryInheritedVertexOnly->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_TRUE, dstOffset), sixRepeats));
4482 secondaryInheritedHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4483 secondaryInheritedResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4484 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4485 secondaryInheritedResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4486 }
4487 }
4488 }
4489
4490 vertexShaderInvocations->addChild(primary.release());
4491 vertexShaderInvocations->addChild(secondary.release());
4492 vertexShaderInvocations->addChild(secondaryInherited.release());
4493
4494 vertexShaderInvocationsVertexOnly->addChild(primaryVertexOnly.release());
4495 vertexShaderInvocationsVertexOnly->addChild(secondaryVertexOnly.release());
4496 vertexShaderInvocationsVertexOnly->addChild(secondaryInheritedVertexOnly.release());
4497
4498 vertexShaderInvocationsHostQueryReset->addChild(primaryHostQueryReset.release());
4499 vertexShaderInvocationsHostQueryReset->addChild(secondaryHostQueryReset.release());
4500 vertexShaderInvocationsHostQueryReset->addChild(secondaryInheritedHostQueryReset.release());
4501
4502 vertexShaderInvocationsResetBeforeCopy->addChild(primaryResetBeforeCopy.release());
4503 vertexShaderInvocationsResetBeforeCopy->addChild(secondaryResetBeforeCopy.release());
4504 vertexShaderInvocationsResetBeforeCopy->addChild(secondaryInheritedResetBeforeCopy.release());
4505
4506 vertexShaderInvocationsResetAfterCopy->addChild(primaryResetAfterCopy.release());
4507 vertexShaderInvocationsResetAfterCopy->addChild(secondaryResetAfterCopy.release());
4508 vertexShaderInvocationsResetAfterCopy->addChild(secondaryInheritedResetAfterCopy.release());
4509 }
4510
4511 //VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT
4512 {
4513 de::MovePtr<TestCaseGroup> primary (new TestCaseGroup(m_testCtx, "primary", ""));
4514 de::MovePtr<TestCaseGroup> secondary (new TestCaseGroup(m_testCtx, "secondary", ""));
4515 de::MovePtr<TestCaseGroup> secondaryInherited (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4516
4517 de::MovePtr<TestCaseGroup> primaryHostQueryReset (new TestCaseGroup(m_testCtx, "primary", ""));
4518 de::MovePtr<TestCaseGroup> secondaryHostQueryReset (new TestCaseGroup(m_testCtx, "secondary", ""));
4519 de::MovePtr<TestCaseGroup> secondaryInheritedHostQueryReset (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4520
4521 de::MovePtr<TestCaseGroup> primaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4522 de::MovePtr<TestCaseGroup> secondaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4523 de::MovePtr<TestCaseGroup> secondaryInheritedResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4524
4525 de::MovePtr<TestCaseGroup> primaryResetAfterCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4526 de::MovePtr<TestCaseGroup> secondaryResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4527 de::MovePtr<TestCaseGroup> secondaryInheritedResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4528
4529 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4530 {
4531 for (int topologyNdx = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; topologyNdx < VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; ++topologyNdx)
4532 {
4533 for (deUint32 i = 0; i < 4; ++i)
4534 {
4535 deBool query64Bits = (i & 1);
4536 deBool dstOffset = (i & 2);
4537 std::string prefix = bitPrefix(query64Bits, dstOffset);
4538
4539 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4540 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4541 continue;
4542
4543 // Tests with no attachments for only primary command to reduce # of test cases.
4544 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4545
4546 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4547
4548 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4549
4550 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4551 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4552
4553 /* Tests for clear operation within a statistics query activated.
4554 * Nothing for secondary_inherited cases can be done since it violates the specification.
4555 *
4556 * The query shouldn't count internal driver operations relevant to the clear operations.
4557 */
4558 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4559 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4560
4561 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4562 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4563 secondary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4564
4565 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4566 secondaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4567
4568 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4569 secondaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4570
4571 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4572 {
4573 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4574 secondaryResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4575 }
4576 }
4577
4578 secondaryInherited->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4579 secondaryInheritedHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4580 secondaryInheritedResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4581 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4582 secondaryInheritedResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4583 }
4584 }
4585 }
4586
4587 fragmentShaderInvocations->addChild(primary.release());
4588 fragmentShaderInvocations->addChild(secondary.release());
4589 fragmentShaderInvocations->addChild(secondaryInherited.release());
4590
4591 fragmentShaderInvocationsHostQueryReset->addChild(primaryHostQueryReset.release());
4592 fragmentShaderInvocationsHostQueryReset->addChild(secondaryHostQueryReset.release());
4593 fragmentShaderInvocationsHostQueryReset->addChild(secondaryInheritedHostQueryReset.release());
4594
4595 fragmentShaderInvocationsResetBeforeCopy->addChild(primaryResetBeforeCopy.release());
4596 fragmentShaderInvocationsResetBeforeCopy->addChild(secondaryResetBeforeCopy.release());
4597 fragmentShaderInvocationsResetBeforeCopy->addChild(secondaryInheritedResetBeforeCopy.release());
4598
4599 fragmentShaderInvocationsResetAfterCopy->addChild(primaryResetAfterCopy.release());
4600 fragmentShaderInvocationsResetAfterCopy->addChild(secondaryResetAfterCopy.release());
4601 fragmentShaderInvocationsResetAfterCopy->addChild(secondaryInheritedResetAfterCopy.release());
4602 }
4603
4604 //VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT
4605 {
4606 de::MovePtr<TestCaseGroup> primary (new TestCaseGroup(m_testCtx, "primary", ""));
4607 de::MovePtr<TestCaseGroup> secondary (new TestCaseGroup(m_testCtx, "secondary", ""));
4608 de::MovePtr<TestCaseGroup> secondaryInherited (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4609
4610 de::MovePtr<TestCaseGroup> primaryHostQueryReset (new TestCaseGroup(m_testCtx, "primary", ""));
4611 de::MovePtr<TestCaseGroup> secondaryHostQueryReset (new TestCaseGroup(m_testCtx, "secondary", ""));
4612 de::MovePtr<TestCaseGroup> secondaryInheritedHostQueryReset (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4613
4614 de::MovePtr<TestCaseGroup> primaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4615 de::MovePtr<TestCaseGroup> secondaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4616 de::MovePtr<TestCaseGroup> secondaryInheritedResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4617
4618 de::MovePtr<TestCaseGroup> primaryResetAfterCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4619 de::MovePtr<TestCaseGroup> secondaryResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4620 de::MovePtr<TestCaseGroup> secondaryInheritedResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4621
4622 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4623 {
4624 for (int topologyNdx = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; topologyNdx < VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; ++topologyNdx)
4625 {
4626 for (deUint32 i = 0; i < 4; ++i)
4627 {
4628 deBool query64Bits = (i & 1);
4629 deBool dstOffset = (i & 2);
4630 std::string prefix = bitPrefix(query64Bits, dstOffset);
4631
4632 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4633 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4634 continue;
4635
4636 // Tests with no attachments for only primary command to reduce # of test cases.
4637 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4638
4639 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4640
4641 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4642
4643 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4644 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4645
4646 /* Tests for clear operation within a statistics query activated.
4647 * Nothing for secondary_inherited cases can be done since it violates the specification.
4648 *
4649 * The query shouldn't count internal driver operations relevant to the clear operations.
4650 */
4651 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4652 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4653
4654 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4655 primary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4656 secondary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4657
4658 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4659 secondaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4660
4661 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4662 secondaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4663
4664 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4665 {
4666 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4667 secondaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4668 }
4669 }
4670
4671 secondaryInherited->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4672 secondaryInheritedHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4673 secondaryInheritedResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4674 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4675 secondaryInheritedResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4676 }
4677 }
4678 }
4679
4680 geometryShaderInvocations->addChild(primary.release());
4681 geometryShaderInvocations->addChild(secondary.release());
4682 geometryShaderInvocations->addChild(secondaryInherited.release());
4683
4684 geometryShaderInvocationsHostQueryReset->addChild(primaryHostQueryReset.release());
4685 geometryShaderInvocationsHostQueryReset->addChild(secondaryHostQueryReset.release());
4686 geometryShaderInvocationsHostQueryReset->addChild(secondaryInheritedHostQueryReset.release());
4687
4688 geometryShaderInvocationsResetBeforeCopy->addChild(primaryResetBeforeCopy.release());
4689 geometryShaderInvocationsResetBeforeCopy->addChild(secondaryResetBeforeCopy.release());
4690 geometryShaderInvocationsResetBeforeCopy->addChild(secondaryInheritedResetBeforeCopy.release());
4691
4692 geometryShaderInvocationsResetAfterCopy->addChild(primaryResetAfterCopy.release());
4693 geometryShaderInvocationsResetAfterCopy->addChild(secondaryResetAfterCopy.release());
4694 geometryShaderInvocationsResetAfterCopy->addChild(secondaryInheritedResetAfterCopy.release());
4695 }
4696
4697 //VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT
4698 {
4699 de::MovePtr<TestCaseGroup> primary (new TestCaseGroup(m_testCtx, "primary", ""));
4700 de::MovePtr<TestCaseGroup> secondary (new TestCaseGroup(m_testCtx, "secondary", ""));
4701 de::MovePtr<TestCaseGroup> secondaryInherited (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4702
4703 de::MovePtr<TestCaseGroup> primaryHostQueryReset (new TestCaseGroup(m_testCtx, "primary", ""));
4704 de::MovePtr<TestCaseGroup> secondaryHostQueryReset (new TestCaseGroup(m_testCtx, "secondary", ""));
4705 de::MovePtr<TestCaseGroup> secondaryInheritedHostQueryReset (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4706
4707 de::MovePtr<TestCaseGroup> primaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4708 de::MovePtr<TestCaseGroup> secondaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4709 de::MovePtr<TestCaseGroup> secondaryInheritedResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4710
4711 de::MovePtr<TestCaseGroup> primaryResetAfterCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4712 de::MovePtr<TestCaseGroup> secondaryResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4713 de::MovePtr<TestCaseGroup> secondaryInheritedResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4714
4715 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4716 {
4717 for (int topologyNdx = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; topologyNdx < VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; ++topologyNdx)
4718 {
4719 for (deUint32 i = 0; i < 4; ++i)
4720 {
4721 deBool query64Bits = (i & 1);
4722 deBool dstOffset = (i & 2);
4723 std::string prefix = bitPrefix(query64Bits, dstOffset);
4724
4725 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4726 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4727 continue;
4728
4729 // Tests with no attachments.
4730 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4731
4732 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4733
4734 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4735
4736 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4737 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4738
4739 /* Tests for clear operation within a statistics query activated.
4740 * Nothing for secondary_inherited cases can be done since it violates the specification.
4741 *
4742 * The query shouldn't count internal driver operations relevant to the clear operations.
4743 */
4744 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4745 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4746
4747 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4748 primary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4749 secondary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4750
4751 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4752 secondaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4753
4754 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4755 secondaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4756
4757 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4758 {
4759 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4760 secondaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4761 }
4762 }
4763 secondaryInherited->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4764 secondaryInheritedHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4765 secondaryInheritedResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4766 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4767 secondaryInheritedResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4768 }
4769 }
4770 }
4771
4772 geometryShaderPrimitives->addChild(primary.release());
4773 geometryShaderPrimitives->addChild(secondary.release());
4774 geometryShaderPrimitives->addChild(secondaryInherited.release());
4775
4776 geometryShaderPrimitivesHostQueryReset->addChild(primaryHostQueryReset.release());
4777 geometryShaderPrimitivesHostQueryReset->addChild(secondaryHostQueryReset.release());
4778 geometryShaderPrimitivesHostQueryReset->addChild(secondaryInheritedHostQueryReset.release());
4779
4780 geometryShaderPrimitivesResetBeforeCopy->addChild(primaryResetBeforeCopy.release());
4781 geometryShaderPrimitivesResetBeforeCopy->addChild(secondaryResetBeforeCopy.release());
4782 geometryShaderPrimitivesResetBeforeCopy->addChild(secondaryInheritedResetBeforeCopy.release());
4783
4784 geometryShaderPrimitivesResetAfterCopy->addChild(primaryResetAfterCopy.release());
4785 geometryShaderPrimitivesResetAfterCopy->addChild(secondaryResetAfterCopy.release());
4786 geometryShaderPrimitivesResetAfterCopy->addChild(secondaryInheritedResetAfterCopy.release());
4787 }
4788
4789 //VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT
4790 {
4791 de::MovePtr<TestCaseGroup> primary (new TestCaseGroup(m_testCtx, "primary", ""));
4792 de::MovePtr<TestCaseGroup> secondary (new TestCaseGroup(m_testCtx, "secondary", ""));
4793 de::MovePtr<TestCaseGroup> secondaryInherited (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4794
4795 de::MovePtr<TestCaseGroup> primaryHostQueryReset (new TestCaseGroup(m_testCtx, "primary", ""));
4796 de::MovePtr<TestCaseGroup> secondaryHostQueryReset (new TestCaseGroup(m_testCtx, "secondary", ""));
4797 de::MovePtr<TestCaseGroup> secondaryInheritedHostQueryReset (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4798
4799 de::MovePtr<TestCaseGroup> primaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4800 de::MovePtr<TestCaseGroup> secondaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4801 de::MovePtr<TestCaseGroup> secondaryInheritedResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4802
4803 de::MovePtr<TestCaseGroup> primaryResetAfterCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4804 de::MovePtr<TestCaseGroup> secondaryResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4805 de::MovePtr<TestCaseGroup> secondaryInheritedResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4806
4807 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4808 {
4809 for (int topologyNdx = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; topologyNdx < VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; ++topologyNdx)
4810 {
4811 for (deUint32 i = 0; i < 4; ++i)
4812 {
4813 deBool query64Bits = (i & 1);
4814 deBool dstOffset = (i & 2);
4815 std::string prefix = bitPrefix(query64Bits, dstOffset);
4816
4817 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4818 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4819 continue;
4820
4821 // Tests with no attachments for only primary command to reduce # of test cases.
4822 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4823
4824 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4825
4826 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4827
4828 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4829 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4830
4831 /* Tests for clear operation within a statistics query activated.
4832 * Nothing for secondary_inherited cases can be done since it violates the specification.
4833 *
4834 * The query shouldn't count internal driver operations relevant to the clear operations.
4835 */
4836 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4837 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4838
4839 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4840 primary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4841 secondary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4842
4843 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4844 secondaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4845
4846 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4847 secondaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4848
4849 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4850 {
4851 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4852 secondaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4853 }
4854 }
4855
4856 secondaryInherited->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4857 secondaryInheritedHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4858 secondaryInheritedResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4859 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4860 secondaryInheritedResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4861 }
4862 }
4863 }
4864
4865 clippingInvocations->addChild(primary.release());
4866 clippingInvocations->addChild(secondary.release());
4867 clippingInvocations->addChild(secondaryInherited.release());
4868
4869 clippingInvocationsHostQueryReset->addChild(primaryHostQueryReset.release());
4870 clippingInvocationsHostQueryReset->addChild(secondaryHostQueryReset.release());
4871 clippingInvocationsHostQueryReset->addChild(secondaryInheritedHostQueryReset.release());
4872
4873 clippingInvocationsResetBeforeCopy->addChild(primaryResetBeforeCopy.release());
4874 clippingInvocationsResetBeforeCopy->addChild(secondaryResetBeforeCopy.release());
4875 clippingInvocationsResetBeforeCopy->addChild(secondaryInheritedResetBeforeCopy.release());
4876
4877 clippingInvocationsResetAfterCopy->addChild(primaryResetAfterCopy.release());
4878 clippingInvocationsResetAfterCopy->addChild(secondaryResetAfterCopy.release());
4879 clippingInvocationsResetAfterCopy->addChild(secondaryInheritedResetAfterCopy.release());
4880 }
4881
4882 //VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT
4883 {
4884 de::MovePtr<TestCaseGroup> primary (new TestCaseGroup(m_testCtx, "primary", ""));
4885 de::MovePtr<TestCaseGroup> secondary (new TestCaseGroup(m_testCtx, "secondary", ""));
4886 de::MovePtr<TestCaseGroup> secondaryInherited (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4887
4888 de::MovePtr<TestCaseGroup> primaryHostQueryReset (new TestCaseGroup(m_testCtx, "primary", ""));
4889 de::MovePtr<TestCaseGroup> secondaryHostQueryReset (new TestCaseGroup(m_testCtx, "secondary", ""));
4890 de::MovePtr<TestCaseGroup> secondaryInheritedHostQueryReset (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4891
4892 de::MovePtr<TestCaseGroup> primaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4893 de::MovePtr<TestCaseGroup> secondaryResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4894 de::MovePtr<TestCaseGroup> secondaryInheritedResetBeforeCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4895
4896 de::MovePtr<TestCaseGroup> primaryResetAfterCopy (new TestCaseGroup(m_testCtx, "primary", ""));
4897 de::MovePtr<TestCaseGroup> secondaryResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary", ""));
4898 de::MovePtr<TestCaseGroup> secondaryInheritedResetAfterCopy (new TestCaseGroup(m_testCtx, "secondary_inherited",""));
4899
4900 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4901 {
4902 for (int topologyNdx = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; topologyNdx < VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; ++topologyNdx)
4903 {
4904 for (deUint32 i = 0; i < 4; ++i)
4905 {
4906 deBool query64Bits = (i & 1);
4907 deBool dstOffset = (i & 2);
4908 std::string prefix = bitPrefix(query64Bits, dstOffset);
4909
4910 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4911 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4912 continue;
4913
4914 // Tests with no attachments for only primary command to reduce # of test cases.
4915 primary->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4916
4917 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4918
4919 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4920
4921 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4922 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<VertexShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + "with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4923
4924 /* Tests for clear operation within a statistics query activated.
4925 * Nothing for secondary_inherited cases can be done since it violates the specification.
4926 *
4927 * The query shouldn't count internal driver operations relevant to the clear operations.
4928 */
4929 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
4930 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
4931
4932 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
4933 primary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4934 secondary->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4935
4936 primaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4937 secondaryHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4938
4939 primaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4940 secondaryResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4941
4942 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4943 {
4944 primaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4945 secondaryResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx] + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
4946 }
4947 }
4948
4949 secondaryInherited->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4950 secondaryInheritedHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4951 secondaryInheritedResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4952 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4953 secondaryInheritedResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<GeometryShaderSecondaryInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + topology_name[topologyNdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, (VkPrimitiveTopology)topologyNdx, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
4954 }
4955 }
4956 }
4957
4958 clippingPrimitives->addChild(primary.release());
4959 clippingPrimitives->addChild(secondary.release());
4960 clippingPrimitives->addChild(secondaryInherited.release());
4961
4962 clippingPrimitivesHostQueryReset->addChild(primaryHostQueryReset.release());
4963 clippingPrimitivesHostQueryReset->addChild(secondaryHostQueryReset.release());
4964 clippingPrimitivesHostQueryReset->addChild(secondaryInheritedHostQueryReset.release());
4965
4966 clippingPrimitivesResetBeforeCopy->addChild(primaryResetBeforeCopy.release());
4967 clippingPrimitivesResetBeforeCopy->addChild(secondaryResetBeforeCopy.release());
4968 clippingPrimitivesResetBeforeCopy->addChild(secondaryInheritedResetBeforeCopy.release());
4969
4970 clippingPrimitivesResetAfterCopy->addChild(primaryResetAfterCopy.release());
4971 clippingPrimitivesResetAfterCopy->addChild(secondaryResetAfterCopy.release());
4972 clippingPrimitivesResetAfterCopy->addChild(secondaryInheritedResetAfterCopy.release());
4973 }
4974
4975 //VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT
4976 //VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT
4977 for (deUint32 copyTypeIdx = 0; copyTypeIdx < DE_LENGTH_OF_ARRAY(copyType); copyTypeIdx++)
4978 {
4979 for (deUint32 i = 0; i < 4; ++i)
4980 {
4981 deBool query64Bits = (i & 1);
4982 deBool dstOffset = (i & 2);
4983 std::string prefix = bitPrefix(query64Bits, dstOffset);
4984
4985 // It makes no sense to use dstOffset with vkGetQueryPoolResults()
4986 if (copyType[copyTypeIdx] == COPY_TYPE_GET && dstOffset)
4987 continue;
4988
4989 // Tests with no attachments for only primary command to reduce # of test cases.
4990 tesControlPatches->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4991
4992 tesControlPatchesHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4993
4994 tesControlPatchesResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4995
4996 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
4997 tesControlPatchesResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
4998
4999 tesEvaluationShaderInvocations->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
5000
5001 tesEvaluationShaderInvocationsHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
5002
5003 tesEvaluationShaderInvocationsResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
5004
5005 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
5006 tesEvaluationShaderInvocationsResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_with_no_color_attachments", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, CLEAR_NOOP, DE_TRUE), sixRepeats));
5007
5008 /* Tests for clear operation within a statistics query activated.
5009 * Nothing for secondary_inherited cases can be done since it violates the specification.
5010 *
5011 * The query shouldn't count internal driver operations relevant to the clear operations.
5012 */
5013 const ClearOperation clearOp[] = { CLEAR_NOOP, CLEAR_COLOR, CLEAR_DEPTH };
5014 const char* const clearOpStr[] = { "", "_clear_color", "_clear_depth" };
5015
5016 for (int clearOpIdx = 0; clearOpIdx < DE_LENGTH_OF_ARRAY(clearOp); ++clearOpIdx) {
5017 tesControlPatches->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5018 tesControlPatches->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5019
5020 tesControlPatchesHostQueryReset->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5021 tesControlPatchesHostQueryReset->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5022
5023 tesControlPatchesResetBeforeCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5024 tesControlPatchesResetBeforeCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5025
5026 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
5027 {
5028 tesControlPatchesResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5029 tesControlPatchesResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5030 }
5031
5032 tesEvaluationShaderInvocations->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5033 tesEvaluationShaderInvocations->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5034
5035 tesEvaluationShaderInvocationsHostQueryReset->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5036 tesEvaluationShaderInvocationsHostQueryReset->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5037
5038 tesEvaluationShaderInvocationsResetBeforeCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5039 tesEvaluationShaderInvocationsResetBeforeCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5040
5041 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
5042 {
5043 tesEvaluationShaderInvocationsResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5044 tesEvaluationShaderInvocationsResetAfterCopy->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary" + clearOpStr[clearOpIdx], "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset, clearOp[clearOpIdx]), sixRepeats));
5045 }
5046 }
5047
5048 tesControlPatches->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5049 tesControlPatchesHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5050 tesControlPatchesResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5051 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
5052 tesControlPatchesResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_control_patches_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5053
5054 tesEvaluationShaderInvocations->addChild(new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance>(m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_NORMAL, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5055 tesEvaluationShaderInvocationsHostQueryReset->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_HOST, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5056 tesEvaluationShaderInvocationsResetBeforeCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance>(m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_BEFORE_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5057 if (copyType[copyTypeIdx] == COPY_TYPE_CMD)
5058 tesEvaluationShaderInvocationsResetAfterCopy->addChild (new QueryPoolGraphicStatisticsTest<TessellationShaderSecondrayInheritedTestInstance> (m_testCtx, prefix + copyTypeStr[copyTypeIdx] + "tes_evaluation_shader_invocations_secondary_inherited", "", GraphicBasicTestInstance::ParametersGraphic(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, RESET_TYPE_AFTER_COPY, copyType[copyTypeIdx], query64Bits, DE_FALSE, dstOffset), sixRepeats));
5059 }
5060 }
5061
5062 // Multiple statistics query flags enabled
5063 {
5064 VkQueryResultFlags partialFlags[] = { 0u, VK_QUERY_RESULT_PARTIAL_BIT };
5065 const char* const partialFlagsStr[] = { "", "_partial" };
5066 VkQueryResultFlags waitFlags[] = { 0u, VK_QUERY_RESULT_WAIT_BIT };
5067 const char* const waitFlagsStr[] = { "", "_wait" };
5068
5069 const CopyType copyTypes[] = { COPY_TYPE_GET, COPY_TYPE_CMD, COPY_TYPE_CMD };
5070 const char* const copyTypesStr[] = { "", "_cmdcopy", "_cmdcopy_dstoffset" };
5071
5072 const StrideType strideTypes[] = { STRIDE_TYPE_VALID, STRIDE_TYPE_ZERO };
5073 const char* const strideTypesStr[] = { "", "_stride_zero" };
5074
5075 const VkQueryPipelineStatisticFlags statisticsFlags =
5076 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT |
5077 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT;
5078
5079 for (deUint32 partialFlagsIdx = 0u; partialFlagsIdx < DE_LENGTH_OF_ARRAY(partialFlags); partialFlagsIdx++)
5080 {
5081 for (deUint32 waitFlagsIdx = 0u; waitFlagsIdx < DE_LENGTH_OF_ARRAY(waitFlags); waitFlagsIdx++)
5082 {
5083 for (deUint32 copyTypesIdx = 0u; copyTypesIdx < DE_LENGTH_OF_ARRAY(copyTypes); copyTypesIdx++)
5084 {
5085 for (deUint32 strideTypesIdx = 0u; strideTypesIdx < DE_LENGTH_OF_ARRAY(strideTypes); strideTypesIdx++)
5086 {
5087 deUint32 dstOffset = copyTypesIdx == 2u ? deUint32(NUM_QUERY_STATISTICS * sizeof(deUint64)) : deUint32(0u);
5088 /* Avoid waiting infinite time for the queries, when one of them is not going to be issued in
5089 * the partial case.
5090 */
5091 if ((deBool)(partialFlags[partialFlagsIdx] & VK_QUERY_RESULT_PARTIAL_BIT) &&
5092 (deBool)(waitFlags[waitFlagsIdx] & VK_QUERY_RESULT_WAIT_BIT))
5093 continue;
5094
5095 // Skip stride bogus tests when there are more than one query count.
5096 if (partialFlags[partialFlagsIdx] && strideTypes[strideTypesIdx] == STRIDE_TYPE_ZERO)
5097 continue;
5098
5099 if (strideTypes[strideTypesIdx] == STRIDE_TYPE_ZERO && copyType[copyTypesIdx] != COPY_TYPE_CMD)
5100 continue;
5101
5102 VkQueryResultFlags queryFlags = VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT | partialFlags[partialFlagsIdx] | waitFlags[waitFlagsIdx];
5103 deUint32 queryCount = partialFlagsIdx ? 2u : 1u;
5104 {
5105 std::ostringstream testName;
5106 testName << "input_assembly_vertex_fragment"
5107 << partialFlagsStr[partialFlagsIdx]
5108 << waitFlagsStr[waitFlagsIdx]
5109 << copyTypesStr[copyTypesIdx]
5110 << strideTypesStr[strideTypesIdx];
5111 GraphicBasicMultipleQueryTestInstance::ParametersGraphic param(statisticsFlags | VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, queryFlags, queryCount, DE_FALSE, copyTypes[copyTypesIdx], dstOffset, strideType[strideTypesIdx]);
5112 vertexShaderMultipleQueries->addChild(new QueryPoolGraphicMultipleQueryStatisticsTest<VertexShaderMultipleQueryTestInstance>(m_testCtx, testName.str().c_str(), "", param));
5113 }
5114
5115 {
5116 // No fragment shader case
5117 std::ostringstream testName;
5118 testName << "input_assembly_vertex"
5119 << partialFlagsStr[partialFlagsIdx]
5120 << waitFlagsStr[waitFlagsIdx]
5121 << copyTypesStr[copyTypesIdx]
5122 << strideTypesStr[strideTypesIdx];
5123 GraphicBasicMultipleQueryTestInstance::ParametersGraphic param(statisticsFlags | VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, queryFlags, queryCount, DE_TRUE, copyTypes[copyTypesIdx], dstOffset, strideType[strideTypesIdx]);
5124 vertexShaderMultipleQueries->addChild(new QueryPoolGraphicMultipleQueryStatisticsTest<VertexShaderMultipleQueryTestInstance>(m_testCtx, testName.str().c_str(), "", param));
5125 }
5126 }
5127 }
5128 }
5129 }
5130 }
5131
5132 addChild(computeShaderInvocationsGroup.release());
5133 addChild(inputAssemblyVertices.release());
5134 addChild(inputAssemblyPrimitives.release());
5135 addChild(vertexShaderInvocations.release());
5136 addChild(fragmentShaderInvocations.release());
5137 addChild(geometryShaderInvocations.release());
5138 addChild(geometryShaderPrimitives.release());
5139 addChild(clippingInvocations.release());
5140 addChild(clippingPrimitives.release());
5141 addChild(tesControlPatches.release());
5142 addChild(tesEvaluationShaderInvocations.release());
5143
5144 vertexOnlyGroup->addChild(inputAssemblyVerticesVertexOnly.release());
5145 vertexOnlyGroup->addChild(inputAssemblyPrimitivesVertexOnly.release());
5146 vertexOnlyGroup->addChild(vertexShaderInvocationsVertexOnly.release());
5147 addChild(vertexOnlyGroup.release());
5148
5149 hostQueryResetGroup->addChild(computeShaderInvocationsGroupHostQueryReset.release());
5150 hostQueryResetGroup->addChild(inputAssemblyVerticesHostQueryReset.release());
5151 hostQueryResetGroup->addChild(inputAssemblyPrimitivesHostQueryReset.release());
5152 hostQueryResetGroup->addChild(vertexShaderInvocationsHostQueryReset.release());
5153 hostQueryResetGroup->addChild(fragmentShaderInvocationsHostQueryReset.release());
5154 hostQueryResetGroup->addChild(geometryShaderInvocationsHostQueryReset.release());
5155 hostQueryResetGroup->addChild(geometryShaderPrimitivesHostQueryReset.release());
5156 hostQueryResetGroup->addChild(clippingInvocationsHostQueryReset.release());
5157 hostQueryResetGroup->addChild(clippingPrimitivesHostQueryReset.release());
5158 hostQueryResetGroup->addChild(tesControlPatchesHostQueryReset.release());
5159 hostQueryResetGroup->addChild(tesEvaluationShaderInvocationsHostQueryReset.release());
5160 addChild(hostQueryResetGroup.release());
5161
5162 resetBeforeCopyGroup->addChild(computeShaderInvocationsGroupResetBeforeCopy.release());
5163 resetBeforeCopyGroup->addChild(inputAssemblyVerticesResetBeforeCopy.release());
5164 resetBeforeCopyGroup->addChild(inputAssemblyPrimitivesResetBeforeCopy.release());
5165 resetBeforeCopyGroup->addChild(vertexShaderInvocationsResetBeforeCopy.release());
5166 resetBeforeCopyGroup->addChild(fragmentShaderInvocationsResetBeforeCopy.release());
5167 resetBeforeCopyGroup->addChild(geometryShaderInvocationsResetBeforeCopy.release());
5168 resetBeforeCopyGroup->addChild(geometryShaderPrimitivesResetBeforeCopy.release());
5169 resetBeforeCopyGroup->addChild(clippingInvocationsResetBeforeCopy.release());
5170 resetBeforeCopyGroup->addChild(clippingPrimitivesResetBeforeCopy.release());
5171 resetBeforeCopyGroup->addChild(tesControlPatchesResetBeforeCopy.release());
5172 resetBeforeCopyGroup->addChild(tesEvaluationShaderInvocationsResetBeforeCopy.release());
5173 addChild(resetBeforeCopyGroup.release());
5174
5175 resetAfterCopyGroup->addChild(computeShaderInvocationsGroupResetAfterCopy.release());
5176 resetAfterCopyGroup->addChild(inputAssemblyVerticesResetAfterCopy.release());
5177 resetAfterCopyGroup->addChild(inputAssemblyPrimitivesResetAfterCopy.release());
5178 resetAfterCopyGroup->addChild(vertexShaderInvocationsResetAfterCopy.release());
5179 resetAfterCopyGroup->addChild(fragmentShaderInvocationsResetAfterCopy.release());
5180 resetAfterCopyGroup->addChild(geometryShaderInvocationsResetAfterCopy.release());
5181 resetAfterCopyGroup->addChild(geometryShaderPrimitivesResetAfterCopy.release());
5182 resetAfterCopyGroup->addChild(clippingInvocationsResetAfterCopy.release());
5183 resetAfterCopyGroup->addChild(clippingPrimitivesResetAfterCopy.release());
5184 resetAfterCopyGroup->addChild(tesControlPatchesResetAfterCopy.release());
5185 resetAfterCopyGroup->addChild(tesEvaluationShaderInvocationsResetAfterCopy.release());
5186 addChild(resetAfterCopyGroup.release());
5187
5188 addChild(vertexShaderMultipleQueries.release());
5189 }
5190
5191 } //QueryPool
5192 } //vkt
5193