| // Copyright (c) 2022 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. |
| |
| #include <string> |
| #include <vector> |
| |
| #include "gmock/gmock.h" |
| #include "test/val/val_fixtures.h" |
| |
| namespace spvtools { |
| namespace val { |
| namespace { |
| |
| using ::testing::HasSubstr; |
| using ::testing::Values; |
| using ::testing::ValuesIn; |
| |
| struct Case { |
| std::vector<std::string> caps; |
| bool shader; |
| std::string result_type; |
| std::string scope; |
| std::string delta; |
| std::string cluster_size; |
| std::string expected_error; // empty for no error. |
| }; |
| |
| inline std::ostream& operator<<(std::ostream& out, Case c) { |
| out << "\nSPV_KHR_subgroup_rotate Case{{"; |
| for (auto& cap : c.caps) { |
| out << cap; |
| } |
| out << "} "; |
| out << (c.shader ? "shader " : "kernel "); |
| out << c.result_type + " "; |
| out << c.scope + " "; |
| out << c.delta + " "; |
| out << c.cluster_size + " "; |
| out << "err'" << c.expected_error << "'"; |
| out << "}"; |
| return out; |
| } |
| |
| std::string AssemblyForCase(const Case& c) { |
| std::ostringstream ss; |
| |
| if (c.shader) { |
| ss << "OpCapability Shader\n"; |
| } else { |
| ss << "OpCapability Kernel\n"; |
| ss << "OpCapability Addresses\n"; |
| } |
| for (auto& cap : c.caps) { |
| ss << "OpCapability " << cap << "\n"; |
| } |
| ss << "OpExtension \"SPV_KHR_subgroup_rotate\"\n"; |
| |
| if (c.shader) { |
| ss << "OpMemoryModel Logical GLSL450\n"; |
| ss << "OpEntryPoint GLCompute %main \"main\"\n"; |
| } else { |
| ss << "OpMemoryModel Physical32 OpenCL\n"; |
| ss << "OpEntryPoint Kernel %main \"main\"\n"; |
| } |
| |
| ss << R"( |
| %void = OpTypeVoid |
| %void_fn = OpTypeFunction %void |
| %u32 = OpTypeInt 32 0 |
| %float = OpTypeFloat 32 |
| %ptr = OpTypePointer Function %u32 |
| )"; |
| |
| if (c.shader) { |
| ss << "%i32 = OpTypeInt 32 1\n"; |
| } |
| |
| ss << R"( |
| %u32_0 = OpConstant %u32 0 |
| %u32_1 = OpConstant %u32 1 |
| %u32_15 = OpConstant %u32 15 |
| %u32_16 = OpConstant %u32 16 |
| %u32_undef = OpUndef %u32 |
| %u32_spec_1 = OpSpecConstant %u32 1 |
| %u32_spec_16 = OpSpecConstant %u32 16 |
| %f32_1 = OpConstant %float 1.0 |
| %subgroup = OpConstant %u32 3 |
| %workgroup = OpConstant %u32 2 |
| %invalid_scope = OpConstant %u32 1 |
| %val = OpConstant %u32 42 |
| )"; |
| |
| if (c.shader) { |
| ss << "%i32_1 = OpConstant %i32 1\n"; |
| } |
| |
| ss << R"( |
| %main = OpFunction %void None %void_fn |
| %entry = OpLabel |
| )"; |
| |
| ss << "%unused = OpGroupNonUniformRotateKHR "; |
| ss << c.result_type + " "; |
| ss << c.scope; |
| ss << " %val "; |
| ss << c.delta; |
| ss << " " + c.cluster_size; |
| ss << "\n"; |
| |
| ss << R"( |
| OpReturn |
| OpFunctionEnd |
| )"; |
| |
| return ss.str(); |
| } |
| |
| using ValidateSpvKHRSubgroupRotate = spvtest::ValidateBase<Case>; |
| |
| TEST_P(ValidateSpvKHRSubgroupRotate, Base) { |
| const auto& c = GetParam(); |
| const auto& assembly = AssemblyForCase(c); |
| CompileSuccessfully(assembly); |
| if (c.expected_error.empty()) { |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()) << getDiagnosticString(); |
| } else { |
| EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); |
| EXPECT_THAT(getDiagnosticString(), HasSubstr(c.expected_error)); |
| } |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| Valid, ValidateSpvKHRSubgroupRotate, |
| ::testing::Values( |
| Case{ |
| {"GroupNonUniformRotateKHR"}, false, "%u32", "%subgroup", "%u32_1"}, |
| Case{{"GroupNonUniformRotateKHR"}, true, "%u32", "%subgroup", "%u32_1"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%u32_16"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%u32_16"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%u32", |
| "%subgroup", |
| "%u32_spec_1", |
| "%u32_16"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%u32_spec_16"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%u32", |
| "%workgroup", |
| "%u32_1"}, |
| Case{ |
| {"GroupNonUniformRotateKHR"}, true, "%u32", "%workgroup", "%u32_1"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%u32", |
| "%workgroup", |
| "%u32_spec_1"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%workgroup", |
| "%u32_spec_1"})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| RequiresCapability, ValidateSpvKHRSubgroupRotate, |
| ::testing::Values(Case{{}, |
| false, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "", |
| "Opcode GroupNonUniformRotateKHR requires one of " |
| "these capabilities: " |
| "GroupNonUniformRotateKHR"}, |
| Case{{}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "", |
| "Opcode GroupNonUniformRotateKHR requires one of " |
| "these capabilities: " |
| "GroupNonUniformRotateKHR"})); |
| |
| TEST_F(ValidateSpvKHRSubgroupRotate, RequiresExtension) { |
| const std::string str = R"( |
| OpCapability GroupNonUniformRotateKHR |
| )"; |
| CompileSuccessfully(str.c_str()); |
| EXPECT_NE(SPV_SUCCESS, ValidateInstructions()); |
| EXPECT_THAT( |
| getDiagnosticString(), |
| HasSubstr( |
| "1st operand of Capability: operand GroupNonUniformRotateKHR(6026) " |
| "requires one of these extensions: SPV_KHR_subgroup_rotate")); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvalidExecutionScope, ValidateSpvKHRSubgroupRotate, |
| ::testing::Values( |
| Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%u32", |
| "%invalid_scope", |
| "%u32_1", |
| "", |
| "Execution scope is limited to Subgroup or Workgroup"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%invalid_scope", |
| "%u32_1", |
| "", |
| "Execution scope is limited to Subgroup or Workgroup"})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvalidResultType, ValidateSpvKHRSubgroupRotate, |
| ::testing::Values(Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%ptr", |
| "%subgroup", |
| "%u32_1", |
| "", |
| "Expected Result Type to be a scalar or vector of " |
| "floating-point, integer or boolean type"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%ptr", |
| "%subgroup", |
| "%u32_1", |
| "", |
| "Expected Result Type to be a scalar or vector of " |
| "floating-point, integer or boolean type"})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| MismatchedResultAndValueTypes, ValidateSpvKHRSubgroupRotate, |
| ::testing::Values( |
| Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%float", |
| "%subgroup", |
| "%u32_1", |
| "", |
| "Result Type must be the same as the type of Value"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%float", |
| "%subgroup", |
| "%u32_1", |
| "", |
| "Result Type must be the same as the type of Value"})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvalidDelta, ValidateSpvKHRSubgroupRotate, |
| ::testing::Values(Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%u32", |
| "%subgroup", |
| "%f32_1", |
| "", |
| "Delta must be a scalar of integer type, whose " |
| "Signedness operand is 0"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%f32_1", |
| "", |
| "Delta must be a scalar of integer type, whose " |
| "Signedness operand is 0"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%i32_1", |
| "", |
| "Delta must be a scalar of integer type, whose " |
| "Signedness operand is 0"})); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| InvalidClusterSize, ValidateSpvKHRSubgroupRotate, |
| ::testing::Values( |
| Case{{"GroupNonUniformRotateKHR"}, |
| false, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%f32_1", |
| "ClusterSize must be a scalar of integer type, whose Signedness " |
| "operand is 0"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%i32_1", |
| "ClusterSize must be a scalar of integer type, whose Signedness " |
| "operand is 0"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%u32_0", |
| "Behavior is undefined unless ClusterSize is at least 1 and a " |
| "power of 2"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%u32_15", |
| "Behavior is undefined unless ClusterSize is at least 1 and a " |
| "power of 2"}, |
| Case{{"GroupNonUniformRotateKHR"}, |
| true, |
| "%u32", |
| "%subgroup", |
| "%u32_1", |
| "%u32_undef", |
| "ClusterSize must come from a constant instruction"})); |
| |
| } // namespace |
| } // namespace val |
| } // namespace spvtools |
