--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2019 Valve Corporation.
+ * Copyright (c) 2019 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief 64-bit data type comparison operations.
+ *//*--------------------------------------------------------------------*/
+
+#include "vktSpvAsm64bitCompareTests.hpp"
+#include "vktTestGroupUtil.hpp"
+#include "vkDefs.hpp"
+#include "vktTestCase.hpp"
+#include "vkQueryUtil.hpp"
+#include "vkMemUtil.hpp"
+#include "vkRefUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkPrograms.hpp"
+#include "vkCmdUtil.hpp"
+
+#include "tcuStringTemplate.hpp"
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <cmath>
+#include <sstream>
+#include <memory>
+#include <limits>
+
+namespace vkt
+{
+namespace SpirVAssembly
+{
+namespace
+{
+
+template <typename T>
+class CompareOperation
+{
+public:
+ virtual std::string spirvName () const = 0;
+ virtual bool run (T left, T right) const = 0;
+};
+
+// Helper intermediate class to be able to implement Ordered and Unordered floating point operations in a simpler way.
+class DoubleCompareOperation: public CompareOperation<double>
+{
+public:
+ struct BasicImplementation
+ {
+ virtual std::string nameSuffix () const = 0;
+ virtual bool run (double left, double right) const = 0; // No NaNs here.
+ };
+
+ virtual std::string spirvName () const
+ {
+ return "OpF" + std::string(m_ordered ? "Ord" : "Unord") + m_impl.nameSuffix();
+ }
+
+ virtual bool run (double left, double right) const
+ {
+ if (nanInvolved(left, right))
+ return !m_ordered; // Ordered operations return false when NaN is involved.
+ return m_impl.run(left, right);
+ }
+
+ DoubleCompareOperation(bool ordered, const BasicImplementation& impl)
+ : m_ordered(ordered), m_impl(impl)
+ {}
+
+private:
+ bool nanInvolved(double left, double right) const
+ {
+ return std::isnan(left) || std::isnan(right);
+ }
+
+ const bool m_ordered;
+ const BasicImplementation& m_impl;
+};
+
+#define GEN_DOUBLE_BASIC_IMPL(NAME, OPERATION) \
+ struct NAME##DoubleBasicImplClass : public DoubleCompareOperation::BasicImplementation \
+ { \
+ virtual std::string nameSuffix () const { return #NAME; } \
+ virtual bool run (double left, double right) const { return left OPERATION right; } \
+ }; \
+ NAME##DoubleBasicImplClass NAME##DoubleBasicImplInstance;
+
+GEN_DOUBLE_BASIC_IMPL(Equal, == )
+GEN_DOUBLE_BASIC_IMPL(NotEqual, != )
+GEN_DOUBLE_BASIC_IMPL(LessThan, < )
+GEN_DOUBLE_BASIC_IMPL(GreaterThan, > )
+GEN_DOUBLE_BASIC_IMPL(LessThanEqual, <= )
+GEN_DOUBLE_BASIC_IMPL(GreaterThanEqual, >= )
+
+#define GEN_FORDERED_OP(NAME) DoubleCompareOperation FOrdered##NAME##Op(true, NAME##DoubleBasicImplInstance)
+#define GEN_FUNORDERED_OP(NAME) DoubleCompareOperation FUnordered##NAME##Op(false, NAME##DoubleBasicImplInstance)
+#define GEN_FBOTH_OP(NAME) GEN_FORDERED_OP(NAME); GEN_FUNORDERED_OP(NAME);
+
+GEN_FBOTH_OP(Equal)
+GEN_FBOTH_OP(NotEqual)
+GEN_FBOTH_OP(LessThan)
+GEN_FBOTH_OP(GreaterThan)
+GEN_FBOTH_OP(LessThanEqual)
+GEN_FBOTH_OP(GreaterThanEqual)
+
+template <typename IntClass>
+class IntCompareOperation: public CompareOperation<IntClass>
+{
+public:
+ struct Implementation
+ {
+ virtual std::string typeChar () const = 0;
+ virtual std::string opName () const = 0;
+ virtual bool run (IntClass left, IntClass right) const = 0;
+ };
+
+ virtual std::string spirvName () const
+ {
+ return "Op" + m_impl.typeChar() + m_impl.opName();
+ }
+
+ virtual bool run (IntClass left, IntClass right) const
+ {
+ return m_impl.run(left, right);
+ }
+
+ IntCompareOperation(const Implementation& impl)
+ : m_impl(impl)
+ {}
+
+private:
+ const Implementation& m_impl;
+};
+
+#define GEN_INT_IMPL(INTTYPE, TYPECHAR, OPNAME, OPERATOR) \
+ struct INTTYPE##OPNAME##IntImplClass : public IntCompareOperation<INTTYPE>::Implementation \
+ { \
+ virtual std::string typeChar () const { return #TYPECHAR; } \
+ virtual std::string opName () const { return #OPNAME; } \
+ virtual bool run (INTTYPE left, INTTYPE right) const { return left OPERATOR right; } \
+ }; \
+ INTTYPE##OPNAME##IntImplClass INTTYPE##OPNAME##IntImplInstance;
+
+#define GEN_ALL_INT_TYPE_IMPL(INTTYPE, TYPECHAR) \
+ GEN_INT_IMPL(INTTYPE, I, Equal, == ) \
+ GEN_INT_IMPL(INTTYPE, I, NotEqual, != ) \
+ GEN_INT_IMPL(INTTYPE, TYPECHAR, GreaterThan, > ) \
+ GEN_INT_IMPL(INTTYPE, TYPECHAR, GreaterThanEqual, >= ) \
+ GEN_INT_IMPL(INTTYPE, TYPECHAR, LessThan, < ) \
+ GEN_INT_IMPL(INTTYPE, TYPECHAR, LessThanEqual, <= )
+
+GEN_ALL_INT_TYPE_IMPL(deInt64, S)
+GEN_ALL_INT_TYPE_IMPL(deUint64, U)
+
+#define GEN_INT_OP(INTTYPE, OPNAME) \
+ struct INTTYPE##OPNAME##OpClass: public IntCompareOperation<INTTYPE> \
+ { \
+ INTTYPE##OPNAME##OpClass () : IntCompareOperation<INTTYPE>(INTTYPE##OPNAME##IntImplInstance) {} \
+ }; \
+ INTTYPE##OPNAME##OpClass INTTYPE##OPNAME##Op;
+
+#define GEN_ALL_INT_OPS(INTTYPE) \
+ GEN_INT_OP(INTTYPE, Equal ) \
+ GEN_INT_OP(INTTYPE, NotEqual ) \
+ GEN_INT_OP(INTTYPE, GreaterThan ) \
+ GEN_INT_OP(INTTYPE, GreaterThanEqual ) \
+ GEN_INT_OP(INTTYPE, LessThan ) \
+ GEN_INT_OP(INTTYPE, LessThanEqual )
+
+GEN_ALL_INT_OPS(deInt64)
+GEN_ALL_INT_OPS(deUint64)
+
+enum DataType {
+ DATA_TYPE_SINGLE = 0,
+ DATA_TYPE_VECTOR,
+ DATA_TYPE_MAX_ENUM,
+};
+
+template <class T>
+using OperandsVector = std::vector<std::pair<T, T>>;
+
+template <class T>
+struct TestParameters
+{
+ DataType dataType;
+ const CompareOperation<T>& operation;
+ vk::VkShaderStageFlagBits stage;
+ const OperandsVector<T>& operands;
+};
+
+// Shader template for the compute stage using single scalars.
+// Generated from the following GLSL shader, replacing some bits by template parameters.
+#if 0
+#version 430
+
+// Left operands, right operands and results.
+layout(binding = 0) buffer Input1 { double values[]; } input1;
+layout(binding = 1) buffer Input2 { double values[]; } input2;
+layout(binding = 2) buffer Output1 { int values[]; } output1;
+
+void main()
+{
+ for (int i = 0; i < 20; i++) {
+ output1.values[i] = int(input1.values[i] == input2.values[i]);
+ }
+}
+#endif
+const tcu::StringTemplate CompShaderSingle(R"(
+ OpCapability Shader
+ ${OPCAPABILITY}
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint GLCompute %main "main"
+ OpExecutionMode %main LocalSize 1 1 1
+ OpName %main "main"
+ OpName %i "i"
+ OpName %Output1 "Output1"
+ OpMemberName %Output1 0 "values"
+ OpName %output1 "output1"
+ OpName %Input1 "Input1"
+ OpMemberName %Input1 0 "values"
+ OpName %input1 "input1"
+ OpName %Input2 "Input2"
+ OpMemberName %Input2 0 "values"
+ OpName %input2 "input2"
+ OpDecorate %_runtimearr_int ArrayStride 4
+ OpMemberDecorate %Output1 0 Offset 0
+ OpDecorate %Output1 BufferBlock
+ OpDecorate %output1 DescriptorSet 0
+ OpDecorate %output1 Binding 2
+ OpDecorate %_runtimearr_tinput ArrayStride 8
+ OpMemberDecorate %Input1 0 Offset 0
+ OpDecorate %Input1 BufferBlock
+ OpDecorate %input1 DescriptorSet 0
+ OpDecorate %input1 Binding 0
+ OpDecorate %_runtimearr_tinput_0 ArrayStride 8
+ OpMemberDecorate %Input2 0 Offset 0
+ OpDecorate %Input2 BufferBlock
+ OpDecorate %input2 DescriptorSet 0
+ OpDecorate %input2 Binding 1
+ %void = OpTypeVoid
+ %3 = OpTypeFunction %void
+ %int = OpTypeInt 32 1
+ %_ptr_Function_int = OpTypePointer Function %int
+ %int_0 = OpConstant %int 0
+ %niters = OpConstant %int ${ITERS}
+ %bool = OpTypeBool
+ %_runtimearr_int = OpTypeRuntimeArray %int
+ %Output1 = OpTypeStruct %_runtimearr_int
+%_ptr_Uniform_Output1 = OpTypePointer Uniform %Output1
+ %output1 = OpVariable %_ptr_Uniform_Output1 Uniform
+ %tinput = ${OPTYPE}
+ %_runtimearr_tinput = OpTypeRuntimeArray %tinput
+ %Input1 = OpTypeStruct %_runtimearr_tinput
+ %_ptr_Uniform_Input1 = OpTypePointer Uniform %Input1
+ %input1 = OpVariable %_ptr_Uniform_Input1 Uniform
+ %_ptr_Uniform_tinput = OpTypePointer Uniform %tinput
+%_runtimearr_tinput_0 = OpTypeRuntimeArray %tinput
+ %Input2 = OpTypeStruct %_runtimearr_tinput_0
+ %_ptr_Uniform_Input2 = OpTypePointer Uniform %Input2
+ %input2 = OpVariable %_ptr_Uniform_Input2 Uniform
+ %int_1 = OpConstant %int 1
+ %_ptr_Uniform_int = OpTypePointer Uniform %int
+ %main = OpFunction %void None %3
+ %5 = OpLabel
+ %i = OpVariable %_ptr_Function_int Function
+ OpStore %i %int_0
+ OpBranch %10
+ %10 = OpLabel
+ OpLoopMerge %12 %13 None
+ OpBranch %14
+ %14 = OpLabel
+ %15 = OpLoad %int %i
+ %18 = OpSLessThan %bool %15 %niters
+ OpBranchConditional %18 %11 %12
+ %11 = OpLabel
+ %23 = OpLoad %int %i
+ %29 = OpLoad %int %i
+ %31 = OpAccessChain %_ptr_Uniform_tinput %input1 %int_0 %29
+ %32 = OpLoad %tinput %31
+ %37 = OpLoad %int %i
+ %38 = OpAccessChain %_ptr_Uniform_tinput %input2 %int_0 %37
+ %39 = OpLoad %tinput %38
+ %40 = ${OPNAME} %bool %32 %39
+ %42 = OpSelect %int %40 %int_1 %int_0
+ %44 = OpAccessChain %_ptr_Uniform_int %output1 %int_0 %23
+ OpStore %44 %42
+ OpBranch %13
+ %13 = OpLabel
+ %45 = OpLoad %int %i
+ %46 = OpIAdd %int %45 %int_1
+ OpStore %i %46
+ OpBranch %10
+ %12 = OpLabel
+ OpReturn
+ OpFunctionEnd
+)");
+
+// Shader template for the compute stage using vectors.
+// Generated from the following GLSL shader, replacing some bits by template parameters.
+// Note the number of iterations needs to be divided by 4 as the shader will consume 4 doubles at a time.
+#if 0
+#version 430
+
+// Left operands, right operands and results.
+layout(binding = 0) buffer Input1 { dvec4 values[]; } input1;
+layout(binding = 1) buffer Input2 { dvec4 values[]; } input2;
+layout(binding = 2) buffer Output1 { ivec4 values[]; } output1;
+
+void main()
+{
+ for (int i = 0; i < 5; i++) {
+ output1.values[i] = ivec4(equal(input1.values[i], input2.values[i]));
+ }
+}
+#endif
+const tcu::StringTemplate CompShaderVector(R"(
+ OpCapability Shader
+ ${OPCAPABILITY}
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint GLCompute %main "main"
+ OpExecutionMode %main LocalSize 1 1 1
+ OpName %main "main"
+ OpName %i "i"
+ OpName %Output1 "Output1"
+ OpMemberName %Output1 0 "values"
+ OpName %output1 "output1"
+ OpName %Input1 "Input1"
+ OpMemberName %Input1 0 "values"
+ OpName %input1 "input1"
+ OpName %Input2 "Input2"
+ OpMemberName %Input2 0 "values"
+ OpName %input2 "input2"
+ OpDecorate %_runtimearr_v4int ArrayStride 16
+ OpMemberDecorate %Output1 0 Offset 0
+ OpDecorate %Output1 BufferBlock
+ OpDecorate %output1 DescriptorSet 0
+ OpDecorate %output1 Binding 2
+ OpDecorate %_runtimearr_v4tinput ArrayStride 32
+ OpMemberDecorate %Input1 0 Offset 0
+ OpDecorate %Input1 BufferBlock
+ OpDecorate %input1 DescriptorSet 0
+ OpDecorate %input1 Binding 0
+ OpDecorate %_runtimearr_v4tinput_0 ArrayStride 32
+ OpMemberDecorate %Input2 0 Offset 0
+ OpDecorate %Input2 BufferBlock
+ OpDecorate %input2 DescriptorSet 0
+ OpDecorate %input2 Binding 1
+ %void = OpTypeVoid
+ %3 = OpTypeFunction %void
+ %int = OpTypeInt 32 1
+ %_ptr_Function_int = OpTypePointer Function %int
+ %int_0 = OpConstant %int 0
+ %niters = OpConstant %int ${ITERS}
+ %bool = OpTypeBool
+ %v4int = OpTypeVector %int 4
+ %_runtimearr_v4int = OpTypeRuntimeArray %v4int
+ %Output1 = OpTypeStruct %_runtimearr_v4int
+ %_ptr_Uniform_Output1 = OpTypePointer Uniform %Output1
+ %output1 = OpVariable %_ptr_Uniform_Output1 Uniform
+ %tinput = ${OPTYPE}
+ %v4tinput = OpTypeVector %tinput 4
+ %_runtimearr_v4tinput = OpTypeRuntimeArray %v4tinput
+ %Input1 = OpTypeStruct %_runtimearr_v4tinput
+ %_ptr_Uniform_Input1 = OpTypePointer Uniform %Input1
+ %input1 = OpVariable %_ptr_Uniform_Input1 Uniform
+ %_ptr_Uniform_v4tinput = OpTypePointer Uniform %v4tinput
+%_runtimearr_v4tinput_0 = OpTypeRuntimeArray %v4tinput
+ %Input2 = OpTypeStruct %_runtimearr_v4tinput_0
+ %_ptr_Uniform_Input2 = OpTypePointer Uniform %Input2
+ %input2 = OpVariable %_ptr_Uniform_Input2 Uniform
+ %v4bool = OpTypeVector %bool 4
+ %int_1 = OpConstant %int 1
+ %45 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0
+ %46 = OpConstantComposite %v4int %int_1 %int_1 %int_1 %int_1
+ %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int
+ %main = OpFunction %void None %3
+ %5 = OpLabel
+ %i = OpVariable %_ptr_Function_int Function
+ OpStore %i %int_0
+ OpBranch %10
+ %10 = OpLabel
+ OpLoopMerge %12 %13 None
+ OpBranch %14
+ %14 = OpLabel
+ %15 = OpLoad %int %i
+ %18 = OpSLessThan %bool %15 %niters
+ OpBranchConditional %18 %11 %12
+ %11 = OpLabel
+ %24 = OpLoad %int %i
+ %31 = OpLoad %int %i
+ %33 = OpAccessChain %_ptr_Uniform_v4tinput %input1 %int_0 %31
+ %34 = OpLoad %v4tinput %33
+ %39 = OpLoad %int %i
+ %40 = OpAccessChain %_ptr_Uniform_v4tinput %input2 %int_0 %39
+ %41 = OpLoad %v4tinput %40
+ %43 = ${OPNAME} %v4bool %34 %41
+ %47 = OpSelect %v4int %43 %46 %45
+ %49 = OpAccessChain %_ptr_Uniform_v4int %output1 %int_0 %24
+ OpStore %49 %47
+ OpBranch %13
+ %13 = OpLabel
+ %50 = OpLoad %int %i
+ %51 = OpIAdd %int %50 %int_1
+ OpStore %i %51
+ OpBranch %10
+ %12 = OpLabel
+ OpReturn
+ OpFunctionEnd
+)");
+
+// Shader template for the vertex stage using single scalars.
+// Generated from the following GLSL shader, replacing some bits by template parameters.
+#if 0
+#version 430
+
+// Left operands, right operands and results.
+layout(binding = 0) buffer Input1 { double values[]; } input1;
+layout(binding = 1) buffer Input2 { double values[]; } input2;
+layout(binding = 2) buffer Output1 { int values[]; } output1;
+
+void main()
+{
+ gl_PointSize = 1;
+ gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+
+ for (int i = 0; i < 20; i++) {
+ output1.values[i] = int(input1.values[i] == input2.values[i]);
+ }
+}
+#endif
+const tcu::StringTemplate VertShaderSingle(R"(
+ OpCapability Shader
+ ${OPCAPABILITY}
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Vertex %main "main" %_
+ OpName %main "main"
+ OpName %gl_PerVertex "gl_PerVertex"
+ OpMemberName %gl_PerVertex 0 "gl_Position"
+ OpMemberName %gl_PerVertex 1 "gl_PointSize"
+ OpMemberName %gl_PerVertex 2 "gl_ClipDistance"
+ OpName %_ ""
+ OpName %i "i"
+ OpName %Output1 "Output1"
+ OpMemberName %Output1 0 "values"
+ OpName %output1 "output1"
+ OpName %Input1 "Input1"
+ OpMemberName %Input1 0 "values"
+ OpName %input1 "input1"
+ OpName %Input2 "Input2"
+ OpMemberName %Input2 0 "values"
+ OpName %input2 "input2"
+ OpMemberDecorate %gl_PerVertex 0 BuiltIn Position
+ OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize
+ OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance
+ OpDecorate %gl_PerVertex Block
+ OpDecorate %_runtimearr_int ArrayStride 4
+ OpMemberDecorate %Output1 0 Offset 0
+ OpDecorate %Output1 BufferBlock
+ OpDecorate %output1 DescriptorSet 0
+ OpDecorate %output1 Binding 2
+ OpDecorate %_runtimearr_tinput ArrayStride 8
+ OpMemberDecorate %Input1 0 Offset 0
+ OpDecorate %Input1 BufferBlock
+ OpDecorate %input1 DescriptorSet 0
+ OpDecorate %input1 Binding 0
+ OpDecorate %_runtimearr_tinput_0 ArrayStride 8
+ OpMemberDecorate %Input2 0 Offset 0
+ OpDecorate %Input2 BufferBlock
+ OpDecorate %input2 DescriptorSet 0
+ OpDecorate %input2 Binding 1
+ %void = OpTypeVoid
+ %3 = OpTypeFunction %void
+ %float = OpTypeFloat 32
+ %v4float = OpTypeVector %float 4
+ %uint = OpTypeInt 32 0
+ %uint_1 = OpConstant %uint 1
+ %_arr_float_uint_1 = OpTypeArray %float %uint_1
+ %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1
+%_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex
+ %_ = OpVariable %_ptr_Output_gl_PerVertex Output
+ %int = OpTypeInt 32 1
+ %int_1 = OpConstant %int 1
+ %float_1 = OpConstant %float 1
+ %_ptr_Output_float = OpTypePointer Output %float
+ %int_0 = OpConstant %int 0
+ %float_0 = OpConstant %float 0
+ %21 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1
+ %_ptr_Output_v4float = OpTypePointer Output %v4float
+ %_ptr_Function_int = OpTypePointer Function %int
+ %niters = OpConstant %int ${ITERS}
+ %bool = OpTypeBool
+ %_runtimearr_int = OpTypeRuntimeArray %int
+ %Output1 = OpTypeStruct %_runtimearr_int
+ %_ptr_Uniform_Output1 = OpTypePointer Uniform %Output1
+ %output1 = OpVariable %_ptr_Uniform_Output1 Uniform
+ %tinput = ${OPTYPE}
+ %_runtimearr_tinput = OpTypeRuntimeArray %tinput
+ %Input1 = OpTypeStruct %_runtimearr_tinput
+ %_ptr_Uniform_Input1 = OpTypePointer Uniform %Input1
+ %input1 = OpVariable %_ptr_Uniform_Input1 Uniform
+ %_ptr_Uniform_tinput = OpTypePointer Uniform %tinput
+ %_runtimearr_tinput_0 = OpTypeRuntimeArray %tinput
+ %Input2 = OpTypeStruct %_runtimearr_tinput_0
+ %_ptr_Uniform_Input2 = OpTypePointer Uniform %Input2
+ %input2 = OpVariable %_ptr_Uniform_Input2 Uniform
+ %_ptr_Uniform_int = OpTypePointer Uniform %int
+ %main = OpFunction %void None %3
+ %5 = OpLabel
+ %i = OpVariable %_ptr_Function_int Function
+ %18 = OpAccessChain %_ptr_Output_float %_ %int_1
+ OpStore %18 %float_1
+ %23 = OpAccessChain %_ptr_Output_v4float %_ %int_0
+ OpStore %23 %21
+ OpStore %i %int_0
+ OpBranch %26
+ %26 = OpLabel
+ OpLoopMerge %28 %29 None
+ OpBranch %30
+ %30 = OpLabel
+ %31 = OpLoad %int %i
+ %34 = OpSLessThan %bool %31 %niters
+ OpBranchConditional %34 %27 %28
+ %27 = OpLabel
+ %39 = OpLoad %int %i
+ %45 = OpLoad %int %i
+ %47 = OpAccessChain %_ptr_Uniform_tinput %input1 %int_0 %45
+ %48 = OpLoad %tinput %47
+ %53 = OpLoad %int %i
+ %54 = OpAccessChain %_ptr_Uniform_tinput %input2 %int_0 %53
+ %55 = OpLoad %tinput %54
+ %56 = ${OPNAME} %bool %48 %55
+ %57 = OpSelect %int %56 %int_1 %int_0
+ %59 = OpAccessChain %_ptr_Uniform_int %output1 %int_0 %39
+ OpStore %59 %57
+ OpBranch %29
+ %29 = OpLabel
+ %60 = OpLoad %int %i
+ %61 = OpIAdd %int %60 %int_1
+ OpStore %i %61
+ OpBranch %26
+ %28 = OpLabel
+ OpReturn
+ OpFunctionEnd
+)");
+
+// Shader template for the vertex stage using vectors.
+// Generated from the following GLSL shader, replacing some bits by template parameters.
+// Note the number of iterations needs to be divided by 4 as the shader will consume 4 doubles at a time.
+#if 0
+#version 430
+
+// Left operands, right operands and results.
+layout(binding = 0) buffer Input1 { dvec4 values[]; } input1;
+layout(binding = 1) buffer Input2 { dvec4 values[]; } input2;
+layout(binding = 2) buffer Output1 { ivec4 values[]; } output1;
+
+void main()
+{
+ gl_PointSize = 1;
+ gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+
+ for (int i = 0; i < 5; i++) {
+ output1.values[i] = ivec4(equal(input1.values[i], input2.values[i]));
+ }
+}
+#endif
+const tcu::StringTemplate VertShaderVector(R"(
+ OpCapability Shader
+ ${OPCAPABILITY}
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Vertex %main "main" %_
+ OpName %main "main"
+ OpName %gl_PerVertex "gl_PerVertex"
+ OpMemberName %gl_PerVertex 0 "gl_Position"
+ OpMemberName %gl_PerVertex 1 "gl_PointSize"
+ OpMemberName %gl_PerVertex 2 "gl_ClipDistance"
+ OpName %_ ""
+ OpName %i "i"
+ OpName %Output1 "Output1"
+ OpMemberName %Output1 0 "values"
+ OpName %output1 "output1"
+ OpName %Input1 "Input1"
+ OpMemberName %Input1 0 "values"
+ OpName %input1 "input1"
+ OpName %Input2 "Input2"
+ OpMemberName %Input2 0 "values"
+ OpName %input2 "input2"
+ OpMemberDecorate %gl_PerVertex 0 BuiltIn Position
+ OpMemberDecorate %gl_PerVertex 1 BuiltIn PointSize
+ OpMemberDecorate %gl_PerVertex 2 BuiltIn ClipDistance
+ OpDecorate %gl_PerVertex Block
+ OpDecorate %_runtimearr_v4int ArrayStride 16
+ OpMemberDecorate %Output1 0 Offset 0
+ OpDecorate %Output1 BufferBlock
+ OpDecorate %output1 DescriptorSet 0
+ OpDecorate %output1 Binding 2
+ OpDecorate %_runtimearr_v4tinput ArrayStride 32
+ OpMemberDecorate %Input1 0 Offset 0
+ OpDecorate %Input1 BufferBlock
+ OpDecorate %input1 DescriptorSet 0
+ OpDecorate %input1 Binding 0
+ OpDecorate %_runtimearr_v4tinput_0 ArrayStride 32
+ OpMemberDecorate %Input2 0 Offset 0
+ OpDecorate %Input2 BufferBlock
+ OpDecorate %input2 DescriptorSet 0
+ OpDecorate %input2 Binding 1
+ %void = OpTypeVoid
+ %3 = OpTypeFunction %void
+ %float = OpTypeFloat 32
+ %v4float = OpTypeVector %float 4
+ %uint = OpTypeInt 32 0
+ %uint_1 = OpConstant %uint 1
+ %_arr_float_uint_1 = OpTypeArray %float %uint_1
+ %gl_PerVertex = OpTypeStruct %v4float %float %_arr_float_uint_1
+%_ptr_Output_gl_PerVertex = OpTypePointer Output %gl_PerVertex
+ %_ = OpVariable %_ptr_Output_gl_PerVertex Output
+ %int = OpTypeInt 32 1
+ %int_1 = OpConstant %int 1
+ %float_1 = OpConstant %float 1
+ %_ptr_Output_float = OpTypePointer Output %float
+ %int_0 = OpConstant %int 0
+ %float_0 = OpConstant %float 0
+ %21 = OpConstantComposite %v4float %float_0 %float_0 %float_0 %float_1
+ %_ptr_Output_v4float = OpTypePointer Output %v4float
+ %_ptr_Function_int = OpTypePointer Function %int
+ %niters = OpConstant %int ${ITERS}
+ %bool = OpTypeBool
+ %v4int = OpTypeVector %int 4
+ %_runtimearr_v4int = OpTypeRuntimeArray %v4int
+ %Output1 = OpTypeStruct %_runtimearr_v4int
+ %_ptr_Uniform_Output1 = OpTypePointer Uniform %Output1
+ %output1 = OpVariable %_ptr_Uniform_Output1 Uniform
+ %tinput = ${OPTYPE}
+ %v4tinput = OpTypeVector %tinput 4
+ %_runtimearr_v4tinput = OpTypeRuntimeArray %v4tinput
+ %Input1 = OpTypeStruct %_runtimearr_v4tinput
+ %_ptr_Uniform_Input1 = OpTypePointer Uniform %Input1
+ %input1 = OpVariable %_ptr_Uniform_Input1 Uniform
+ %_ptr_Uniform_v4tinput = OpTypePointer Uniform %v4tinput
+ %_runtimearr_v4tinput_0 = OpTypeRuntimeArray %v4tinput
+ %Input2 = OpTypeStruct %_runtimearr_v4tinput_0
+ %_ptr_Uniform_Input2 = OpTypePointer Uniform %Input2
+ %input2 = OpVariable %_ptr_Uniform_Input2 Uniform
+ %v4bool = OpTypeVector %bool 4
+ %60 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0
+ %61 = OpConstantComposite %v4int %int_1 %int_1 %int_1 %int_1
+ %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int
+ %main = OpFunction %void None %3
+ %5 = OpLabel
+ %i = OpVariable %_ptr_Function_int Function
+ %18 = OpAccessChain %_ptr_Output_float %_ %int_1
+ OpStore %18 %float_1
+ %23 = OpAccessChain %_ptr_Output_v4float %_ %int_0
+ OpStore %23 %21
+ OpStore %i %int_0
+ OpBranch %26
+ %26 = OpLabel
+ OpLoopMerge %28 %29 None
+ OpBranch %30
+ %30 = OpLabel
+ %31 = OpLoad %int %i
+ %34 = OpSLessThan %bool %31 %niters
+ OpBranchConditional %34 %27 %28
+ %27 = OpLabel
+ %40 = OpLoad %int %i
+ %47 = OpLoad %int %i
+ %49 = OpAccessChain %_ptr_Uniform_v4tinput %input1 %int_0 %47
+ %50 = OpLoad %v4tinput %49
+ %55 = OpLoad %int %i
+ %56 = OpAccessChain %_ptr_Uniform_v4tinput %input2 %int_0 %55
+ %57 = OpLoad %v4tinput %56
+ %59 = ${OPNAME} %v4bool %50 %57
+ %62 = OpSelect %v4int %59 %61 %60
+ %64 = OpAccessChain %_ptr_Uniform_v4int %output1 %int_0 %40
+ OpStore %64 %62
+ OpBranch %29
+ %29 = OpLabel
+ %65 = OpLoad %int %i
+ %66 = OpIAdd %int %65 %int_1
+ OpStore %i %66
+ OpBranch %26
+ %28 = OpLabel
+ OpReturn
+ OpFunctionEnd
+)");
+
+// GLSL passthrough vertex shader to test the fragment shader.
+const std::string VertShaderPassThrough = R"(
+#version 430
+
+layout(location = 0) out vec4 out_color;
+
+void main()
+{
+ gl_PointSize = 1;
+ gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+ out_color = vec4(0.0, 0.0, 0.0, 1.0);
+}
+)";
+
+// Shader template for the fragment stage using single scalars.
+// Generated from the following GLSL shader, replacing some bits by template parameters.
+#if 0
+#version 430
+
+// Left operands, right operands and results.
+layout(binding = 0) buffer Input1 { double values[]; } input1;
+layout(binding = 1) buffer Input2 { double values[]; } input2;
+layout(binding = 2) buffer Output1 { int values[]; } output1;
+
+void main()
+{
+ for (int i = 0; i < 20; i++) {
+ output1.values[i] = int(input1.values[i] == input2.values[i]);
+ }
+}
+#endif
+const tcu::StringTemplate FragShaderSingle(R"(
+ OpCapability Shader
+ ${OPCAPABILITY}
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %main "main"
+ OpExecutionMode %main OriginUpperLeft
+ OpSource GLSL 430
+ OpName %main "main"
+ OpName %i "i"
+ OpName %Output1 "Output1"
+ OpMemberName %Output1 0 "values"
+ OpName %output1 "output1"
+ OpName %Input1 "Input1"
+ OpMemberName %Input1 0 "values"
+ OpName %input1 "input1"
+ OpName %Input2 "Input2"
+ OpMemberName %Input2 0 "values"
+ OpName %input2 "input2"
+ OpDecorate %_runtimearr_int ArrayStride 4
+ OpMemberDecorate %Output1 0 Offset 0
+ OpDecorate %Output1 BufferBlock
+ OpDecorate %output1 DescriptorSet 0
+ OpDecorate %output1 Binding 2
+ OpDecorate %_runtimearr_tinput ArrayStride 8
+ OpMemberDecorate %Input1 0 Offset 0
+ OpDecorate %Input1 BufferBlock
+ OpDecorate %input1 DescriptorSet 0
+ OpDecorate %input1 Binding 0
+ OpDecorate %_runtimearr_tinput_0 ArrayStride 8
+ OpMemberDecorate %Input2 0 Offset 0
+ OpDecorate %Input2 BufferBlock
+ OpDecorate %input2 DescriptorSet 0
+ OpDecorate %input2 Binding 1
+ %void = OpTypeVoid
+ %3 = OpTypeFunction %void
+ %int = OpTypeInt 32 1
+ %_ptr_Function_int = OpTypePointer Function %int
+ %int_0 = OpConstant %int 0
+ %niters = OpConstant %int ${ITERS}
+ %bool = OpTypeBool
+ %_runtimearr_int = OpTypeRuntimeArray %int
+ %Output1 = OpTypeStruct %_runtimearr_int
+%_ptr_Uniform_Output1 = OpTypePointer Uniform %Output1
+ %output1 = OpVariable %_ptr_Uniform_Output1 Uniform
+ %tinput = ${OPTYPE}
+ %_runtimearr_tinput = OpTypeRuntimeArray %tinput
+ %Input1 = OpTypeStruct %_runtimearr_tinput
+ %_ptr_Uniform_Input1 = OpTypePointer Uniform %Input1
+ %input1 = OpVariable %_ptr_Uniform_Input1 Uniform
+ %_ptr_Uniform_tinput = OpTypePointer Uniform %tinput
+%_runtimearr_tinput_0 = OpTypeRuntimeArray %tinput
+ %Input2 = OpTypeStruct %_runtimearr_tinput_0
+ %_ptr_Uniform_Input2 = OpTypePointer Uniform %Input2
+ %input2 = OpVariable %_ptr_Uniform_Input2 Uniform
+ %int_1 = OpConstant %int 1
+ %_ptr_Uniform_int = OpTypePointer Uniform %int
+ %main = OpFunction %void None %3
+ %5 = OpLabel
+ %i = OpVariable %_ptr_Function_int Function
+ OpStore %i %int_0
+ OpBranch %10
+ %10 = OpLabel
+ OpLoopMerge %12 %13 None
+ OpBranch %14
+ %14 = OpLabel
+ %15 = OpLoad %int %i
+ %18 = OpSLessThan %bool %15 %niters
+ OpBranchConditional %18 %11 %12
+ %11 = OpLabel
+ %23 = OpLoad %int %i
+ %29 = OpLoad %int %i
+ %31 = OpAccessChain %_ptr_Uniform_tinput %input1 %int_0 %29
+ %32 = OpLoad %tinput %31
+ %37 = OpLoad %int %i
+ %38 = OpAccessChain %_ptr_Uniform_tinput %input2 %int_0 %37
+ %39 = OpLoad %tinput %38
+ %40 = ${OPNAME} %bool %32 %39
+ %42 = OpSelect %int %40 %int_1 %int_0
+ %44 = OpAccessChain %_ptr_Uniform_int %output1 %int_0 %23
+ OpStore %44 %42
+ OpBranch %13
+ %13 = OpLabel
+ %45 = OpLoad %int %i
+ %46 = OpIAdd %int %45 %int_1
+ OpStore %i %46
+ OpBranch %10
+ %12 = OpLabel
+ OpReturn
+ OpFunctionEnd
+)");
+
+// Shader template for the fragment stage using vectors.
+// Generated from the following GLSL shader, replacing some bits by template parameters.
+// Note the number of iterations needs to be divided by 4 as the shader will consume 4 doubles at a time.
+#if 0
+#version 430
+
+// Left operands, right operands and results.
+layout(binding = 0) buffer Input1 { dvec4 values[]; } input1;
+layout(binding = 1) buffer Input2 { dvec4 values[]; } input2;
+layout(binding = 2) buffer Output1 { ivec4 values[]; } output1;
+
+void main()
+{
+ for (int i = 0; i < 5; i++) {
+ output1.values[i] = ivec4(equal(input1.values[i], input2.values[i]));
+ }
+}
+#endif
+const tcu::StringTemplate FragShaderVector(R"(
+ OpCapability Shader
+ ${OPCAPABILITY}
+ %1 = OpExtInstImport "GLSL.std.450"
+ OpMemoryModel Logical GLSL450
+ OpEntryPoint Fragment %main "main"
+ OpExecutionMode %main OriginUpperLeft
+ OpName %main "main"
+ OpName %i "i"
+ OpName %Output1 "Output1"
+ OpMemberName %Output1 0 "values"
+ OpName %output1 "output1"
+ OpName %Input1 "Input1"
+ OpMemberName %Input1 0 "values"
+ OpName %input1 "input1"
+ OpName %Input2 "Input2"
+ OpMemberName %Input2 0 "values"
+ OpName %input2 "input2"
+ OpDecorate %_runtimearr_v4int ArrayStride 16
+ OpMemberDecorate %Output1 0 Offset 0
+ OpDecorate %Output1 BufferBlock
+ OpDecorate %output1 DescriptorSet 0
+ OpDecorate %output1 Binding 2
+ OpDecorate %_runtimearr_v4tinput ArrayStride 32
+ OpMemberDecorate %Input1 0 Offset 0
+ OpDecorate %Input1 BufferBlock
+ OpDecorate %input1 DescriptorSet 0
+ OpDecorate %input1 Binding 0
+ OpDecorate %_runtimearr_v4tinput_0 ArrayStride 32
+ OpMemberDecorate %Input2 0 Offset 0
+ OpDecorate %Input2 BufferBlock
+ OpDecorate %input2 DescriptorSet 0
+ OpDecorate %input2 Binding 1
+ %void = OpTypeVoid
+ %3 = OpTypeFunction %void
+ %int = OpTypeInt 32 1
+ %_ptr_Function_int = OpTypePointer Function %int
+ %int_0 = OpConstant %int 0
+ %niters = OpConstant %int ${ITERS}
+ %bool = OpTypeBool
+ %v4int = OpTypeVector %int 4
+ %_runtimearr_v4int = OpTypeRuntimeArray %v4int
+ %Output1 = OpTypeStruct %_runtimearr_v4int
+ %_ptr_Uniform_Output1 = OpTypePointer Uniform %Output1
+ %output1 = OpVariable %_ptr_Uniform_Output1 Uniform
+ %tinput = ${OPTYPE}
+ %v4tinput = OpTypeVector %tinput 4
+ %_runtimearr_v4tinput = OpTypeRuntimeArray %v4tinput
+ %Input1 = OpTypeStruct %_runtimearr_v4tinput
+ %_ptr_Uniform_Input1 = OpTypePointer Uniform %Input1
+ %input1 = OpVariable %_ptr_Uniform_Input1 Uniform
+ %_ptr_Uniform_v4tinput = OpTypePointer Uniform %v4tinput
+%_runtimearr_v4tinput_0 = OpTypeRuntimeArray %v4tinput
+ %Input2 = OpTypeStruct %_runtimearr_v4tinput_0
+ %_ptr_Uniform_Input2 = OpTypePointer Uniform %Input2
+ %input2 = OpVariable %_ptr_Uniform_Input2 Uniform
+ %v4bool = OpTypeVector %bool 4
+ %int_1 = OpConstant %int 1
+ %45 = OpConstantComposite %v4int %int_0 %int_0 %int_0 %int_0
+ %46 = OpConstantComposite %v4int %int_1 %int_1 %int_1 %int_1
+ %_ptr_Uniform_v4int = OpTypePointer Uniform %v4int
+ %main = OpFunction %void None %3
+ %5 = OpLabel
+ %i = OpVariable %_ptr_Function_int Function
+ OpStore %i %int_0
+ OpBranch %10
+ %10 = OpLabel
+ OpLoopMerge %12 %13 None
+ OpBranch %14
+ %14 = OpLabel
+ %15 = OpLoad %int %i
+ %18 = OpSLessThan %bool %15 %niters
+ OpBranchConditional %18 %11 %12
+ %11 = OpLabel
+ %24 = OpLoad %int %i
+ %31 = OpLoad %int %i
+ %33 = OpAccessChain %_ptr_Uniform_v4tinput %input1 %int_0 %31
+ %34 = OpLoad %v4tinput %33
+ %39 = OpLoad %int %i
+ %40 = OpAccessChain %_ptr_Uniform_v4tinput %input2 %int_0 %39
+ %41 = OpLoad %v4tinput %40
+ %43 = ${OPNAME} %v4bool %34 %41
+ %47 = OpSelect %v4int %43 %46 %45
+ %49 = OpAccessChain %_ptr_Uniform_v4int %output1 %int_0 %24
+ OpStore %49 %47
+ OpBranch %13
+ %13 = OpLabel
+ %50 = OpLoad %int %i
+ %51 = OpIAdd %int %50 %int_1
+ OpStore %i %51
+ OpBranch %10
+ %12 = OpLabel
+ OpReturn
+ OpFunctionEnd
+)");
+
+struct SpirvTemplateManager
+{
+ static const tcu::StringTemplate& getTemplate (DataType type, vk::VkShaderStageFlagBits stage)
+ {
+ DE_ASSERT(type == DATA_TYPE_SINGLE || type == DATA_TYPE_VECTOR);
+ DE_ASSERT( stage == vk::VK_SHADER_STAGE_COMPUTE_BIT ||
+ stage == vk::VK_SHADER_STAGE_VERTEX_BIT ||
+ stage == vk::VK_SHADER_STAGE_FRAGMENT_BIT );
+
+ if (type == DATA_TYPE_SINGLE)
+ {
+ if (stage == vk::VK_SHADER_STAGE_COMPUTE_BIT) return CompShaderSingle;
+ if (stage == vk::VK_SHADER_STAGE_VERTEX_BIT) return VertShaderSingle;
+ else return FragShaderSingle;
+ }
+ else
+ {
+ if (stage == vk::VK_SHADER_STAGE_COMPUTE_BIT) return CompShaderVector;
+ if (stage == vk::VK_SHADER_STAGE_VERTEX_BIT) return VertShaderVector;
+ else return FragShaderVector;
+ }
+ }
+
+ // Specialized below for different types.
+ template <class T>
+ static std::string getOpCapability();
+
+ // Same.
+ template <class T>
+ static std::string getOpType();
+};
+
+template <> std::string SpirvTemplateManager::getOpCapability<double>() { return "OpCapability Float64"; }
+template <> std::string SpirvTemplateManager::getOpCapability<deInt64>() { return "OpCapability Int64"; }
+template <> std::string SpirvTemplateManager::getOpCapability<deUint64>() { return "OpCapability Int64"; }
+
+template <> std::string SpirvTemplateManager::getOpType<double>() { return "OpTypeFloat 64"; }
+template <> std::string SpirvTemplateManager::getOpType<deInt64>() { return "OpTypeInt 64 1"; }
+template <> std::string SpirvTemplateManager::getOpType<deUint64>() { return "OpTypeInt 64 0"; }
+
+struct BufferWithMemory
+{
+ vk::Move<vk::VkBuffer> buffer;
+ de::MovePtr<vk::Allocation> allocation;
+
+ BufferWithMemory ()
+ : buffer(), allocation()
+ {}
+
+ BufferWithMemory (BufferWithMemory&& other)
+ : buffer(other.buffer), allocation(other.allocation)
+ {}
+
+ BufferWithMemory& operator= (BufferWithMemory&& other)
+ {
+ buffer = other.buffer;
+ allocation = other.allocation;
+ return *this;
+ }
+};
+
+// Create storage buffer, bind memory to it and return both things.
+BufferWithMemory createStorageBuffer(const vk::DeviceInterface& vkdi,
+ const vk::VkDevice device,
+ vk::Allocator& allocator,
+ size_t numBytes)
+{
+ const vk::VkBufferCreateInfo bufferCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
+ DE_NULL, // pNext
+ 0u, // flags
+ numBytes, // size
+ vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, // usage
+ vk::VK_SHARING_MODE_EXCLUSIVE, // sharingMode
+ 0u, // queueFamilyCount
+ DE_NULL, // pQueueFamilyIndices
+ };
+
+ BufferWithMemory bufmem;
+
+ bufmem.buffer = vk::createBuffer(vkdi, device, &bufferCreateInfo);
+ const vk::VkMemoryRequirements requirements = getBufferMemoryRequirements(vkdi, device, *bufmem.buffer);
+ bufmem.allocation = allocator.allocate(requirements, vk::MemoryRequirement::HostVisible);
+
+ VK_CHECK(vkdi.bindBufferMemory(device, *bufmem.buffer, bufmem.allocation->getMemory(), bufmem.allocation->getOffset()));
+
+ return bufmem;
+}
+
+vk::Move<vk::VkShaderModule> createShaderModule (const vk::DeviceInterface& deviceInterface,
+ vk::VkDevice device,
+ const vk::ProgramBinary& binary)
+{
+ DE_ASSERT(binary.getFormat() == vk::PROGRAM_FORMAT_SPIRV);
+
+ const struct vk::VkShaderModuleCreateInfo shaderModuleInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+ DE_NULL,
+ 0,
+ static_cast<deUintptr>(binary.getSize()),
+ reinterpret_cast<const deUint32*>(binary.getBinary()),
+ };
+
+ return createShaderModule(deviceInterface, device, &shaderModuleInfo);
+}
+
+// Make sure the length of the following vectors is a multiple of 4. This will make sure operands can be reused for vectorized tests.
+const OperandsVector<double> DOUBLE_OPERANDS =
+{
+ { -8.0, -5.0 },
+ { -5.0, -8.0 },
+ { -5.0, -5.0 },
+ { -5.0, 0.0 },
+ { 0.0, -5.0 },
+ { 5.0, 0.0 },
+ { 0.0, 5.0 },
+ { 0.0, 0.0 },
+ { -5.0, 5.0 },
+ { 5.0, -5.0 },
+ { 5.0, 8.0 },
+ { 8.0, 5.0 },
+ { 5.0, 5.0 },
+ { -6.0, -5.0 },
+ { 6.0, 5.0 },
+ { 0.0, 1.0 },
+ { 1.0, 0.0 },
+ { 0.0, NAN },
+ { NAN, 0.0 },
+ { NAN, NAN },
+};
+
+const OperandsVector<deInt64> INT64_OPERANDS =
+{
+ { -8, -5 },
+ { -5, -8 },
+ { -5, -5 },
+ { -5, 0 },
+ { 0, -5 },
+ { 5, 0 },
+ { 0, 5 },
+ { 0, 0 },
+ { -5, 5 },
+ { 5, -5 },
+ { 5, 8 },
+ { 8, 5 },
+ { 5, 5 },
+ { -6, -5 },
+ { 6, 5 },
+ { 0, 1 },
+};
+
+constexpr auto MAX_DEUINT64 = std::numeric_limits<deUint64>::max();
+const OperandsVector<deUint64> UINT64_OPERANDS =
+{
+ { 0, 0 },
+ { 1, 0 },
+ { 0, 1 },
+ { 1, 1 },
+ { 5, 8 },
+ { 8, 5 },
+ { 5, 5 },
+ { 0, MAX_DEUINT64 },
+ { MAX_DEUINT64, 0 },
+ { MAX_DEUINT64 - 1, MAX_DEUINT64 },
+ { MAX_DEUINT64, MAX_DEUINT64 - 1 },
+ { MAX_DEUINT64, MAX_DEUINT64 },
+};
+
+template <class T>
+class T64bitCompareTestInstance : public TestInstance
+{
+public:
+ T64bitCompareTestInstance (Context& ctx, const TestParameters<T>& params);
+ tcu::TestStatus iterate (void);
+
+private:
+ const TestParameters<T> m_params;
+ const size_t m_numOperations;
+ const size_t m_inputBufferSize;
+ const size_t m_outputBufferSize;
+};
+
+template <class T>
+T64bitCompareTestInstance<T>::T64bitCompareTestInstance (Context& ctx, const TestParameters<T>& params)
+ : TestInstance(ctx)
+ , m_params(params)
+ , m_numOperations(m_params.operands.size())
+ , m_inputBufferSize(m_numOperations * sizeof(T))
+ , m_outputBufferSize(m_numOperations * sizeof(int))
+{
+}
+
+template <class T>
+tcu::TestStatus T64bitCompareTestInstance<T>::iterate (void)
+{
+ DE_ASSERT(m_params.stage == vk::VK_SHADER_STAGE_COMPUTE_BIT ||
+ m_params.stage == vk::VK_SHADER_STAGE_VERTEX_BIT ||
+ m_params.stage == vk::VK_SHADER_STAGE_FRAGMENT_BIT );
+
+ auto& vkdi = m_context.getDeviceInterface();
+ auto device = m_context.getDevice();
+ auto& allocator = m_context.getDefaultAllocator();
+
+ // Create storage buffers (left operands, right operands and results buffer).
+ BufferWithMemory input1 = createStorageBuffer(vkdi, device, allocator, m_inputBufferSize);
+ BufferWithMemory input2 = createStorageBuffer(vkdi, device, allocator, m_inputBufferSize);
+ BufferWithMemory output1 = createStorageBuffer(vkdi, device, allocator, m_outputBufferSize);
+
+ // Create an array of buffers.
+ std::vector<vk::VkBuffer> buffers;
+ buffers.push_back(input1.buffer.get());
+ buffers.push_back(input2.buffer.get());
+ buffers.push_back(output1.buffer.get());
+
+ // Create descriptor set layout.
+ std::vector<vk::VkDescriptorSetLayoutBinding> bindings;
+ for (size_t i = 0; i < buffers.size(); ++i)
+ {
+ vk::VkDescriptorSetLayoutBinding binding =
+ {
+ static_cast<deUint32>(i), // uint32_t binding;
+ vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // VkDescriptorType descriptorType;
+ 1u, // uint32_t descriptorCount;
+ static_cast<vk::VkShaderStageFlags>(m_params.stage), // VkShaderStageFlags stageFlags;
+ DE_NULL // const VkSampler* pImmutableSamplers;
+ };
+ bindings.push_back(binding);
+ }
+
+ const vk::VkDescriptorSetLayoutCreateInfo layoutCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkDescriptorSetLayoutCreateFlags flags;
+ static_cast<deUint32>(bindings.size()), // uint32_t bindingCount;
+ bindings.data() // const VkDescriptorSetLayoutBinding* pBindings;
+ };
+ auto descriptorSetLayout = vk::createDescriptorSetLayout(vkdi, device, &layoutCreateInfo);
+
+ // Create descriptor set.
+ vk::DescriptorPoolBuilder poolBuilder;
+ poolBuilder.addType(bindings[0].descriptorType, static_cast<deUint32>(bindings.size()));
+ auto descriptorPool = poolBuilder.build(vkdi, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
+
+ const vk::VkDescriptorSetAllocateInfo allocateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *descriptorPool, // VkDescriptorPool descriptorPool;
+ 1u, // uint32_t descriptorSetCount;
+ &descriptorSetLayout.get() // const VkDescriptorSetLayout* pSetLayouts;
+ };
+ auto descriptorSet = vk::allocateDescriptorSet(vkdi, device, &allocateInfo);
+
+ // Update descriptor set.
+ std::vector<vk::VkDescriptorBufferInfo> descriptorBufferInfos;
+ std::vector<vk::VkWriteDescriptorSet> descriptorWrites;
+
+ descriptorBufferInfos.reserve(buffers.size());
+ descriptorWrites.reserve(buffers.size());
+
+ for (size_t i = 0; i < buffers.size(); ++i)
+ {
+ vk::VkDescriptorBufferInfo bufferInfo =
+ {
+ buffers[i], // VkBuffer buffer;
+ 0u, // VkDeviceSize offset;
+ VK_WHOLE_SIZE, // VkDeviceSize range;
+ };
+ descriptorBufferInfos.push_back(bufferInfo);
+ }
+
+ for (size_t i = 0; i < buffers.size(); ++i)
+ {
+ vk::VkWriteDescriptorSet write =
+ {
+ vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *descriptorSet, // VkDescriptorSet dstSet;
+ static_cast<deUint32>(i), // uint32_t dstBinding;
+ 0u, // uint32_t dstArrayElement;
+ 1u, // uint32_t descriptorCount;
+ bindings[i].descriptorType, // VkDescriptorType descriptorType;
+ DE_NULL, // const VkDescriptorImageInfo* pImageInfo;
+ &descriptorBufferInfos[i], // const VkDescriptorBufferInfo* pBufferInfo;
+ DE_NULL, // const VkBufferView* pTexelBufferView;
+ };
+ descriptorWrites.push_back(write);
+ }
+ vkdi.updateDescriptorSets(device, static_cast<deUint32>(descriptorWrites.size()), descriptorWrites.data(), 0u, DE_NULL);
+
+ // Fill storage buffers with data. Note: VkPhysicalDeviceLimits.minMemoryMapAlignment guarantees this cast is safe.
+ T* input1Ptr = reinterpret_cast<T*> (input1.allocation->getHostPtr());
+ T* input2Ptr = reinterpret_cast<T*> (input2.allocation->getHostPtr());
+ int* output1Ptr = reinterpret_cast<int*> (output1.allocation->getHostPtr());
+
+ for (size_t i = 0; i < m_numOperations; ++i)
+ {
+ input1Ptr[i] = m_params.operands[i].first;
+ input2Ptr[i] = m_params.operands[i].second;
+ output1Ptr[i] = -9;
+ }
+
+ // Flush memory.
+ vk::flushAlloc(vkdi, device, *input1.allocation);
+ vk::flushAlloc(vkdi, device, *input2.allocation);
+ vk::flushAlloc(vkdi, device, *output1.allocation);
+
+ // Prepare barriers in advance so data is visible to the shaders and the host.
+ std::vector<vk::VkBufferMemoryBarrier> hostToDevBarriers;
+ std::vector<vk::VkBufferMemoryBarrier> devToHostBarriers;
+ for (size_t i = 0; i < buffers.size(); ++i)
+ {
+ const vk::VkBufferMemoryBarrier hostDev =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ vk::VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
+ (vk::VK_ACCESS_SHADER_READ_BIT | vk::VK_ACCESS_SHADER_WRITE_BIT), // VkAccessFlags dstAccessMask;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
+ buffers[i], // VkBuffer buffer;
+ 0u, // VkDeviceSize offset;
+ VK_WHOLE_SIZE, // VkDeviceSize size;
+ };
+ hostToDevBarriers.push_back(hostDev);
+
+ const vk::VkBufferMemoryBarrier devHost =
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ vk::VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags srcAccessMask;
+ vk::VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
+ VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
+ buffers[i], // VkBuffer buffer;
+ 0u, // VkDeviceSize offset;
+ VK_WHOLE_SIZE, // VkDeviceSize size;
+ };
+ devToHostBarriers.push_back(devHost);
+ }
+
+ // Create command pool and command buffer.
+ auto queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
+
+ const vk::VkCommandPoolCreateInfo cmdPoolCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ vk::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, // VkCommandPoolCreateFlags flags;
+ queueFamilyIndex, // deUint32 queueFamilyIndex;
+ };
+ auto cmdPool = vk::createCommandPool(vkdi, device, &cmdPoolCreateInfo);
+
+ const vk::VkCommandBufferAllocateInfo cmdBufferAllocateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *cmdPool, // VkCommandPool commandPool;
+ vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
+ 1u, // deUint32 commandBufferCount;
+ };
+ auto cmdBuffer = vk::allocateCommandBuffer(vkdi, device, &cmdBufferAllocateInfo);
+
+ // Create pipeline layout.
+ const vk::VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineLayoutCreateFlags flags;
+ 1u, // deUint32 setLayoutCount;
+ &descriptorSetLayout.get(), // const VkDescriptorSetLayout* pSetLayouts;
+ 0u, // deUint32 pushConstantRangeCount;
+ DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
+ };
+ auto pipelineLayout = vk::createPipelineLayout(vkdi, device, &pipelineLayoutCreateInfo);
+
+ if (m_params.stage == vk::VK_SHADER_STAGE_COMPUTE_BIT)
+ {
+ // Create compute pipeline.
+ auto compShaderModule = createShaderModule(vkdi, device, m_context.getBinaryCollection().get("comp"));
+
+ const vk::VkComputePipelineCreateInfo computeCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineCreateFlags flags;
+ { // VkPipelineShaderStageCreateInfo stage;
+ vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineShaderStageCreateFlags flags;
+ vk::VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage;
+ *compShaderModule, // VkShaderModule module;
+ "main", // const char* pName;
+ DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
+ },
+ *pipelineLayout, // VkPipelineLayout layout;
+ DE_NULL, // VkPipeline basePipelineHandle;
+ 0, // int32_t basePipelineIndex;
+ };
+ auto computePipeline = vk::createComputePipeline(vkdi, device, DE_NULL, &computeCreateInfo);
+
+ // Run the shader.
+ vk::beginCommandBuffer(vkdi, *cmdBuffer);
+ vkdi.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *computePipeline);
+ vkdi.cmdBindDescriptorSets(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, 1u, &descriptorSet.get(), 0u, DE_NULL);
+ vkdi.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0u, DE_NULL, static_cast<deUint32>(hostToDevBarriers.size()), hostToDevBarriers.data(), 0u, DE_NULL);
+ vkdi.cmdDispatch(*cmdBuffer, 1u, 1u, 1u);
+ vkdi.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 0u, DE_NULL, static_cast<deUint32>(devToHostBarriers.size()), devToHostBarriers.data(), 0u, DE_NULL);
+ vk::endCommandBuffer(vkdi, *cmdBuffer);
+ vk::submitCommandsAndWait(vkdi, device, m_context.getUniversalQueue(), *cmdBuffer);
+ }
+ else if (m_params.stage == vk::VK_SHADER_STAGE_VERTEX_BIT ||
+ m_params.stage == vk::VK_SHADER_STAGE_FRAGMENT_BIT )
+ {
+ const bool isFrag = (m_params.stage == vk::VK_SHADER_STAGE_FRAGMENT_BIT);
+
+ // Create graphics pipeline.
+ auto vertShaderModule = createShaderModule(vkdi, device, m_context.getBinaryCollection().get("vert"));
+ vk::Move<vk::VkShaderModule> fragShaderModule;
+ std::vector<vk::VkPipelineShaderStageCreateInfo> shaderStages;
+
+ const vk::VkPipelineShaderStageCreateInfo vertexStage =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineShaderStageCreateFlags flags;
+ vk::VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage;
+ *vertShaderModule, // VkShaderModule module;
+ "main", // const char* pName;
+ DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
+ };
+ shaderStages.push_back(vertexStage);
+
+ if (isFrag)
+ {
+ fragShaderModule = createShaderModule(vkdi, device, m_context.getBinaryCollection().get("frag"));
+
+ const vk::VkPipelineShaderStageCreateInfo fragmentStage =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineShaderStageCreateFlags flags;
+ vk::VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage;
+ *fragShaderModule, // VkShaderModule module;
+ "main", // const char* pName;
+ DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
+ };
+ shaderStages.push_back(fragmentStage);
+ }
+
+ const vk::VkPipelineVertexInputStateCreateInfo vertexInputInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineVertexInputStateCreateFlags flags;
+ 0u, // deUint32 vertexBindingDescriptionCount;
+ DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
+ 0u, // deUint32 vertexAttributeDescriptionCount;
+ DE_NULL, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
+ };
+
+ const vk::VkPipelineInputAssemblyStateCreateInfo inputAssembly =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // VkPipelineInputAssemblyStateCreateFlags flags;
+ vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // VkPrimitiveTopology topology;
+ VK_FALSE, // VkBool32 primitiveRestartEnable;
+ };
+
+ const vk::VkPipelineRasterizationStateCreateInfo rasterizationState =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineRasterizationStateCreateFlags flags;
+ VK_FALSE, // VkBool32 depthClampEnable;
+ (isFrag ? VK_FALSE : VK_TRUE), // VkBool32 rasterizerDiscardEnable;
+ vk::VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
+ vk::VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
+ vk::VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
+ VK_FALSE, // VkBool32 depthBiasEnable;
+ 0.0f, // float depthBiasConstantFactor;
+ 0.0f, // float depthBiasClamp;
+ 0.0f, // float depthBiasSlopeFactor;
+ 1.0f, // float lineWidth;
+ };
+
+ const vk::VkSubpassDescription subpassDescription =
+ {
+ 0, // VkSubpassDescriptionFlags flags;
+ vk::VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
+ 0u, // deUint32 inputAttachmentCount;
+ DE_NULL, // const VkAttachmentReference* pInputAttachments;
+ 0u, // deUint32 colorAttachmentCount;
+ DE_NULL, // const VkAttachmentReference* pColorAttachments;
+ DE_NULL, // const VkAttachmentReference* pResolveAttachments;
+ DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment;
+ 0u, // deUint32 preserveAttachmentCount;
+ 0u, // const deUint32* pPreserveAttachments;
+ };
+
+ const vk::VkRenderPassCreateInfo renderPassCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkRenderPassCreateFlags flags;
+ 0u, // deUint32 attachmentCount;
+ DE_NULL, // const VkAttachmentDescription* pAttachments;
+ 1u, // deUint32 subpassCount;
+ &subpassDescription, // const VkSubpassDescription* pSubpasses;
+ 0u, // deUint32 dependencyCount;
+ DE_NULL, // const VkSubpassDependency* pDependencies;
+ };
+ auto renderPass = vk::createRenderPass(vkdi, device, &renderPassCreateInfo);
+
+ std::unique_ptr<vk::VkPipelineMultisampleStateCreateInfo> multisampleState;
+ if (isFrag)
+ {
+ multisampleState.reset(new vk::VkPipelineMultisampleStateCreateInfo);
+ *multisampleState =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineMultisampleStateCreateFlags flags;
+ vk::VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
+ VK_FALSE, // VkBool32 sampleShadingEnable;
+ 0.0f, // float minSampleShading;
+ DE_NULL, // const VkSampleMask* pSampleMask;
+ VK_FALSE, // VkBool32 alphaToCoverageEnable;
+ VK_FALSE, // VkBool32 alphaToOneEnable;
+ };
+ }
+
+ const vk::VkViewport viewport =
+ {
+ 0.0f, // float x;
+ 0.0f, // float y;
+ 1.0f, // float width;
+ 1.0f, // float height;
+ 0.0f, // float minDepth;
+ 1.0f, // float maxDepth;
+ };
+
+ const vk::VkRect2D renderArea = { { 0u, 0u }, { 1u, 1u } };
+
+ std::unique_ptr<vk::VkPipelineViewportStateCreateInfo> viewportState;
+
+ if (isFrag)
+ {
+ viewportState.reset(new vk::VkPipelineViewportStateCreateInfo);
+ *viewportState =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineViewportStateCreateFlags flags;
+ 1u, // deUint32 viewportCount;
+ &viewport, // const VkViewport* pViewports;
+ 1u, // deUint32 scissorCount;
+ &renderArea, // const VkRect2D* pScissors;
+ };
+ }
+
+ const vk::VkGraphicsPipelineCreateInfo graphicsCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkPipelineCreateFlags flags;
+ static_cast<deUint32>(shaderStages.size()), // deUint32 stageCount;
+ shaderStages.data(), // const VkPipelineShaderStageCreateInfo* pStages;
+ &vertexInputInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
+ &inputAssembly, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
+ DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
+ viewportState.get(), // const VkPipelineViewportStateCreateInfo* pViewportState;
+ &rasterizationState, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
+ multisampleState.get(), // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
+ DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
+ DE_NULL, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
+ DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
+ *pipelineLayout, // VkPipelineLayout layout;
+ *renderPass, // VkRenderPass renderPass;
+ 0u, // deUint32 subpass;
+ DE_NULL, // VkPipeline basePipelineHandle;
+ 0u, // deInt32 basePipelineIndex;
+ };
+ auto graphicsPipeline = vk::createGraphicsPipeline(vkdi, device, DE_NULL, &graphicsCreateInfo);
+
+ const vk::VkFramebufferCreateInfo frameBufferCreateInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkFramebufferCreateFlags flags;
+ *renderPass, // VkRenderPass renderPass;
+ 0u, // deUint32 attachmentCount;
+ DE_NULL, // const VkImageView* pAttachments;
+ 1u, // deUint32 width;
+ 1u, // deUint32 height;
+ 1u, // deUint32 layers;
+ };
+ auto frameBuffer = vk::createFramebuffer(vkdi, device, &frameBufferCreateInfo);
+
+ const vk::VkRenderPassBeginInfo renderPassBeginInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ *renderPass, // VkRenderPass renderPass;
+ *frameBuffer, // VkFramebuffer framebuffer;
+ renderArea, // VkRect2D renderArea;
+ 0u, // deUint32 clearValueCount;
+ DE_NULL, // const VkClearValue* pClearValues;
+ };
+
+ // Run the shader.
+ vk::VkPipelineStageFlags pipelineStage = (isFrag ? vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT : vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT);
+
+ vk::beginCommandBuffer(vkdi, *cmdBuffer);
+ vkdi.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, pipelineStage, 0, 0u, DE_NULL, static_cast<deUint32>(hostToDevBarriers.size()), hostToDevBarriers.data(), 0u, DE_NULL);
+ vkdi.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, vk::VK_SUBPASS_CONTENTS_INLINE);
+ vkdi.cmdBindPipeline(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
+ vkdi.cmdBindDescriptorSets(*cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0, 1u, &descriptorSet.get(), 0u, DE_NULL);
+ vkdi.cmdDraw(*cmdBuffer, 1u, 1u, 0u, 0u);
+ vkdi.cmdEndRenderPass(*cmdBuffer);
+ vkdi.cmdPipelineBarrier(*cmdBuffer, pipelineStage, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 0u, DE_NULL, static_cast<deUint32>(devToHostBarriers.size()), devToHostBarriers.data(), 0u, DE_NULL);
+ vk::endCommandBuffer(vkdi, *cmdBuffer);
+ vk::submitCommandsAndWait(vkdi, device, m_context.getUniversalQueue(), *cmdBuffer);
+ }
+
+ // Invalidate allocations.
+ vk::invalidateAlloc(vkdi, device, *input1.allocation);
+ vk::invalidateAlloc(vkdi, device, *input2.allocation);
+ vk::invalidateAlloc(vkdi, device, *output1.allocation);
+
+ // Read and verify results.
+ std::vector<int> results(m_numOperations);
+ deMemcpy(results.data(), output1.allocation->getHostPtr(), m_outputBufferSize);
+ for (size_t i = 0; i < m_numOperations; ++i)
+ {
+ int expected = static_cast<int>(m_params.operation.run(m_params.operands[i].first, m_params.operands[i].second));
+ if (results[i] != expected)
+ {
+ std::ostringstream msg;
+ msg << "Invalid result found in position " << i << ": expected " << expected << " and found " << results[i];
+ return tcu::TestStatus::fail(msg.str());
+ }
+ }
+
+ return tcu::TestStatus::pass("Pass");
+}
+
+template <class T>
+class T64bitCompareTest : public TestCase
+{
+public:
+ T64bitCompareTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TestParameters<T>& params);
+ virtual void checkSupport (Context& context) const;
+ virtual void initPrograms (vk::SourceCollections& programCollection) const;
+ virtual TestInstance* createInstance (Context& ctx) const;
+
+private:
+ const TestParameters<T> m_params;
+};
+
+template <class T>
+T64bitCompareTest<T>::T64bitCompareTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TestParameters<T>& params)
+ : TestCase(testCtx, name, description), m_params(params)
+{
+ // This is needed so that the same operands can be used for single-element comparisons or for vectorized comparisons (which use *vec4 types).
+ DE_ASSERT(m_params.operands.size() % 4 == 0);
+}
+
+// This template checks the needed type support features in shaders for type T.
+// Specializations are provided below.
+template <class T>
+void checkTypeSupport(const vk::VkPhysicalDeviceFeatures& features);
+
+template <>
+void checkTypeSupport<double>(const vk::VkPhysicalDeviceFeatures& features)
+{
+ if (!features.shaderFloat64)
+ TCU_THROW(NotSupportedError, "64-bit floats not supported in shaders");
+}
+
+void check64bitIntegers(const vk::VkPhysicalDeviceFeatures& features)
+{
+ if (!features.shaderInt64)
+ TCU_THROW(NotSupportedError, "64-bit integer types not supported in shaders");
+}
+
+template <>
+void checkTypeSupport<deInt64>(const vk::VkPhysicalDeviceFeatures& features)
+{
+ check64bitIntegers(features);
+}
+
+template <>
+void checkTypeSupport<deUint64>(const vk::VkPhysicalDeviceFeatures& features)
+{
+ check64bitIntegers(features);
+}
+
+template <class T>
+void T64bitCompareTest<T>::checkSupport (Context& context) const
+{
+ auto& vki = context.getInstanceInterface();
+ auto physicalDevice = context.getPhysicalDevice();
+ auto features = vk::getPhysicalDeviceFeatures(vki, physicalDevice);
+
+ checkTypeSupport<T>(features);
+
+ switch (m_params.stage)
+ {
+ case vk::VK_SHADER_STAGE_COMPUTE_BIT:
+ break;
+ case vk::VK_SHADER_STAGE_VERTEX_BIT:
+ if (!features.vertexPipelineStoresAndAtomics)
+ TCU_THROW(NotSupportedError, "Vertex shader does not support stores");
+ break;
+ case vk::VK_SHADER_STAGE_FRAGMENT_BIT:
+ if (!features.fragmentStoresAndAtomics)
+ TCU_THROW(NotSupportedError, "Fragment shader does not support stores");
+ break;
+ default:
+ DE_ASSERT(DE_NULL == "Invalid shader stage specified");
+ }
+}
+
+template <class T>
+void T64bitCompareTest<T>::initPrograms (vk::SourceCollections& programCollection) const
+{
+ DE_ASSERT(m_params.stage == vk::VK_SHADER_STAGE_COMPUTE_BIT ||
+ m_params.stage == vk::VK_SHADER_STAGE_VERTEX_BIT ||
+ m_params.stage == vk::VK_SHADER_STAGE_FRAGMENT_BIT );
+
+ std::map<std::string, std::string> replacements;
+ replacements["ITERS"] = de::toString((m_params.dataType == DATA_TYPE_SINGLE) ? m_params.operands.size() : m_params.operands.size() / 4);
+ replacements["OPNAME"] = m_params.operation.spirvName();
+ replacements["OPCAPABILITY"] = SpirvTemplateManager::getOpCapability<T>();
+ replacements["OPTYPE"] = SpirvTemplateManager::getOpType<T>();
+
+ static const std::map<vk::VkShaderStageFlagBits, std::string> sourceNames =
+ {
+ std::make_pair( vk::VK_SHADER_STAGE_COMPUTE_BIT, "comp" ),
+ std::make_pair( vk::VK_SHADER_STAGE_VERTEX_BIT, "vert" ),
+ std::make_pair( vk::VK_SHADER_STAGE_FRAGMENT_BIT, "frag" ),
+ };
+
+ // Add the proper template under the proper name.
+ programCollection.spirvAsmSources.add(sourceNames.find(m_params.stage)->second) << SpirvTemplateManager::getTemplate(m_params.dataType, m_params.stage).specialize(replacements);
+
+ // Add the passthrough vertex shader needed for the fragment shader.
+ if (m_params.stage == vk::VK_SHADER_STAGE_FRAGMENT_BIT)
+ programCollection.glslSources.add("vert") << glu::VertexSource(VertShaderPassThrough);
+}
+
+template <class T>
+TestInstance* T64bitCompareTest<T>::createInstance (Context& ctx) const
+{
+ return new T64bitCompareTestInstance<T>(ctx, m_params);
+}
+
+const std::map<DataType, std::string> dataTypeName =
+{
+ std::make_pair(DATA_TYPE_SINGLE, "single"),
+ std::make_pair(DATA_TYPE_VECTOR, "vector"),
+};
+
+using StageName = std::map<vk::VkShaderStageFlagBits, std::string>;
+
+void createDoubleCompareTestsInGroup (tcu::TestCaseGroup* tests, const StageName* stageNames)
+{
+ static const std::vector<const CompareOperation<double>*> operationList =
+ {
+ // Ordered operations.
+ &FOrderedEqualOp,
+ &FOrderedNotEqualOp,
+ &FOrderedLessThanOp,
+ &FOrderedLessThanEqualOp,
+ &FOrderedGreaterThanOp,
+ &FOrderedGreaterThanEqualOp,
+ // Unordered operations.
+ &FUnorderedEqualOp,
+ &FUnorderedNotEqualOp,
+ &FUnorderedLessThanOp,
+ &FUnorderedLessThanEqualOp,
+ &FUnorderedGreaterThanOp,
+ &FUnorderedGreaterThanEqualOp,
+ };
+
+ for (const auto& stageNamePair : *stageNames)
+ for (const auto& typeNamePair : dataTypeName)
+ for (const auto opPtr : operationList)
+ {
+ TestParameters<double> params = { typeNamePair.first, *opPtr, stageNamePair.first, DOUBLE_OPERANDS };
+ std::string testName = stageNamePair.second + "_" + de::toLower(opPtr->spirvName()) + "_" + typeNamePair.second;
+ tests->addChild(new T64bitCompareTest<double>(tests->getTestContext(), testName, "", params));
+ }
+}
+
+void createInt64CompareTestsInGroup (tcu::TestCaseGroup* tests, const StageName* stageNames)
+{
+ static const std::vector<const CompareOperation<deInt64>*> operationList =
+ {
+ &deInt64EqualOp,
+ &deInt64NotEqualOp,
+ &deInt64LessThanOp,
+ &deInt64LessThanEqualOp,
+ &deInt64GreaterThanOp,
+ &deInt64GreaterThanEqualOp,
+ };
+
+ for (const auto& stageNamePair : *stageNames)
+ for (const auto& typeNamePair : dataTypeName)
+ for (const auto opPtr : operationList)
+ {
+ TestParameters<deInt64> params = { typeNamePair.first, *opPtr, stageNamePair.first, INT64_OPERANDS };
+ std::string testName = stageNamePair.second + "_" + de::toLower(opPtr->spirvName()) + "_" + typeNamePair.second;
+ tests->addChild(new T64bitCompareTest<deInt64>(tests->getTestContext(), testName, "", params));
+ }
+}
+
+void createUint64CompareTestsInGroup (tcu::TestCaseGroup* tests, const StageName* stageNames)
+{
+ static const std::vector<const CompareOperation<deUint64>*> operationList =
+ {
+ &deUint64EqualOp,
+ &deUint64NotEqualOp,
+ &deUint64LessThanOp,
+ &deUint64LessThanEqualOp,
+ &deUint64GreaterThanOp,
+ &deUint64GreaterThanEqualOp,
+ };
+
+ for (const auto& stageNamePair : *stageNames)
+ for (const auto& typeNamePair : dataTypeName)
+ for (const auto opPtr : operationList)
+ {
+ TestParameters<deUint64> params = { typeNamePair.first, *opPtr, stageNamePair.first, UINT64_OPERANDS };
+ std::string testName = stageNamePair.second + "_" + de::toLower(opPtr->spirvName()) + "_" + typeNamePair.second;
+ tests->addChild(new T64bitCompareTest<deUint64>(tests->getTestContext(), testName, "", params));
+ }
+}
+
+struct TestMgr
+{
+ typedef void (*CreationFunctionPtr)(tcu::TestCaseGroup*, const StageName*);
+
+ static const char* getParentGroupName () { return "64bit_compare"; }
+ static const char* getParentGroupDesc () { return "64-bit type comparison operations"; }
+
+ template <class T>
+ static std::string getGroupName ();
+
+ template <class T>
+ static std::string getGroupDesc ();
+
+ template <class T>
+ static CreationFunctionPtr getCreationFunction ();
+};
+
+template <> std::string TestMgr::getGroupName<double>() { return "double"; }
+template <> std::string TestMgr::getGroupName<deInt64>() { return "int64"; }
+template <> std::string TestMgr::getGroupName<deUint64>() { return "uint64"; }
+
+template <> std::string TestMgr::getGroupDesc<double>() { return "64-bit floating point tests"; }
+template <> std::string TestMgr::getGroupDesc<deInt64>() { return "64-bit signed integer tests"; }
+template <> std::string TestMgr::getGroupDesc<deUint64>() { return "64-bit unsigned integer tests"; }
+
+template <> TestMgr::CreationFunctionPtr TestMgr::getCreationFunction<double> () { return createDoubleCompareTestsInGroup; }
+template <> TestMgr::CreationFunctionPtr TestMgr::getCreationFunction<deInt64> () { return createInt64CompareTestsInGroup; }
+template <> TestMgr::CreationFunctionPtr TestMgr::getCreationFunction<deUint64> () { return createUint64CompareTestsInGroup; }
+
+} // anonymous
+
+tcu::TestCaseGroup* create64bitCompareGraphicsGroup (tcu::TestContext& testCtx)
+{
+ static const StageName graphicStages =
+ {
+ std::make_pair(vk::VK_SHADER_STAGE_VERTEX_BIT, "vert"),
+ std::make_pair(vk::VK_SHADER_STAGE_FRAGMENT_BIT, "frag"),
+ };
+
+ tcu::TestCaseGroup* newGroup = new tcu::TestCaseGroup(testCtx, TestMgr::getParentGroupName(), TestMgr::getParentGroupDesc());
+ newGroup->addChild(createTestGroup(testCtx, TestMgr::getGroupName<double>(), TestMgr::getGroupDesc<double>(), TestMgr::getCreationFunction<double>(), &graphicStages));
+ newGroup->addChild(createTestGroup(testCtx, TestMgr::getGroupName<deInt64>(), TestMgr::getGroupDesc<deInt64>(), TestMgr::getCreationFunction<deInt64>(), &graphicStages));
+ newGroup->addChild(createTestGroup(testCtx, TestMgr::getGroupName<deUint64>(), TestMgr::getGroupDesc<deUint64>(), TestMgr::getCreationFunction<deUint64>(), &graphicStages));
+ return newGroup;
+}
+
+tcu::TestCaseGroup* create64bitCompareComputeGroup (tcu::TestContext& testCtx)
+{
+ static const StageName computeStages =
+ {
+ std::make_pair(vk::VK_SHADER_STAGE_COMPUTE_BIT, "comp"),
+ };
+
+ tcu::TestCaseGroup* newGroup = new tcu::TestCaseGroup(testCtx, TestMgr::getParentGroupName(), TestMgr::getParentGroupDesc());
+ newGroup->addChild(createTestGroup(testCtx, TestMgr::getGroupName<double>(), TestMgr::getGroupDesc<double>(), TestMgr::getCreationFunction<double>(), &computeStages));
+ newGroup->addChild(createTestGroup(testCtx, TestMgr::getGroupName<deInt64>(), TestMgr::getGroupDesc<deInt64>(), TestMgr::getCreationFunction<deInt64>(), &computeStages));
+ newGroup->addChild(createTestGroup(testCtx, TestMgr::getGroupName<deUint64>(), TestMgr::getGroupDesc<deUint64>(), TestMgr::getCreationFunction<deUint64>(), &computeStages));
+ return newGroup;
+}
+
+} // SpirVAssembly
+} // vkt
projects / platform / upstream / VK-GL-CTS.git / commitdiff