blob: 93bf70d49e40e00c2d16077d9abf81baeb787218 [file] [log] [blame]
Michael Lentine83ab3412015-11-03 16:20:30 -08001// VK tests
2//
Nathaniel Cesario022e7b22021-04-06 00:06:17 -06003// Copyright (c) 2015-2021 The Khronos Group Inc.
4// Copyright (c) 2015-2021 Valve Corporation
5// Copyright (c) 2015-2021 LunarG, Inc.
6// Copyright (c) 2015-2021 Google, Inc.
Michael Lentine83ab3412015-11-03 16:20:30 -08007//
Jon Ashburn3ebf1252016-04-19 11:30:31 -06008// Licensed under the Apache License, Version 2.0 (the "License");
9// you may not use this file except in compliance with the License.
10// You may obtain a copy of the License at
Michael Lentine83ab3412015-11-03 16:20:30 -080011//
Jon Ashburn3ebf1252016-04-19 11:30:31 -060012// http://www.apache.org/licenses/LICENSE-2.0
Michael Lentine83ab3412015-11-03 16:20:30 -080013//
Jon Ashburn3ebf1252016-04-19 11:30:31 -060014// Unless required by applicable law or agreed to in writing, software
15// distributed under the License is distributed on an "AS IS" BASIS,
16// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17// See the License for the specific language governing permissions and
18// limitations under the License.
Michael Lentine83ab3412015-11-03 16:20:30 -080019
20#include "vktestframeworkandroid.h"
Nathaniel Cesarioe1f91ba2021-08-19 14:06:11 -060021#include "vkrenderframework.h"
Cody Northrop8e54a402016-03-08 22:25:52 -070022#include "shaderc/shaderc.hpp"
23#include <android/log.h>
Michael Lentine83ab3412015-11-03 16:20:30 -080024
25VkTestFramework::VkTestFramework() {}
26VkTestFramework::~VkTestFramework() {}
27
Tobin Ehlis72888642017-11-15 09:43:56 -070028// Define static elements
29bool VkTestFramework::m_devsim_layer = false;
Nathaniel Cesario022e7b22021-04-06 00:06:17 -060030int VkTestFramework::m_phys_device_index = -1;
Locke5ddafd92019-03-20 10:11:33 -060031ANativeWindow *VkTestFramework::window = nullptr;
Tobin Ehlis72888642017-11-15 09:43:56 -070032
Mark Lobodzinskic6a62142016-09-07 16:35:55 -060033VkFormat VkTestFramework::GetFormat(VkInstance instance, vk_testing::Device *device) {
Michael Lentineb62cc052015-12-09 08:44:25 -080034 VkFormatProperties format_props;
Mark Lobodzinski1ad400e2019-09-27 13:53:29 -060035 vk::GetPhysicalDeviceFormatProperties(device->phy().handle(), VK_FORMAT_B8G8R8A8_UNORM, &format_props);
Michael Lentineb62cc052015-12-09 08:44:25 -080036 if (format_props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT ||
Mark Lobodzinskic6a62142016-09-07 16:35:55 -060037 format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
Michael Lentineb62cc052015-12-09 08:44:25 -080038 return VK_FORMAT_B8G8R8A8_UNORM;
39 }
Mark Lobodzinski1ad400e2019-09-27 13:53:29 -060040 vk::GetPhysicalDeviceFormatProperties(device->phy().handle(), VK_FORMAT_R8G8B8A8_UNORM, &format_props);
Michael Lentineb62cc052015-12-09 08:44:25 -080041 if (format_props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT ||
Mark Lobodzinskic6a62142016-09-07 16:35:55 -060042 format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
Michael Lentineb62cc052015-12-09 08:44:25 -080043 return VK_FORMAT_R8G8B8A8_UNORM;
44 }
45 printf("Error - device does not support VK_FORMAT_B8G8R8A8_UNORM nor VK_FORMAT_R8G8B8A8_UNORM - exiting\n");
46 exit(0);
47}
48
Michael Lentine83ab3412015-11-03 16:20:30 -080049void VkTestFramework::InitArgs(int *argc, char *argv[]) {}
50void VkTestFramework::Finish() {}
51
Mark Lobodzinski91ee16c2019-09-27 11:44:52 -060052void TestEnvironment::SetUp() {
53 vk_testing::set_error_callback(test_error_callback);
54
55 vk::InitDispatchTable();
56}
Michael Lentine83ab3412015-11-03 16:20:30 -080057
58void TestEnvironment::TearDown() {}
Cody Northrop8e54a402016-03-08 22:25:52 -070059
Cody Northrop8e54a402016-03-08 22:25:52 -070060// Android specific helper functions for shaderc.
61struct shader_type_mapping {
62 VkShaderStageFlagBits vkshader_type;
63 shaderc_shader_kind shaderc_type;
64};
65
66static const shader_type_mapping shader_map_table[] = {
Mark Lobodzinskic6a62142016-09-07 16:35:55 -060067 {VK_SHADER_STAGE_VERTEX_BIT, shaderc_glsl_vertex_shader},
68 {VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, shaderc_glsl_tess_control_shader},
69 {VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, shaderc_glsl_tess_evaluation_shader},
70 {VK_SHADER_STAGE_GEOMETRY_BIT, shaderc_glsl_geometry_shader},
71 {VK_SHADER_STAGE_FRAGMENT_BIT, shaderc_glsl_fragment_shader},
72 {VK_SHADER_STAGE_COMPUTE_BIT, shaderc_glsl_compute_shader},
Cody Northrop8e54a402016-03-08 22:25:52 -070073};
74
75shaderc_shader_kind MapShadercType(VkShaderStageFlagBits vkShader) {
76 for (auto shader : shader_map_table) {
77 if (shader.vkshader_type == vkShader) {
78 return shader.shaderc_type;
79 }
80 }
81 assert(false);
82 return shaderc_glsl_infer_from_source;
83}
84
85// Compile a given string containing GLSL into SPIR-V
86// Return value of false means an error was encountered
Mark Lobodzinskif0003442019-10-28 16:05:32 -060087bool VkTestFramework::GLSLtoSPV(VkPhysicalDeviceLimits const *const device_limits, const VkShaderStageFlagBits shader_type,
sfricke-samsung5a8ea0b2021-09-03 09:46:08 -070088 const char *pshader, std::vector<uint32_t> &spirv, bool debug, const spv_target_env spv_env) {
Cody Northrop8e54a402016-03-08 22:25:52 -070089 // On Android, use shaderc instead.
90 shaderc::Compiler compiler;
Karl Schultz6c009e52019-01-14 19:21:05 -070091 shaderc::CompileOptions options;
92 if (debug) {
93 options.SetOptimizationLevel(shaderc_optimization_level_zero);
94 options.SetGenerateDebugInfo();
95 }
Jeff Bolz49d64982019-09-18 13:18:14 -050096
sfricke-samsunge6e56b62021-08-20 10:14:37 -070097 switch (spv_env) {
Jeff Bolz49d64982019-09-18 13:18:14 -050098 default:
sfricke-samsunge6e56b62021-08-20 10:14:37 -070099 case SPV_ENV_VULKAN_1_0:
100 case SPV_ENV_UNIVERSAL_1_0:
Jeff Bolz49d64982019-09-18 13:18:14 -0500101 options.SetTargetSpirv(shaderc_spirv_version_1_0);
102 break;
sfricke-samsunge6e56b62021-08-20 10:14:37 -0700103 case SPV_ENV_UNIVERSAL_1_1:
Jeff Bolz49d64982019-09-18 13:18:14 -0500104 options.SetTargetSpirv(shaderc_spirv_version_1_1);
105 break;
sfricke-samsunge6e56b62021-08-20 10:14:37 -0700106 case SPV_ENV_UNIVERSAL_1_2:
Jeff Bolz49d64982019-09-18 13:18:14 -0500107 options.SetTargetSpirv(shaderc_spirv_version_1_2);
108 break;
sfricke-samsunge6e56b62021-08-20 10:14:37 -0700109 case SPV_ENV_VULKAN_1_1:
110 case SPV_ENV_UNIVERSAL_1_3:
Jeff Bolz49d64982019-09-18 13:18:14 -0500111 options.SetTargetSpirv(shaderc_spirv_version_1_3);
112 break;
sfricke-samsunge6e56b62021-08-20 10:14:37 -0700113 case SPV_ENV_UNIVERSAL_1_4:
Jeff Bolz49d64982019-09-18 13:18:14 -0500114 options.SetTargetSpirv(shaderc_spirv_version_1_4);
115 break;
sfricke-samsunge6e56b62021-08-20 10:14:37 -0700116 case SPV_ENV_VULKAN_1_2:
117 case SPV_ENV_UNIVERSAL_1_5:
118 options.SetTargetSpirv(shaderc_spirv_version_1_5);
119 break;
Jeff Bolz49d64982019-09-18 13:18:14 -0500120 }
121
Mark Lobodzinskif0003442019-10-28 16:05:32 -0600122 // Override glslang built-in GL settings with actual hardware values
123 options.SetLimit(shaderc_limit_max_clip_distances, device_limits->maxClipDistances);
124 options.SetLimit(shaderc_limit_max_compute_work_group_count_x, device_limits->maxComputeWorkGroupCount[0]);
125 options.SetLimit(shaderc_limit_max_compute_work_group_count_y, device_limits->maxComputeWorkGroupCount[1]);
126 options.SetLimit(shaderc_limit_max_compute_work_group_count_z, device_limits->maxComputeWorkGroupCount[2]);
127 options.SetLimit(shaderc_limit_max_compute_work_group_size_x, device_limits->maxComputeWorkGroupSize[0]);
128 options.SetLimit(shaderc_limit_max_compute_work_group_size_y, device_limits->maxComputeWorkGroupSize[1]);
129 options.SetLimit(shaderc_limit_max_compute_work_group_size_z, device_limits->maxComputeWorkGroupSize[2]);
130 options.SetLimit(shaderc_limit_max_cull_distances, device_limits->maxCullDistances);
131 options.SetLimit(shaderc_limit_max_fragment_input_components, device_limits->maxFragmentInputComponents);
132 options.SetLimit(shaderc_limit_max_geometry_input_components, device_limits->maxGeometryInputComponents);
133 options.SetLimit(shaderc_limit_max_geometry_output_components, device_limits->maxGeometryOutputComponents);
134 options.SetLimit(shaderc_limit_max_geometry_output_vertices, device_limits->maxGeometryOutputVertices);
135 options.SetLimit(shaderc_limit_max_geometry_total_output_components, device_limits->maxGeometryTotalOutputComponents);
136 options.SetLimit(shaderc_limit_max_vertex_output_components, device_limits->maxVertexOutputComponents);
137 options.SetLimit(shaderc_limit_max_viewports, device_limits->maxViewports);
138
Mark Lobodzinskic6a62142016-09-07 16:35:55 -0600139 shaderc::SpvCompilationResult result =
Karl Schultz6c009e52019-01-14 19:21:05 -0700140 compiler.CompileGlslToSpv(pshader, strlen(pshader), MapShadercType(shader_type), "shader", options);
Cody Northrop8e54a402016-03-08 22:25:52 -0700141 if (result.GetCompilationStatus() != shaderc_compilation_status_success) {
Mark Lobodzinski4e1a2f32019-10-23 11:17:41 -0600142 __android_log_print(ANDROID_LOG_ERROR, "VulkanLayerValidationTests", "GLSLtoSPV compilation failed: %s",
Cody Northrop10133102018-09-25 09:02:03 -0600143 result.GetErrorMessage().c_str());
Cody Northrop8e54a402016-03-08 22:25:52 -0700144 return false;
145 }
146
147 for (auto iter = result.begin(); iter != result.end(); iter++) {
148 spirv.push_back(*iter);
149 }
150
151 return true;
152}
Karl Schultz23707622018-08-22 10:20:33 -0600153
154//
155// Compile a given string containing SPIR-V assembly into SPV for use by VK
156// Return value of false means an error was encountered.
157//
158bool VkTestFramework::ASMtoSPV(const spv_target_env target_env, const uint32_t options, const char *pasm,
sfricke-samsung5a8ea0b2021-09-03 09:46:08 -0700159 std::vector<uint32_t> &spv) {
Karl Schultz23707622018-08-22 10:20:33 -0600160 spv_binary binary;
161 spv_diagnostic diagnostic = nullptr;
162 spv_context context = spvContextCreate(target_env);
163 spv_result_t error = spvTextToBinaryWithOptions(context, pasm, strlen(pasm), options, &binary, &diagnostic);
164 spvContextDestroy(context);
165 if (error) {
166 __android_log_print(ANDROID_LOG_ERROR, "VkLayerValidationTest", "ASMtoSPV compilation failed");
167 spvDiagnosticDestroy(diagnostic);
168 return false;
169 }
170 spv.insert(spv.end(), binary->code, binary->code + binary->wordCount);
171 spvBinaryDestroy(binary);
172
173 return true;
174}