Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 1 | #!/usr/bin/env python3 |
| 2 | |
Hans-Kristian Arntzen | 4704482 | 2021-01-14 16:07:49 +0100 | [diff] [blame] | 3 | # Copyright 2015-2021 Arm Limited |
Jon Leech | f2a6554 | 2021-05-08 01:47:48 -0700 | [diff] [blame] | 4 | # SPDX-License-Identifier: Apache-2.0 |
Hans-Kristian Arntzen | f9818f0 | 2020-01-16 15:24:37 +0100 | [diff] [blame] | 5 | # |
| 6 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 7 | # you may not use this file except in compliance with the License. |
| 8 | # You may obtain a copy of the License at |
| 9 | # |
| 10 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 11 | # |
| 12 | # Unless required by applicable law or agreed to in writing, software |
| 13 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 15 | # See the License for the specific language governing permissions and |
| 16 | # limitations under the License. |
Sarah Mashayekhi | eed8468 | 2019-11-26 14:46:19 -0500 | [diff] [blame] | 17 | |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 18 | import sys |
| 19 | import os |
Arseny Kapoulkine | f45075b | 2017-01-24 22:26:39 -0800 | [diff] [blame] | 20 | import os.path |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 21 | import subprocess |
| 22 | import tempfile |
| 23 | import re |
| 24 | import itertools |
| 25 | import hashlib |
| 26 | import shutil |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 27 | import argparse |
Hans-Kristian Arntzen | ad0c5c6 | 2017-02-04 10:19:44 +0100 | [diff] [blame] | 28 | import codecs |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 29 | import json |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 30 | import multiprocessing |
Hans-Kristian Arntzen | 26107ba | 2018-07-02 13:12:58 +0200 | [diff] [blame] | 31 | import errno |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 32 | from functools import partial |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 33 | |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 34 | class Paths(): |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 35 | def __init__(self, spirv_cross, glslang, spirv_as, spirv_val, spirv_opt): |
| 36 | self.spirv_cross = spirv_cross |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 37 | self.glslang = glslang |
| 38 | self.spirv_as = spirv_as |
| 39 | self.spirv_val = spirv_val |
| 40 | self.spirv_opt = spirv_opt |
| 41 | |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 42 | def remove_file(path): |
| 43 | #print('Removing file:', path) |
| 44 | os.remove(path) |
| 45 | |
| 46 | def create_temporary(suff = ''): |
| 47 | f, path = tempfile.mkstemp(suffix = suff) |
| 48 | os.close(f) |
| 49 | #print('Creating temporary:', path) |
| 50 | return path |
| 51 | |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 52 | def parse_stats(stats): |
| 53 | m = re.search('([0-9]+) work registers', stats) |
| 54 | registers = int(m.group(1)) if m else 0 |
| 55 | |
| 56 | m = re.search('([0-9]+) uniform registers', stats) |
| 57 | uniform_regs = int(m.group(1)) if m else 0 |
| 58 | |
| 59 | m_list = re.findall('(-?[0-9]+)\s+(-?[0-9]+)\s+(-?[0-9]+)', stats) |
| 60 | alu_short = float(m_list[1][0]) if m_list else 0 |
| 61 | ls_short = float(m_list[1][1]) if m_list else 0 |
| 62 | tex_short = float(m_list[1][2]) if m_list else 0 |
| 63 | alu_long = float(m_list[2][0]) if m_list else 0 |
| 64 | ls_long = float(m_list[2][1]) if m_list else 0 |
| 65 | tex_long = float(m_list[2][2]) if m_list else 0 |
| 66 | |
| 67 | return (registers, uniform_regs, alu_short, ls_short, tex_short, alu_long, ls_long, tex_long) |
| 68 | |
| 69 | def get_shader_type(shader): |
| 70 | _, ext = os.path.splitext(shader) |
| 71 | if ext == '.vert': |
| 72 | return '--vertex' |
| 73 | elif ext == '.frag': |
| 74 | return '--fragment' |
| 75 | elif ext == '.comp': |
| 76 | return '--compute' |
| 77 | elif ext == '.tesc': |
| 78 | return '--tessellation_control' |
| 79 | elif ext == '.tese': |
| 80 | return '--tessellation_evaluation' |
| 81 | elif ext == '.geom': |
| 82 | return '--geometry' |
| 83 | else: |
| 84 | return '' |
| 85 | |
| 86 | def get_shader_stats(shader): |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 87 | path = create_temporary() |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 88 | |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 89 | p = subprocess.Popen(['malisc', get_shader_type(shader), '--core', 'Mali-T760', '-V', shader], stdout = subprocess.PIPE, stderr = subprocess.PIPE) |
| 90 | stdout, stderr = p.communicate() |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 91 | remove_file(path) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 92 | |
| 93 | if p.returncode != 0: |
| 94 | print(stderr.decode('utf-8')) |
| 95 | raise OSError('malisc failed') |
| 96 | p.wait() |
| 97 | |
| 98 | returned = stdout.decode('utf-8') |
| 99 | return parse_stats(returned) |
| 100 | |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 101 | def print_msl_compiler_version(): |
| 102 | try: |
| 103 | subprocess.check_call(['xcrun', '--sdk', 'iphoneos', 'metal', '--version']) |
Hans-Kristian Arntzen | 2e000a0 | 2021-03-12 12:51:53 +0100 | [diff] [blame] | 104 | print('... are the Metal compiler characteristics.\n') # display after so xcrun FNF is silent |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 105 | except OSError as e: |
Hans-Kristian Arntzen | 26107ba | 2018-07-02 13:12:58 +0200 | [diff] [blame] | 106 | if (e.errno != errno.ENOENT): # Ignore xcrun not found error |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 107 | raise |
Hans-Kristian Arntzen | 2e000a0 | 2021-03-12 12:51:53 +0100 | [diff] [blame] | 108 | print('Metal SDK is not present.\n') |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 109 | except subprocess.CalledProcessError: |
| 110 | pass |
| 111 | |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 112 | def msl_compiler_supports_version(version): |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 113 | try: |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 114 | subprocess.check_call(['xcrun', '--sdk', 'macosx', 'metal', '-x', 'metal', '-std=macos-metal' + version, '-'], |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 115 | stdin = subprocess.DEVNULL, stdout = subprocess.DEVNULL, stderr = subprocess.DEVNULL) |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 116 | print('Current SDK supports MSL {0}. Enabling validation for MSL {0} shaders.'.format(version)) |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 117 | return True |
| 118 | except OSError as e: |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 119 | print('Failed to check if MSL {} is not supported. It probably is not.'.format(version)) |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 120 | return False |
| 121 | except subprocess.CalledProcessError: |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 122 | print('Current SDK does NOT support MSL {0}. Disabling validation for MSL {0} shaders.'.format(version)) |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 123 | return False |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 124 | |
Hans-Kristian Arntzen | 32823b0 | 2018-09-07 09:33:34 +0200 | [diff] [blame] | 125 | def path_to_msl_standard(shader): |
Chip Davis | 3a9af96 | 2018-09-26 20:06:05 -0500 | [diff] [blame] | 126 | if '.ios.' in shader: |
| 127 | if '.msl2.' in shader: |
| 128 | return '-std=ios-metal2.0' |
| 129 | elif '.msl21.' in shader: |
| 130 | return '-std=ios-metal2.1' |
Hans-Kristian Arntzen | fccf1d0 | 2019-06-12 09:30:41 +0200 | [diff] [blame] | 131 | elif '.msl22.' in shader: |
| 132 | return '-std=ios-metal2.2' |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 133 | elif '.msl23.' in shader: |
| 134 | return '-std=ios-metal2.3' |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 135 | elif '.msl24.' in shader: |
| 136 | return '-std=ios-metal2.4' |
Chip Davis | 3a9af96 | 2018-09-26 20:06:05 -0500 | [diff] [blame] | 137 | elif '.msl11.' in shader: |
| 138 | return '-std=ios-metal1.1' |
| 139 | elif '.msl10.' in shader: |
| 140 | return '-std=ios-metal1.0' |
| 141 | else: |
| 142 | return '-std=ios-metal1.2' |
Hans-Kristian Arntzen | 32823b0 | 2018-09-07 09:33:34 +0200 | [diff] [blame] | 143 | else: |
Chip Davis | 3a9af96 | 2018-09-26 20:06:05 -0500 | [diff] [blame] | 144 | if '.msl2.' in shader: |
| 145 | return '-std=macos-metal2.0' |
| 146 | elif '.msl21.' in shader: |
| 147 | return '-std=macos-metal2.1' |
Hans-Kristian Arntzen | fccf1d0 | 2019-06-12 09:30:41 +0200 | [diff] [blame] | 148 | elif '.msl22.' in shader: |
| 149 | return '-std=macos-metal2.2' |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 150 | elif '.msl23.' in shader: |
| 151 | return '-std=macos-metal2.3' |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 152 | elif '.msl24.' in shader: |
| 153 | return '-std=macos-metal2.4' |
Chip Davis | 3a9af96 | 2018-09-26 20:06:05 -0500 | [diff] [blame] | 154 | elif '.msl11.' in shader: |
| 155 | return '-std=macos-metal1.1' |
| 156 | else: |
| 157 | return '-std=macos-metal1.2' |
Hans-Kristian Arntzen | 32823b0 | 2018-09-07 09:33:34 +0200 | [diff] [blame] | 158 | |
Hans-Kristian Arntzen | 652d826 | 2018-09-07 09:45:25 +0200 | [diff] [blame] | 159 | def path_to_msl_standard_cli(shader): |
| 160 | if '.msl2.' in shader: |
| 161 | return '20000' |
| 162 | elif '.msl21.' in shader: |
| 163 | return '20100' |
Hans-Kristian Arntzen | fccf1d0 | 2019-06-12 09:30:41 +0200 | [diff] [blame] | 164 | elif '.msl22.' in shader: |
| 165 | return '20200' |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 166 | elif '.msl23.' in shader: |
| 167 | return '20300' |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 168 | elif '.msl24.' in shader: |
| 169 | return '20400' |
Hans-Kristian Arntzen | 652d826 | 2018-09-07 09:45:25 +0200 | [diff] [blame] | 170 | elif '.msl11.' in shader: |
| 171 | return '10100' |
| 172 | else: |
| 173 | return '10200' |
| 174 | |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 175 | def validate_shader_msl(shader, opt): |
| 176 | msl_path = reference_path(shader[0], shader[1], opt) |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 177 | try: |
Chip Davis | 3a9af96 | 2018-09-26 20:06:05 -0500 | [diff] [blame] | 178 | if '.ios.' in msl_path: |
| 179 | msl_os = 'iphoneos' |
| 180 | else: |
| 181 | msl_os = 'macosx' |
Hans-Kristian Arntzen | 32823b0 | 2018-09-07 09:33:34 +0200 | [diff] [blame] | 182 | subprocess.check_call(['xcrun', '--sdk', msl_os, 'metal', '-x', 'metal', path_to_msl_standard(msl_path), '-Werror', '-Wno-unused-variable', msl_path]) |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 183 | print('Compiled Metal shader: ' + msl_path) # display after so xcrun FNF is silent |
| 184 | except OSError as oe: |
Hans-Kristian Arntzen | 26107ba | 2018-07-02 13:12:58 +0200 | [diff] [blame] | 185 | if (oe.errno != errno.ENOENT): # Ignore xcrun not found error |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 186 | raise |
| 187 | except subprocess.CalledProcessError: |
| 188 | print('Error compiling Metal shader: ' + msl_path) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 189 | raise RuntimeError('Failed to compile Metal shader') |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 190 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 191 | def cross_compile_msl(shader, spirv, opt, iterations, paths): |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 192 | spirv_path = create_temporary() |
| 193 | msl_path = create_temporary(os.path.basename(shader)) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 194 | |
Hans-Kristian Arntzen | 6382f15 | 2021-10-13 15:52:04 +0200 | [diff] [blame] | 195 | spirv_14 = '.spv14.' in shader |
| 196 | spirv_env = 'vulkan1.1spv1.4' if spirv_14 else 'vulkan1.1' |
Hans-Kristian Arntzen | 9012a39 | 2020-01-06 11:47:26 +0100 | [diff] [blame] | 197 | |
| 198 | spirv_cmd = [paths.spirv_as, '--target-env', spirv_env, '-o', spirv_path, shader] |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 199 | if '.preserve.' in shader: |
| 200 | spirv_cmd.append('--preserve-numeric-ids') |
| 201 | |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 202 | if spirv: |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 203 | subprocess.check_call(spirv_cmd) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 204 | else: |
Hans-Kristian Arntzen | 6382f15 | 2021-10-13 15:52:04 +0200 | [diff] [blame] | 205 | glslang_env = 'spirv1.4' if spirv_14 else 'vulkan1.1' |
| 206 | subprocess.check_call([paths.glslang, '--amb' ,'--target-env', glslang_env, '-V', '-o', spirv_path, shader]) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 207 | |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 208 | if opt and (not shader_is_invalid_spirv(shader)): |
Lukas Hermanns | e1b161b | 2019-10-21 16:39:53 -0400 | [diff] [blame] | 209 | if '.graphics-robust-access.' in shader: |
| 210 | subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '--graphics-robust-access', '-o', spirv_path, spirv_path]) |
| 211 | else: |
| 212 | subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 213 | |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 214 | spirv_cross_path = paths.spirv_cross |
Hans-Kristian Arntzen | e8ca39b | 2018-04-03 14:26:24 +0200 | [diff] [blame] | 215 | |
Hans-Kristian Arntzen | c4ff129 | 2021-01-04 09:40:11 +0100 | [diff] [blame] | 216 | msl_args = [spirv_cross_path, '--output', msl_path, spirv_path, '--msl', '--iterations', str(iterations)] |
Hans-Kristian Arntzen | 652d826 | 2018-09-07 09:45:25 +0200 | [diff] [blame] | 217 | msl_args.append('--msl-version') |
| 218 | msl_args.append(path_to_msl_standard_cli(shader)) |
Hans-Kristian Arntzen | c4ff129 | 2021-01-04 09:40:11 +0100 | [diff] [blame] | 219 | if not '.nomain.' in shader: |
| 220 | msl_args.append('--entry') |
| 221 | msl_args.append('main') |
Chip Davis | 2583321 | 2018-09-19 20:36:33 -0500 | [diff] [blame] | 222 | if '.swizzle.' in shader: |
| 223 | msl_args.append('--msl-swizzle-texture-samples') |
Chip Davis | 3a9af96 | 2018-09-26 20:06:05 -0500 | [diff] [blame] | 224 | if '.ios.' in shader: |
| 225 | msl_args.append('--msl-ios') |
Hans-Kristian Arntzen | b8033d7 | 2019-01-14 14:53:47 +0100 | [diff] [blame] | 226 | if '.pad-fragment.' in shader: |
| 227 | msl_args.append('--msl-pad-fragment-output') |
Chip Davis | c51e5b7 | 2019-01-08 16:33:32 -0600 | [diff] [blame] | 228 | if '.capture.' in shader: |
| 229 | msl_args.append('--msl-capture-output') |
Chip Davis | 41d9424 | 2019-02-05 23:47:50 -0600 | [diff] [blame] | 230 | if '.domain.' in shader: |
| 231 | msl_args.append('--msl-domain-lower-left') |
Hans-Kristian Arntzen | e47a77d | 2019-03-14 10:29:34 +0100 | [diff] [blame] | 232 | if '.argument.' in shader: |
| 233 | msl_args.append('--msl-argument-buffers') |
Hans-Kristian Arntzen | fc4f39b | 2019-04-23 12:17:21 +0200 | [diff] [blame] | 234 | if '.texture-buffer-native.' in shader: |
| 235 | msl_args.append('--msl-texture-buffer-native') |
Lukas Hermanns | f3a6d28 | 2019-09-27 15:49:54 -0400 | [diff] [blame] | 236 | if '.framebuffer-fetch.' in shader: |
| 237 | msl_args.append('--msl-framebuffer-fetch') |
Lukas Hermanns | ffbd801 | 2019-10-09 11:22:25 -0400 | [diff] [blame] | 238 | if '.invariant-float-math.' in shader: |
| 239 | msl_args.append('--msl-invariant-float-math') |
Lukas Hermanns | f3a6d28 | 2019-09-27 15:49:54 -0400 | [diff] [blame] | 240 | if '.emulate-cube-array.' in shader: |
| 241 | msl_args.append('--msl-emulate-cube-array') |
Hans-Kristian Arntzen | e2aadf8 | 2019-03-15 21:53:21 +0100 | [diff] [blame] | 242 | if '.discrete.' in shader: |
Hans-Kristian Arntzen | b3380ec | 2019-03-15 14:07:03 +0100 | [diff] [blame] | 243 | # Arbitrary for testing purposes. |
Hans-Kristian Arntzen | e2aadf8 | 2019-03-15 21:53:21 +0100 | [diff] [blame] | 244 | msl_args.append('--msl-discrete-descriptor-set') |
Hans-Kristian Arntzen | b3380ec | 2019-03-15 14:07:03 +0100 | [diff] [blame] | 245 | msl_args.append('2') |
Hans-Kristian Arntzen | e2aadf8 | 2019-03-15 21:53:21 +0100 | [diff] [blame] | 246 | msl_args.append('--msl-discrete-descriptor-set') |
Hans-Kristian Arntzen | b3380ec | 2019-03-15 14:07:03 +0100 | [diff] [blame] | 247 | msl_args.append('3') |
Hans-Kristian Arntzen | c3bd136 | 2020-01-16 11:07:30 +0100 | [diff] [blame] | 248 | if '.force-active.' in shader: |
| 249 | msl_args.append('--msl-force-active-argument-buffer-resources') |
Hans-Kristian Arntzen | 65af09d | 2019-05-28 13:41:46 +0200 | [diff] [blame] | 250 | if '.line.' in shader: |
| 251 | msl_args.append('--emit-line-directives') |
Chip Davis | 7eecf5a | 2019-05-31 12:06:20 -0500 | [diff] [blame] | 252 | if '.multiview.' in shader: |
| 253 | msl_args.append('--msl-multiview') |
Chip Davis | cab7335 | 2020-08-23 16:44:41 -0500 | [diff] [blame] | 254 | if '.no-layered.' in shader: |
| 255 | msl_args.append('--msl-multiview-no-layered-rendering') |
Chip Davis | 6a58554 | 2019-07-12 21:50:50 -0500 | [diff] [blame] | 256 | if '.viewfromdev.' in shader: |
| 257 | msl_args.append('--msl-view-index-from-device-index') |
Chip Davis | fb5ee4c | 2019-07-22 13:08:04 -0500 | [diff] [blame] | 258 | if '.dispatchbase.' in shader: |
| 259 | msl_args.append('--msl-dispatch-base') |
Chip Davis | cb35934 | 2019-09-05 23:14:12 -0500 | [diff] [blame] | 260 | if '.dynamic-buffer.' in shader: |
| 261 | # Arbitrary for testing purposes. |
| 262 | msl_args.append('--msl-dynamic-buffer') |
| 263 | msl_args.append('0') |
| 264 | msl_args.append('0') |
| 265 | msl_args.append('--msl-dynamic-buffer') |
| 266 | msl_args.append('1') |
| 267 | msl_args.append('2') |
Chip Davis | fedbc35 | 2019-12-16 22:58:16 -0600 | [diff] [blame] | 268 | if '.inline-block.' in shader: |
| 269 | # Arbitrary for testing purposes. |
| 270 | msl_args.append('--msl-inline-uniform-block') |
| 271 | msl_args.append('0') |
| 272 | msl_args.append('0') |
Hans-Kristian Arntzen | 4bb673a | 2019-10-14 12:51:48 +0200 | [diff] [blame] | 273 | if '.device-argument-buffer.' in shader: |
| 274 | msl_args.append('--msl-device-argument-buffer') |
| 275 | msl_args.append('0') |
| 276 | msl_args.append('--msl-device-argument-buffer') |
| 277 | msl_args.append('1') |
Hans-Kristian Arntzen | c9d4f9c | 2020-02-24 12:47:14 +0100 | [diff] [blame] | 278 | if '.force-native-array.' in shader: |
| 279 | msl_args.append('--msl-force-native-arrays') |
Hans-Kristian Arntzen | b8905bb | 2020-03-26 11:21:23 +0100 | [diff] [blame] | 280 | if '.zero-initialize.' in shader: |
| 281 | msl_args.append('--force-zero-initialized-variables') |
Chip Davis | b29f83c | 2020-04-10 01:13:33 -0500 | [diff] [blame] | 282 | if '.frag-output.' in shader: |
| 283 | # Arbitrary for testing purposes. |
| 284 | msl_args.append('--msl-disable-frag-depth-builtin') |
| 285 | msl_args.append('--msl-disable-frag-stencil-ref-builtin') |
| 286 | msl_args.append('--msl-enable-frag-output-mask') |
| 287 | msl_args.append('0x000000ca') |
Hans-Kristian Arntzen | ebf4636 | 2020-04-20 09:48:20 +0200 | [diff] [blame] | 288 | if '.no-user-varying.' in shader: |
| 289 | msl_args.append('--msl-no-clip-distance-user-varying') |
Chip Davis | 5281d99 | 2020-06-13 23:03:30 -0500 | [diff] [blame] | 290 | if '.shader-inputs.' in shader: |
| 291 | # Arbitrary for testing purposes. |
| 292 | msl_args.append('--msl-shader-input') |
| 293 | msl_args.append('0') |
| 294 | msl_args.append('u8') |
| 295 | msl_args.append('2') |
| 296 | msl_args.append('--msl-shader-input') |
| 297 | msl_args.append('1') |
| 298 | msl_args.append('u16') |
| 299 | msl_args.append('3') |
| 300 | msl_args.append('--msl-shader-input') |
| 301 | msl_args.append('6') |
| 302 | msl_args.append('other') |
| 303 | msl_args.append('4') |
Chip Davis | 688c5fc | 2020-02-20 21:38:28 -0600 | [diff] [blame] | 304 | if '.multi-patch.' in shader: |
| 305 | msl_args.append('--msl-multi-patch-workgroup') |
| 306 | # Arbitrary for testing purposes. |
| 307 | msl_args.append('--msl-shader-input') |
| 308 | msl_args.append('0') |
| 309 | msl_args.append('any32') |
| 310 | msl_args.append('3') |
| 311 | msl_args.append('--msl-shader-input') |
| 312 | msl_args.append('1') |
| 313 | msl_args.append('any16') |
| 314 | msl_args.append('2') |
| 315 | if '.for-tess.' in shader: |
| 316 | msl_args.append('--msl-vertex-for-tessellation') |
Tomek Ponitka | 18f23c4 | 2020-07-22 18:37:17 +0200 | [diff] [blame] | 317 | if '.fixed-sample-mask.' in shader: |
| 318 | msl_args.append('--msl-additional-fixed-sample-mask') |
| 319 | msl_args.append('0x00000022') |
Chip Davis | 4cf840e | 2020-08-27 19:24:20 -0500 | [diff] [blame] | 320 | if '.arrayed-subpass.' in shader: |
| 321 | msl_args.append('--msl-arrayed-subpass-input') |
Chip Davis | 5845e00 | 2020-10-14 20:48:52 -0500 | [diff] [blame] | 322 | if '.1d-as-2d.' in shader: |
| 323 | msl_args.append('--msl-texture-1d-as-2d') |
Chip Davis | 6890835 | 2020-11-18 23:16:46 -0600 | [diff] [blame] | 324 | if '.simd.' in shader: |
| 325 | msl_args.append('--msl-ios-use-simdgroup-functions') |
| 326 | if '.emulate-subgroup.' in shader: |
| 327 | msl_args.append('--msl-emulate-subgroups') |
| 328 | if '.fixed-subgroup.' in shader: |
| 329 | # Arbitrary for testing purposes. |
| 330 | msl_args.append('--msl-fixed-subgroup-size') |
| 331 | msl_args.append('32') |
Chip Davis | fd738e3 | 2020-11-20 15:41:46 -0600 | [diff] [blame] | 332 | if '.force-sample.' in shader: |
| 333 | msl_args.append('--msl-force-sample-rate-shading') |
Hans-Kristian Arntzen | 3136e34 | 2021-01-07 14:30:35 +0100 | [diff] [blame] | 334 | if '.decoration-binding.' in shader: |
| 335 | msl_args.append('--msl-decoration-binding') |
Hans-Kristian Arntzen | 88b54f5 | 2021-04-06 11:49:07 +0200 | [diff] [blame] | 336 | if '.mask-location-0.' in shader: |
| 337 | msl_args.append('--mask-stage-output-location') |
| 338 | msl_args.append('0') |
| 339 | msl_args.append('0') |
| 340 | if '.mask-location-1.' in shader: |
| 341 | msl_args.append('--mask-stage-output-location') |
| 342 | msl_args.append('1') |
| 343 | msl_args.append('0') |
| 344 | if '.mask-position.' in shader: |
| 345 | msl_args.append('--mask-stage-output-builtin') |
| 346 | msl_args.append('Position') |
| 347 | if '.mask-point-size.' in shader: |
| 348 | msl_args.append('--mask-stage-output-builtin') |
| 349 | msl_args.append('PointSize') |
| 350 | if '.mask-clip-distance.' in shader: |
| 351 | msl_args.append('--mask-stage-output-builtin') |
| 352 | msl_args.append('ClipDistance') |
Hans-Kristian Arntzen | e8ca39b | 2018-04-03 14:26:24 +0200 | [diff] [blame] | 353 | |
| 354 | subprocess.check_call(msl_args) |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 355 | |
| 356 | if not shader_is_invalid_spirv(msl_path): |
Hans-Kristian Arntzen | 9012a39 | 2020-01-06 11:47:26 +0100 | [diff] [blame] | 357 | subprocess.check_call([paths.spirv_val, '--scalar-block-layout', '--target-env', spirv_env, spirv_path]) |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 358 | |
Hans-Kristian Arntzen | 1c28ec6 | 2017-01-18 19:05:57 +0100 | [diff] [blame] | 359 | return (spirv_path, msl_path) |
| 360 | |
Hans-Kristian Arntzen | 9507325 | 2017-12-12 11:03:46 +0100 | [diff] [blame] | 361 | def shader_model_hlsl(shader): |
| 362 | if '.vert' in shader: |
Hans-Kristian Arntzen | 0312c98 | 2018-09-12 09:44:35 +0200 | [diff] [blame] | 363 | if '.sm30.' in shader: |
| 364 | return '-Tvs_3_0' |
| 365 | else: |
| 366 | return '-Tvs_5_1' |
Hans-Kristian Arntzen | 9507325 | 2017-12-12 11:03:46 +0100 | [diff] [blame] | 367 | elif '.frag' in shader: |
Hans-Kristian Arntzen | 0312c98 | 2018-09-12 09:44:35 +0200 | [diff] [blame] | 368 | if '.sm30.' in shader: |
| 369 | return '-Tps_3_0' |
| 370 | else: |
| 371 | return '-Tps_5_1' |
Hans-Kristian Arntzen | 9507325 | 2017-12-12 11:03:46 +0100 | [diff] [blame] | 372 | elif '.comp' in shader: |
| 373 | return '-Tcs_5_1' |
| 374 | else: |
| 375 | return None |
| 376 | |
Hans-Kristian Arntzen | 789fa91 | 2017-12-12 13:23:56 +0100 | [diff] [blame] | 377 | def shader_to_win_path(shader): |
| 378 | # It's (very) convenient to be able to run HLSL testing in wine on Unix-likes, so support that. |
| 379 | try: |
| 380 | with subprocess.Popen(['winepath', '-w', shader], stdout = subprocess.PIPE, stderr = subprocess.PIPE) as f: |
| 381 | stdout_data, stderr_data = f.communicate() |
| 382 | return stdout_data.decode('utf-8') |
| 383 | except OSError as oe: |
Hans-Kristian Arntzen | 26107ba | 2018-07-02 13:12:58 +0200 | [diff] [blame] | 384 | if (oe.errno != errno.ENOENT): # Ignore not found errors |
Hans-Kristian Arntzen | 789fa91 | 2017-12-12 13:23:56 +0100 | [diff] [blame] | 385 | return shader |
| 386 | except subprocess.CalledProcessError: |
| 387 | raise |
| 388 | |
Hans-Kristian Arntzen | 51a48a7 | 2017-12-12 13:33:13 +0100 | [diff] [blame] | 389 | return shader |
| 390 | |
Hans-Kristian Arntzen | d0c829b | 2018-04-18 16:43:28 +0200 | [diff] [blame] | 391 | ignore_fxc = False |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 392 | def validate_shader_hlsl(shader, force_no_external_validation, paths): |
Hans-Kristian Arntzen | c7eda1b | 2019-07-17 11:24:31 +0200 | [diff] [blame] | 393 | test_glslang = True |
| 394 | if '.nonuniformresource.' in shader: |
| 395 | test_glslang = False |
| 396 | if '.fxconly.' in shader: |
| 397 | test_glslang = False |
| 398 | |
Hans-Kristian Arntzen | 8f71694 | 2020-07-01 11:37:03 +0200 | [diff] [blame] | 399 | hlsl_args = [paths.glslang, '--amb', '-e', 'main', '-D', '--target-env', 'vulkan1.1', '-V', shader] |
| 400 | if '.sm30.' in shader: |
| 401 | hlsl_args.append('--hlsl-dx9-compatible') |
| 402 | |
Hans-Kristian Arntzen | c7eda1b | 2019-07-17 11:24:31 +0200 | [diff] [blame] | 403 | if test_glslang: |
Hans-Kristian Arntzen | 8f71694 | 2020-07-01 11:37:03 +0200 | [diff] [blame] | 404 | subprocess.check_call(hlsl_args) |
| 405 | |
Hans-Kristian Arntzen | 789fa91 | 2017-12-12 13:23:56 +0100 | [diff] [blame] | 406 | is_no_fxc = '.nofxc.' in shader |
Hans-Kristian Arntzen | d0c829b | 2018-04-18 16:43:28 +0200 | [diff] [blame] | 407 | global ignore_fxc |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 408 | if (not ignore_fxc) and (not force_no_external_validation) and (not is_no_fxc): |
Hans-Kristian Arntzen | 789fa91 | 2017-12-12 13:23:56 +0100 | [diff] [blame] | 409 | try: |
| 410 | win_path = shader_to_win_path(shader) |
Hans-Kristian Arntzen | 647ddae | 2019-05-13 14:58:27 +0200 | [diff] [blame] | 411 | args = ['fxc', '-nologo', shader_model_hlsl(shader), win_path] |
| 412 | if '.nonuniformresource.' in shader: |
| 413 | args.append('/enable_unbounded_descriptor_tables') |
| 414 | subprocess.check_call(args) |
Hans-Kristian Arntzen | 789fa91 | 2017-12-12 13:23:56 +0100 | [diff] [blame] | 415 | except OSError as oe: |
Hans-Kristian Arntzen | 26107ba | 2018-07-02 13:12:58 +0200 | [diff] [blame] | 416 | if (oe.errno != errno.ENOENT): # Ignore not found errors |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 417 | print('Failed to run FXC.') |
| 418 | ignore_fxc = True |
Hans-Kristian Arntzen | 789fa91 | 2017-12-12 13:23:56 +0100 | [diff] [blame] | 419 | raise |
Hans-Kristian Arntzen | d0c829b | 2018-04-18 16:43:28 +0200 | [diff] [blame] | 420 | else: |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 421 | print('Could not find FXC.') |
Hans-Kristian Arntzen | d0c829b | 2018-04-18 16:43:28 +0200 | [diff] [blame] | 422 | ignore_fxc = True |
Hans-Kristian Arntzen | 789fa91 | 2017-12-12 13:23:56 +0100 | [diff] [blame] | 423 | except subprocess.CalledProcessError: |
| 424 | print('Failed compiling HLSL shader:', shader, 'with FXC.') |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 425 | raise RuntimeError('Failed compiling HLSL shader') |
Robert Konrad | ddbeea2 | 2017-01-26 11:46:29 +0100 | [diff] [blame] | 426 | |
Hans-Kristian Arntzen | ecf56cf | 2017-06-30 10:34:21 +0200 | [diff] [blame] | 427 | def shader_to_sm(shader): |
Hans-Kristian Arntzen | 2d52006 | 2020-06-04 11:35:21 +0200 | [diff] [blame] | 428 | if '.sm62.' in shader: |
| 429 | return '62' |
| 430 | elif '.sm60.' in shader: |
Hans-Kristian Arntzen | c266429 | 2018-04-11 15:02:02 +0200 | [diff] [blame] | 431 | return '60' |
| 432 | elif '.sm51.' in shader: |
Hans-Kristian Arntzen | ecf56cf | 2017-06-30 10:34:21 +0200 | [diff] [blame] | 433 | return '51' |
crosire | 3d39652 | 2018-09-11 20:57:56 +0200 | [diff] [blame] | 434 | elif '.sm30.' in shader: |
| 435 | return '30' |
Hans-Kristian Arntzen | ecf56cf | 2017-06-30 10:34:21 +0200 | [diff] [blame] | 436 | else: |
| 437 | return '50' |
| 438 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 439 | def cross_compile_hlsl(shader, spirv, opt, force_no_external_validation, iterations, paths): |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 440 | spirv_path = create_temporary() |
| 441 | hlsl_path = create_temporary(os.path.basename(shader)) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 442 | |
Hans-Kristian Arntzen | 6382f15 | 2021-10-13 15:52:04 +0200 | [diff] [blame] | 443 | spirv_14 = '.spv14.' in shader |
| 444 | spirv_env = 'vulkan1.1spv1.4' if spirv_14 else 'vulkan1.1' |
Hans-Kristian Arntzen | ea02a0c | 2021-01-22 13:48:16 +0100 | [diff] [blame] | 445 | spirv_cmd = [paths.spirv_as, '--target-env', spirv_env, '-o', spirv_path, shader] |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 446 | if '.preserve.' in shader: |
| 447 | spirv_cmd.append('--preserve-numeric-ids') |
| 448 | |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 449 | if spirv: |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 450 | subprocess.check_call(spirv_cmd) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 451 | else: |
Hans-Kristian Arntzen | 6382f15 | 2021-10-13 15:52:04 +0200 | [diff] [blame] | 452 | glslang_env = 'spirv1.4' if spirv_14 else 'vulkan1.1' |
| 453 | subprocess.check_call([paths.glslang, '--amb', '--target-env', glslang_env, '-V', '-o', spirv_path, shader]) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 454 | |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 455 | if opt and (not shader_is_invalid_spirv(hlsl_path)): |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 456 | subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 457 | |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 458 | spirv_cross_path = paths.spirv_cross |
Hans-Kristian Arntzen | ecf56cf | 2017-06-30 10:34:21 +0200 | [diff] [blame] | 459 | |
| 460 | sm = shader_to_sm(shader) |
Hans-Kristian Arntzen | 65af09d | 2019-05-28 13:41:46 +0200 | [diff] [blame] | 461 | |
| 462 | hlsl_args = [spirv_cross_path, '--entry', 'main', '--output', hlsl_path, spirv_path, '--hlsl-enable-compat', '--hlsl', '--shader-model', sm, '--iterations', str(iterations)] |
| 463 | if '.line.' in shader: |
| 464 | hlsl_args.append('--emit-line-directives') |
Hans-Kristian Arntzen | c27e1ef | 2020-03-04 16:32:52 +0100 | [diff] [blame] | 465 | if '.force-uav.' in shader: |
| 466 | hlsl_args.append('--hlsl-force-storage-buffer-as-uav') |
Hans-Kristian Arntzen | b8905bb | 2020-03-26 11:21:23 +0100 | [diff] [blame] | 467 | if '.zero-initialize.' in shader: |
| 468 | hlsl_args.append('--force-zero-initialized-variables') |
Hans-Kristian Arntzen | 28bf905 | 2020-04-03 11:21:41 +0200 | [diff] [blame] | 469 | if '.nonwritable-uav-texture.' in shader: |
| 470 | hlsl_args.append('--hlsl-nonwritable-uav-texture-as-srv') |
Hans-Kristian Arntzen | 2d52006 | 2020-06-04 11:35:21 +0200 | [diff] [blame] | 471 | if '.native-16bit.' in shader: |
| 472 | hlsl_args.append('--hlsl-enable-16bit-types') |
Hans-Kristian Arntzen | b334417 | 2020-11-03 11:18:32 +0100 | [diff] [blame] | 473 | if '.flatten-matrix-vertex-input.' in shader: |
| 474 | hlsl_args.append('--hlsl-flatten-matrix-vertex-input-semantics') |
Hans-Kristian Arntzen | b8905bb | 2020-03-26 11:21:23 +0100 | [diff] [blame] | 475 | |
Hans-Kristian Arntzen | 65af09d | 2019-05-28 13:41:46 +0200 | [diff] [blame] | 476 | subprocess.check_call(hlsl_args) |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 477 | |
| 478 | if not shader_is_invalid_spirv(hlsl_path): |
Hans-Kristian Arntzen | ea02a0c | 2021-01-22 13:48:16 +0100 | [diff] [blame] | 479 | subprocess.check_call([paths.spirv_val, '--scalar-block-layout', '--target-env', spirv_env, spirv_path]) |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 480 | |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 481 | validate_shader_hlsl(hlsl_path, force_no_external_validation, paths) |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 482 | |
Robert Konrad | e717953 | 2017-01-26 10:06:05 +0100 | [diff] [blame] | 483 | return (spirv_path, hlsl_path) |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 484 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 485 | def cross_compile_reflect(shader, spirv, opt, iterations, paths): |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 486 | spirv_path = create_temporary() |
| 487 | reflect_path = create_temporary(os.path.basename(shader)) |
| 488 | |
Ryan Harrison | d3c59e7 | 2019-05-08 14:03:35 -0400 | [diff] [blame] | 489 | spirv_cmd = [paths.spirv_as, '--target-env', 'vulkan1.1', '-o', spirv_path, shader] |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 490 | if '.preserve.' in shader: |
| 491 | spirv_cmd.append('--preserve-numeric-ids') |
| 492 | |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 493 | if spirv: |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 494 | subprocess.check_call(spirv_cmd) |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 495 | else: |
Ryan Harrison | cf1bf1c | 2019-09-18 15:56:51 -0400 | [diff] [blame] | 496 | subprocess.check_call([paths.glslang, '--amb', '--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader]) |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 497 | |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 498 | if opt and (not shader_is_invalid_spirv(reflect_path)): |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 499 | subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 500 | |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 501 | spirv_cross_path = paths.spirv_cross |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 502 | |
| 503 | sm = shader_to_sm(shader) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 504 | subprocess.check_call([spirv_cross_path, '--entry', 'main', '--output', reflect_path, spirv_path, '--reflect', '--iterations', str(iterations)]) |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 505 | return (spirv_path, reflect_path) |
| 506 | |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 507 | def validate_shader(shader, vulkan, paths): |
Arseny Kapoulkine | f45075b | 2017-01-24 22:26:39 -0800 | [diff] [blame] | 508 | if vulkan: |
Hans-Kristian Arntzen | 2097c30 | 2021-01-08 11:37:29 +0100 | [diff] [blame] | 509 | spirv_14 = '.spv14.' in shader |
| 510 | glslang_env = 'spirv1.4' if spirv_14 else 'vulkan1.1' |
| 511 | subprocess.check_call([paths.glslang, '--amb', '--target-env', glslang_env, '-V', shader]) |
Arseny Kapoulkine | f45075b | 2017-01-24 22:26:39 -0800 | [diff] [blame] | 512 | else: |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 513 | subprocess.check_call([paths.glslang, shader]) |
Arseny Kapoulkine | f45075b | 2017-01-24 22:26:39 -0800 | [diff] [blame] | 514 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 515 | def cross_compile(shader, vulkan, spirv, invalid_spirv, eliminate, is_legacy, flatten_ubo, sso, flatten_dim, opt, push_ubo, iterations, paths): |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 516 | spirv_path = create_temporary() |
| 517 | glsl_path = create_temporary(os.path.basename(shader)) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 518 | |
Hans-Kristian Arntzen | 2097c30 | 2021-01-08 11:37:29 +0100 | [diff] [blame] | 519 | spirv_14 = '.spv14.' in shader |
| 520 | spirv_env = 'vulkan1.1spv1.4' if spirv_14 else 'vulkan1.1' |
Hans-Kristian Arntzen | 9012a39 | 2020-01-06 11:47:26 +0100 | [diff] [blame] | 521 | |
Hans-Kristian Arntzen | 45ad58a | 2016-05-10 23:39:41 +0200 | [diff] [blame] | 522 | if vulkan or spirv: |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 523 | vulkan_glsl_path = create_temporary('vk' + os.path.basename(shader)) |
Hans-Kristian Arntzen | dbee4e4 | 2016-05-05 10:16:22 +0200 | [diff] [blame] | 524 | |
Hans-Kristian Arntzen | 9012a39 | 2020-01-06 11:47:26 +0100 | [diff] [blame] | 525 | spirv_cmd = [paths.spirv_as, '--target-env', spirv_env, '-o', spirv_path, shader] |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 526 | if '.preserve.' in shader: |
| 527 | spirv_cmd.append('--preserve-numeric-ids') |
| 528 | |
Hans-Kristian Arntzen | 45ad58a | 2016-05-10 23:39:41 +0200 | [diff] [blame] | 529 | if spirv: |
Hans-Kristian Arntzen | d2cc43e | 2019-02-19 17:00:49 +0100 | [diff] [blame] | 530 | subprocess.check_call(spirv_cmd) |
Hans-Kristian Arntzen | 45ad58a | 2016-05-10 23:39:41 +0200 | [diff] [blame] | 531 | else: |
Hans-Kristian Arntzen | 2097c30 | 2021-01-08 11:37:29 +0100 | [diff] [blame] | 532 | glslang_env = 'spirv1.4' if spirv_14 else 'vulkan1.1' |
| 533 | subprocess.check_call([paths.glslang, '--amb', '--target-env', glslang_env, '-V', '-o', spirv_path, shader]) |
Hans-Kristian Arntzen | 45ad58a | 2016-05-10 23:39:41 +0200 | [diff] [blame] | 534 | |
Hans-Kristian Arntzen | cdca192 | 2017-11-21 16:52:01 +0100 | [diff] [blame] | 535 | if opt and (not invalid_spirv): |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 536 | subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path]) |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 537 | |
Hans-Kristian Arntzen | 706d3ea | 2016-09-12 20:11:30 +0200 | [diff] [blame] | 538 | if not invalid_spirv: |
Hans-Kristian Arntzen | 9012a39 | 2020-01-06 11:47:26 +0100 | [diff] [blame] | 539 | subprocess.check_call([paths.spirv_val, '--scalar-block-layout', '--target-env', spirv_env, spirv_path]) |
Hans-Kristian Arntzen | dbee4e4 | 2016-05-05 10:16:22 +0200 | [diff] [blame] | 540 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 541 | extra_args = ['--iterations', str(iterations)] |
Arseny Kapoulkine | 24c6625 | 2017-01-16 14:19:49 -0800 | [diff] [blame] | 542 | if eliminate: |
| 543 | extra_args += ['--remove-unused-variables'] |
Hans-Kristian Arntzen | 41f7e5b | 2017-01-13 16:41:27 +0100 | [diff] [blame] | 544 | if is_legacy: |
Arseny Kapoulkine | 24c6625 | 2017-01-16 14:19:49 -0800 | [diff] [blame] | 545 | extra_args += ['--version', '100', '--es'] |
| 546 | if flatten_ubo: |
| 547 | extra_args += ['--flatten-ubo'] |
Hans-Kristian Arntzen | 36650c8 | 2017-05-22 15:30:43 +0200 | [diff] [blame] | 548 | if sso: |
| 549 | extra_args += ['--separate-shader-objects'] |
Hans-Kristian Arntzen | 470ae7a | 2017-05-22 17:40:00 +0200 | [diff] [blame] | 550 | if flatten_dim: |
| 551 | extra_args += ['--flatten-multidimensional-arrays'] |
Hans-Kristian Arntzen | 0474848 | 2019-03-19 10:58:37 +0100 | [diff] [blame] | 552 | if push_ubo: |
| 553 | extra_args += ['--glsl-emit-push-constant-as-ubo'] |
Hans-Kristian Arntzen | 65af09d | 2019-05-28 13:41:46 +0200 | [diff] [blame] | 554 | if '.line.' in shader: |
| 555 | extra_args += ['--emit-line-directives'] |
Hans-Kristian Arntzen | 12ca9d1 | 2019-07-25 11:07:14 +0200 | [diff] [blame] | 556 | if '.no-samplerless.' in shader: |
| 557 | extra_args += ['--vulkan-glsl-disable-ext-samplerless-texture-functions'] |
Hans-Kristian Arntzen | 95cd20f | 2020-03-04 16:41:00 +0100 | [diff] [blame] | 558 | if '.no-qualifier-deduction.' in shader: |
| 559 | extra_args += ['--disable-storage-image-qualifier-deduction'] |
Hans-Kristian Arntzen | 04e877d | 2020-03-19 14:20:37 +0100 | [diff] [blame] | 560 | if '.framebuffer-fetch.' in shader: |
| 561 | extra_args += ['--glsl-remap-ext-framebuffer-fetch', '0', '0'] |
| 562 | extra_args += ['--glsl-remap-ext-framebuffer-fetch', '1', '1'] |
| 563 | extra_args += ['--glsl-remap-ext-framebuffer-fetch', '2', '2'] |
| 564 | extra_args += ['--glsl-remap-ext-framebuffer-fetch', '3', '3'] |
Hans-Kristian Arntzen | 26a4986 | 2021-05-21 14:21:13 +0200 | [diff] [blame] | 565 | if '.framebuffer-fetch-noncoherent.' in shader: |
| 566 | extra_args += ['--glsl-ext-framebuffer-fetch-noncoherent'] |
Hans-Kristian Arntzen | b8905bb | 2020-03-26 11:21:23 +0100 | [diff] [blame] | 567 | if '.zero-initialize.' in shader: |
| 568 | extra_args += ['--force-zero-initialized-variables'] |
Hans-Kristian Arntzen | 57c93d4 | 2020-07-28 15:15:24 +0200 | [diff] [blame] | 569 | if '.force-flattened-io.' in shader: |
| 570 | extra_args += ['--glsl-force-flattened-io-blocks'] |
Hans-Kristian Arntzen | 41f7e5b | 2017-01-13 16:41:27 +0100 | [diff] [blame] | 571 | |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 572 | spirv_cross_path = paths.spirv_cross |
Hans-Kristian Arntzen | dbee4e4 | 2016-05-05 10:16:22 +0200 | [diff] [blame] | 573 | |
Hans-Kristian Arntzen | 8869a16 | 2016-05-11 19:55:57 +0200 | [diff] [blame] | 574 | # A shader might not be possible to make valid GLSL from, skip validation for this case. |
Hans-Kristian Arntzen | 04e877d | 2020-03-19 14:20:37 +0100 | [diff] [blame] | 575 | if (not ('nocompat' in glsl_path)) or (not vulkan): |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 576 | subprocess.check_call([spirv_cross_path, '--entry', 'main', '--output', glsl_path, spirv_path] + extra_args) |
Hans-Kristian Arntzen | 04e877d | 2020-03-19 14:20:37 +0100 | [diff] [blame] | 577 | if not 'nocompat' in glsl_path: |
| 578 | validate_shader(glsl_path, False, paths) |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 579 | else: |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 580 | remove_file(glsl_path) |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 581 | glsl_path = None |
Hans-Kristian Arntzen | dbee4e4 | 2016-05-05 10:16:22 +0200 | [diff] [blame] | 582 | |
Hans-Kristian Arntzen | bae76d7 | 2020-06-29 12:50:31 +0200 | [diff] [blame] | 583 | if (vulkan or spirv) and (not is_legacy): |
Hans-Kristian Arntzen | ce18d1b | 2021-01-08 10:47:46 +0100 | [diff] [blame] | 584 | subprocess.check_call([spirv_cross_path, '--entry', 'main', '-V', '--output', vulkan_glsl_path, spirv_path] + extra_args) |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 585 | validate_shader(vulkan_glsl_path, True, paths) |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 586 | # SPIR-V shaders might just want to validate Vulkan GLSL output, we don't always care about the output. |
| 587 | if not vulkan: |
| 588 | remove_file(vulkan_glsl_path) |
Hans-Kristian Arntzen | dbee4e4 | 2016-05-05 10:16:22 +0200 | [diff] [blame] | 589 | |
| 590 | return (spirv_path, glsl_path, vulkan_glsl_path if vulkan else None) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 591 | |
Hans-Kristian Arntzen | ad0c5c6 | 2017-02-04 10:19:44 +0100 | [diff] [blame] | 592 | def make_unix_newline(buf): |
| 593 | decoded = codecs.decode(buf, 'utf-8') |
| 594 | decoded = decoded.replace('\r', '') |
| 595 | return codecs.encode(decoded, 'utf-8') |
| 596 | |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 597 | def md5_for_file(path): |
| 598 | md5 = hashlib.md5() |
| 599 | with open(path, 'rb') as f: |
Hans-Kristian Arntzen | ad0c5c6 | 2017-02-04 10:19:44 +0100 | [diff] [blame] | 600 | for chunk in iter(lambda: make_unix_newline(f.read(8192)), b''): |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 601 | md5.update(chunk) |
| 602 | return md5.digest() |
| 603 | |
| 604 | def make_reference_dir(path): |
| 605 | base = os.path.dirname(path) |
| 606 | if not os.path.exists(base): |
| 607 | os.makedirs(base) |
| 608 | |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 609 | def reference_path(directory, relpath, opt): |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 610 | split_paths = os.path.split(directory) |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 611 | reference_dir = os.path.join(split_paths[0], 'reference/' + ('opt/' if opt else '')) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 612 | reference_dir = os.path.join(reference_dir, split_paths[1]) |
| 613 | return os.path.join(reference_dir, relpath) |
| 614 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 615 | def regression_check_reflect(shader, json_file, args): |
| 616 | reference = reference_path(shader[0], shader[1], args.opt) + '.json' |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 617 | joined_path = os.path.join(shader[0], shader[1]) |
| 618 | print('Reference shader reflection path:', reference) |
| 619 | if os.path.exists(reference): |
Hans-Kristian Arntzen | 309e994 | 2019-10-04 11:04:52 +0200 | [diff] [blame] | 620 | actual = md5_for_file(json_file) |
| 621 | expected = md5_for_file(reference) |
| 622 | if actual != expected: |
Hans-Kristian Arntzen | 9ae91c2 | 2019-04-10 11:33:52 +0200 | [diff] [blame] | 623 | if args.update: |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 624 | print('Generated reflection json has changed for {}!'.format(reference)) |
| 625 | # If we expect changes, update the reference file. |
| 626 | if os.path.exists(reference): |
| 627 | remove_file(reference) |
| 628 | make_reference_dir(reference) |
| 629 | shutil.move(json_file, reference) |
| 630 | else: |
| 631 | print('Generated reflection json in {} does not match reference {}!'.format(json_file, reference)) |
| 632 | with open(json_file, 'r') as f: |
| 633 | print('') |
| 634 | print('Generated:') |
| 635 | print('======================') |
| 636 | print(f.read()) |
| 637 | print('======================') |
| 638 | print('') |
| 639 | |
| 640 | # Otherwise, fail the test. Keep the shader file around so we can inspect. |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 641 | if not args.keep: |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 642 | remove_file(json_file) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 643 | |
| 644 | raise RuntimeError('Does not match reference') |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 645 | else: |
| 646 | remove_file(json_file) |
| 647 | else: |
| 648 | print('Found new shader {}. Placing generated source code in {}'.format(joined_path, reference)) |
| 649 | make_reference_dir(reference) |
| 650 | shutil.move(json_file, reference) |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 651 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 652 | def regression_check(shader, glsl, args): |
| 653 | reference = reference_path(shader[0], shader[1], args.opt) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 654 | joined_path = os.path.join(shader[0], shader[1]) |
| 655 | print('Reference shader path:', reference) |
| 656 | |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 657 | if os.path.exists(reference): |
| 658 | if md5_for_file(glsl) != md5_for_file(reference): |
Hans-Kristian Arntzen | 9ae91c2 | 2019-04-10 11:33:52 +0200 | [diff] [blame] | 659 | if args.update: |
Bill Hollings | 77f5812 | 2017-08-11 14:54:58 -0400 | [diff] [blame] | 660 | print('Generated source code has changed for {}!'.format(reference)) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 661 | # If we expect changes, update the reference file. |
| 662 | if os.path.exists(reference): |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 663 | remove_file(reference) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 664 | make_reference_dir(reference) |
| 665 | shutil.move(glsl, reference) |
| 666 | else: |
Bill Hollings | 77f5812 | 2017-08-11 14:54:58 -0400 | [diff] [blame] | 667 | print('Generated source code in {} does not match reference {}!'.format(glsl, reference)) |
Hans-Kristian Arntzen | 45c797d | 2016-12-16 13:48:30 +0100 | [diff] [blame] | 668 | with open(glsl, 'r') as f: |
| 669 | print('') |
| 670 | print('Generated:') |
| 671 | print('======================') |
| 672 | print(f.read()) |
| 673 | print('======================') |
| 674 | print('') |
| 675 | |
Hans-Kristian Arntzen | e50e04c | 2016-03-22 14:56:50 +0100 | [diff] [blame] | 676 | # Otherwise, fail the test. Keep the shader file around so we can inspect. |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 677 | if not args.keep: |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 678 | remove_file(glsl) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 679 | raise RuntimeError('Does not match reference') |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 680 | else: |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 681 | remove_file(glsl) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 682 | else: |
Bill Hollings | 77f5812 | 2017-08-11 14:54:58 -0400 | [diff] [blame] | 683 | print('Found new shader {}. Placing generated source code in {}'.format(joined_path, reference)) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 684 | make_reference_dir(reference) |
| 685 | shutil.move(glsl, reference) |
| 686 | |
Hans-Kristian Arntzen | 8869a16 | 2016-05-11 19:55:57 +0200 | [diff] [blame] | 687 | def shader_is_vulkan(shader): |
| 688 | return '.vk.' in shader |
| 689 | |
Hans-Kristian Arntzen | 2c7d2e4 | 2016-07-11 12:47:46 +0200 | [diff] [blame] | 690 | def shader_is_desktop(shader): |
| 691 | return '.desktop.' in shader |
| 692 | |
Hans-Kristian Arntzen | f61a5d1 | 2016-08-26 12:58:50 +0200 | [diff] [blame] | 693 | def shader_is_eliminate_dead_variables(shader): |
| 694 | return '.noeliminate.' not in shader |
| 695 | |
Hans-Kristian Arntzen | 45ad58a | 2016-05-10 23:39:41 +0200 | [diff] [blame] | 696 | def shader_is_spirv(shader): |
| 697 | return '.asm.' in shader |
| 698 | |
Hans-Kristian Arntzen | 706d3ea | 2016-09-12 20:11:30 +0200 | [diff] [blame] | 699 | def shader_is_invalid_spirv(shader): |
| 700 | return '.invalid.' in shader |
| 701 | |
Hans-Kristian Arntzen | 41f7e5b | 2017-01-13 16:41:27 +0100 | [diff] [blame] | 702 | def shader_is_legacy(shader): |
| 703 | return '.legacy.' in shader |
| 704 | |
Arseny Kapoulkine | 24c6625 | 2017-01-16 14:19:49 -0800 | [diff] [blame] | 705 | def shader_is_flatten_ubo(shader): |
| 706 | return '.flatten.' in shader |
| 707 | |
Hans-Kristian Arntzen | 36650c8 | 2017-05-22 15:30:43 +0200 | [diff] [blame] | 708 | def shader_is_sso(shader): |
| 709 | return '.sso.' in shader |
| 710 | |
Hans-Kristian Arntzen | 470ae7a | 2017-05-22 17:40:00 +0200 | [diff] [blame] | 711 | def shader_is_flatten_dimensions(shader): |
| 712 | return '.flatten_dim.' in shader |
| 713 | |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 714 | def shader_is_noopt(shader): |
| 715 | return '.noopt.' in shader |
| 716 | |
Hans-Kristian Arntzen | 0474848 | 2019-03-19 10:58:37 +0100 | [diff] [blame] | 717 | def shader_is_push_ubo(shader): |
| 718 | return '.push-ubo.' in shader |
| 719 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 720 | def test_shader(stats, shader, args, paths): |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 721 | joined_path = os.path.join(shader[0], shader[1]) |
Hans-Kristian Arntzen | 8869a16 | 2016-05-11 19:55:57 +0200 | [diff] [blame] | 722 | vulkan = shader_is_vulkan(shader[1]) |
Hans-Kristian Arntzen | 2c7d2e4 | 2016-07-11 12:47:46 +0200 | [diff] [blame] | 723 | desktop = shader_is_desktop(shader[1]) |
Hans-Kristian Arntzen | f61a5d1 | 2016-08-26 12:58:50 +0200 | [diff] [blame] | 724 | eliminate = shader_is_eliminate_dead_variables(shader[1]) |
Hans-Kristian Arntzen | b684716 | 2016-09-10 12:52:23 +0200 | [diff] [blame] | 725 | is_spirv = shader_is_spirv(shader[1]) |
Hans-Kristian Arntzen | 706d3ea | 2016-09-12 20:11:30 +0200 | [diff] [blame] | 726 | invalid_spirv = shader_is_invalid_spirv(shader[1]) |
Hans-Kristian Arntzen | 41f7e5b | 2017-01-13 16:41:27 +0100 | [diff] [blame] | 727 | is_legacy = shader_is_legacy(shader[1]) |
Arseny Kapoulkine | 24c6625 | 2017-01-16 14:19:49 -0800 | [diff] [blame] | 728 | flatten_ubo = shader_is_flatten_ubo(shader[1]) |
Hans-Kristian Arntzen | 36650c8 | 2017-05-22 15:30:43 +0200 | [diff] [blame] | 729 | sso = shader_is_sso(shader[1]) |
Hans-Kristian Arntzen | 470ae7a | 2017-05-22 17:40:00 +0200 | [diff] [blame] | 730 | flatten_dim = shader_is_flatten_dimensions(shader[1]) |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 731 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | 0474848 | 2019-03-19 10:58:37 +0100 | [diff] [blame] | 732 | push_ubo = shader_is_push_ubo(shader[1]) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 733 | |
| 734 | print('Testing shader:', joined_path) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 735 | spirv, glsl, vulkan_glsl = cross_compile(joined_path, vulkan, is_spirv, invalid_spirv, eliminate, is_legacy, flatten_ubo, sso, flatten_dim, args.opt and (not noopt), push_ubo, args.iterations, paths) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 736 | |
Hans-Kristian Arntzen | 8869a16 | 2016-05-11 19:55:57 +0200 | [diff] [blame] | 737 | # Only test GLSL stats if we have a shader following GL semantics. |
Hans-Kristian Arntzen | b684716 | 2016-09-10 12:52:23 +0200 | [diff] [blame] | 738 | if stats and (not vulkan) and (not is_spirv) and (not desktop): |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 739 | cross_stats = get_shader_stats(glsl) |
| 740 | |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 741 | if glsl: |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 742 | regression_check(shader, glsl, args) |
Hans-Kristian Arntzen | dbee4e4 | 2016-05-05 10:16:22 +0200 | [diff] [blame] | 743 | if vulkan_glsl: |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 744 | regression_check((shader[0], shader[1] + '.vk'), vulkan_glsl, args) |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 745 | |
| 746 | remove_file(spirv) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 747 | |
Hans-Kristian Arntzen | b684716 | 2016-09-10 12:52:23 +0200 | [diff] [blame] | 748 | if stats and (not vulkan) and (not is_spirv) and (not desktop): |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 749 | pristine_stats = get_shader_stats(joined_path) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 750 | |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 751 | a = [] |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 752 | a.append(shader[1]) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 753 | for i in pristine_stats: |
| 754 | a.append(str(i)) |
| 755 | for i in cross_stats: |
| 756 | a.append(str(i)) |
| 757 | print(','.join(a), file = stats) |
| 758 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 759 | def test_shader_msl(stats, shader, args, paths): |
Hans-Kristian Arntzen | 1c28ec6 | 2017-01-18 19:05:57 +0100 | [diff] [blame] | 760 | joined_path = os.path.join(shader[0], shader[1]) |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 761 | print('\nTesting MSL shader:', joined_path) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 762 | is_spirv = shader_is_spirv(shader[1]) |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 763 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 764 | spirv, msl = cross_compile_msl(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths) |
| 765 | regression_check(shader, msl, args) |
Bill Hollings | a68b327 | 2017-12-26 16:32:45 -0500 | [diff] [blame] | 766 | |
| 767 | # Uncomment the following line to print the temp SPIR-V file path. |
| 768 | # This temp SPIR-V file is not deleted until after the Metal validation step below. |
| 769 | # If Metal validation fails, the temp SPIR-V file can be copied out and |
| 770 | # used as input to an invocation of spirv-cross to debug from Xcode directly. |
| 771 | # To do so, build spriv-cross using `make DEBUG=1`, then run the spriv-cross |
| 772 | # executable from Xcode using args: `--msl --entry main --output msl_path spirv_path`. |
| 773 | # print('SPRIV shader: ' + spirv) |
Hans-Kristian Arntzen | 70743b9 | 2017-02-05 11:04:45 +0100 | [diff] [blame] | 774 | |
Hans-Kristian Arntzen | 33fc2ad | 2019-06-18 10:35:17 +0200 | [diff] [blame] | 775 | shader_is_msl22 = 'msl22' in joined_path |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 776 | shader_is_msl23 = 'msl23' in joined_path |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 777 | shader_is_msl24 = 'msl24' in joined_path |
| 778 | skip_validation = (shader_is_msl22 and (not args.msl22)) or (shader_is_msl23 and (not args.msl23)) or (shader_is_msl24 and (not args.msl24)) |
Hans-Kristian Arntzen | 33fc2ad | 2019-06-18 10:35:17 +0200 | [diff] [blame] | 779 | if '.invalid.' in joined_path: |
| 780 | skip_validation = True |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 781 | |
| 782 | if (not args.force_no_external_validation) and (not skip_validation): |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 783 | validate_shader_msl(shader, args.opt) |
Hans-Kristian Arntzen | 1c28ec6 | 2017-01-18 19:05:57 +0100 | [diff] [blame] | 784 | |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 785 | remove_file(spirv) |
Bill Hollings | a68b327 | 2017-12-26 16:32:45 -0500 | [diff] [blame] | 786 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 787 | def test_shader_hlsl(stats, shader, args, paths): |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 788 | joined_path = os.path.join(shader[0], shader[1]) |
| 789 | print('Testing HLSL shader:', joined_path) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 790 | is_spirv = shader_is_spirv(shader[1]) |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 791 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 792 | spirv, hlsl = cross_compile_hlsl(joined_path, is_spirv, args.opt and (not noopt), args.force_no_external_validation, args.iterations, paths) |
| 793 | regression_check(shader, hlsl, args) |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 794 | remove_file(spirv) |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 795 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 796 | def test_shader_reflect(stats, shader, args, paths): |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 797 | joined_path = os.path.join(shader[0], shader[1]) |
| 798 | print('Testing shader reflection:', joined_path) |
| 799 | is_spirv = shader_is_spirv(shader[1]) |
| 800 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 801 | spirv, reflect = cross_compile_reflect(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths) |
| 802 | regression_check_reflect(shader, reflect, args) |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 803 | remove_file(spirv) |
| 804 | |
Hans-Kristian Arntzen | 852e63e | 2019-03-07 12:43:00 +0100 | [diff] [blame] | 805 | def test_shader_file(relpath, stats, args, backend): |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 806 | paths = Paths(args.spirv_cross, args.glslang, args.spirv_as, args.spirv_val, args.spirv_opt) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 807 | try: |
| 808 | if backend == 'msl': |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 809 | test_shader_msl(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 810 | elif backend == 'hlsl': |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 811 | test_shader_hlsl(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 812 | elif backend == 'reflect': |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 813 | test_shader_reflect(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 814 | else: |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 815 | test_shader(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 816 | return None |
| 817 | except Exception as e: |
| 818 | return e |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 819 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 820 | def test_shaders_helper(stats, backend, args): |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 821 | all_files = [] |
| 822 | for root, dirs, files in os.walk(os.path.join(args.folder)): |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 823 | files = [ f for f in files if not f.startswith(".") ] #ignore system files (esp OSX) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 824 | for i in files: |
| 825 | path = os.path.join(root, i) |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 826 | relpath = os.path.relpath(path, args.folder) |
| 827 | all_files.append(relpath) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 828 | |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 829 | # The child processes in parallel execution mode don't have the proper state for the global args variable, so |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 830 | # at this point we need to switch to explicit arguments |
| 831 | if args.parallel: |
Hans-Kristian Arntzen | 35a9b79 | 2020-04-27 16:44:14 +0200 | [diff] [blame] | 832 | with multiprocessing.Pool(multiprocessing.cpu_count()) as pool: |
| 833 | results = [] |
| 834 | for f in all_files: |
| 835 | results.append(pool.apply_async(test_shader_file, |
| 836 | args = (f, stats, args, backend))) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 837 | |
Hans-Kristian Arntzen | 35a9b79 | 2020-04-27 16:44:14 +0200 | [diff] [blame] | 838 | pool.close() |
| 839 | pool.join() |
| 840 | results_completed = [res.get() for res in results] |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 841 | |
Hans-Kristian Arntzen | 35a9b79 | 2020-04-27 16:44:14 +0200 | [diff] [blame] | 842 | for error in results_completed: |
| 843 | if error is not None: |
| 844 | print('Error:', error) |
| 845 | sys.exit(1) |
| 846 | |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 847 | else: |
| 848 | for i in all_files: |
Hans-Kristian Arntzen | 852e63e | 2019-03-07 12:43:00 +0100 | [diff] [blame] | 849 | e = test_shader_file(i, stats, args, backend) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 850 | if e is not None: |
| 851 | print('Error:', e) |
| 852 | sys.exit(1) |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 853 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 854 | def test_shaders(backend, args): |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 855 | if args.malisc: |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 856 | with open('stats.csv', 'w') as stats: |
| 857 | print('Shader,OrigRegs,OrigUniRegs,OrigALUShort,OrigLSShort,OrigTEXShort,OrigALULong,OrigLSLong,OrigTEXLong,CrossRegs,CrossUniRegs,CrossALUShort,CrossLSShort,CrossTEXShort,CrossALULong,CrossLSLong,CrossTEXLong', file = stats) |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 858 | test_shaders_helper(stats, backend, args) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 859 | else: |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 860 | test_shaders_helper(None, backend, args) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 861 | |
| 862 | def main(): |
| 863 | parser = argparse.ArgumentParser(description = 'Script for regression testing.') |
| 864 | parser.add_argument('folder', |
| 865 | help = 'Folder containing shader files to test.') |
| 866 | parser.add_argument('--update', |
| 867 | action = 'store_true', |
| 868 | help = 'Updates reference files if there is a mismatch. Use when legitimate changes in output is found.') |
Hans-Kristian Arntzen | e50e04c | 2016-03-22 14:56:50 +0100 | [diff] [blame] | 869 | parser.add_argument('--keep', |
| 870 | action = 'store_true', |
| 871 | help = 'Leave failed GLSL shaders on disk if they fail regression. Useful for debugging.') |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 872 | parser.add_argument('--malisc', |
| 873 | action = 'store_true', |
Hans-Kristian Arntzen | 147e53a | 2016-04-04 09:36:04 +0200 | [diff] [blame] | 874 | help = 'Use malisc offline compiler to determine static cycle counts before and after spirv-cross.') |
Bill Hollings | 5ad73f3 | 2017-03-19 21:06:21 -0400 | [diff] [blame] | 875 | parser.add_argument('--msl', |
Hans-Kristian Arntzen | 1c28ec6 | 2017-01-18 19:05:57 +0100 | [diff] [blame] | 876 | action = 'store_true', |
| 877 | help = 'Test Metal backend.') |
Bill Hollings | 6fdb534 | 2017-03-19 21:46:06 -0400 | [diff] [blame] | 878 | parser.add_argument('--metal', |
| 879 | action = 'store_true', |
| 880 | help = 'Deprecated Metal option. Use --msl instead.') |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 881 | parser.add_argument('--hlsl', |
| 882 | action = 'store_true', |
| 883 | help = 'Test HLSL backend.') |
Hans-Kristian Arntzen | 70743b9 | 2017-02-05 11:04:45 +0100 | [diff] [blame] | 884 | parser.add_argument('--force-no-external-validation', |
| 885 | action = 'store_true', |
| 886 | help = 'Disable all external validation.') |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 887 | parser.add_argument('--opt', |
| 888 | action = 'store_true', |
| 889 | help = 'Run SPIRV-Tools optimization passes as well.') |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 890 | parser.add_argument('--reflect', |
| 891 | action = 'store_true', |
| 892 | help = 'Test reflection backend.') |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 893 | parser.add_argument('--parallel', |
| 894 | action = 'store_true', |
| 895 | help = 'Execute tests in parallel. Useful for doing regression quickly, but bad for debugging and stat output.') |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 896 | parser.add_argument('--spirv-cross', |
| 897 | default = './spirv-cross', |
| 898 | help = 'Explicit path to spirv-cross') |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 899 | parser.add_argument('--glslang', |
| 900 | default = 'glslangValidator', |
| 901 | help = 'Explicit path to glslangValidator') |
| 902 | parser.add_argument('--spirv-as', |
| 903 | default = 'spirv-as', |
| 904 | help = 'Explicit path to spirv-as') |
| 905 | parser.add_argument('--spirv-val', |
| 906 | default = 'spirv-val', |
| 907 | help = 'Explicit path to spirv-val') |
| 908 | parser.add_argument('--spirv-opt', |
| 909 | default = 'spirv-opt', |
| 910 | help = 'Explicit path to spirv-opt') |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 911 | parser.add_argument('--iterations', |
| 912 | default = 1, |
| 913 | type = int, |
| 914 | help = 'Number of iterations to run SPIRV-Cross (benchmarking)') |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 915 | |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 916 | args = parser.parse_args() |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 917 | if not args.folder: |
| 918 | sys.stderr.write('Need shader folder.\n') |
| 919 | sys.exit(1) |
| 920 | |
Brad Davis | 7620400 | 2018-06-20 10:25:38 -0700 | [diff] [blame] | 921 | if (args.parallel and (args.malisc or args.force_no_external_validation or args.update)): |
| 922 | sys.stderr.write('Parallel execution is disabled when using the flags --update, --malisc or --force-no-external-validation\n') |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 923 | args.parallel = False |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 924 | |
Hans-Kristian Arntzen | 856a8d2 | 2019-06-18 12:22:46 +0200 | [diff] [blame] | 925 | args.msl22 = False |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 926 | args.msl23 = False |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 927 | args.msl24 = False |
Bill Hollings | 5ad73f3 | 2017-03-19 21:06:21 -0400 | [diff] [blame] | 928 | if args.msl: |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 929 | print_msl_compiler_version() |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 930 | args.msl22 = msl_compiler_supports_version('2.2') |
| 931 | args.msl23 = msl_compiler_supports_version('2.3') |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 932 | args.msl24 = msl_compiler_supports_version('2.4') |
Arseny Kapoulkine | 49baf41 | 2017-01-25 00:01:53 -0800 | [diff] [blame] | 933 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 934 | backend = 'glsl' |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 935 | if (args.msl or args.metal): |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 936 | backend = 'msl' |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 937 | elif args.hlsl: |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 938 | backend = 'hlsl' |
| 939 | elif args.reflect: |
| 940 | backend = 'reflect' |
Hans-Kristian Arntzen | 70743b9 | 2017-02-05 11:04:45 +0100 | [diff] [blame] | 941 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 942 | test_shaders(backend, args) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 943 | if args.malisc: |
| 944 | print('Stats in stats.csv!') |
Hans-Kristian Arntzen | e50e04c | 2016-03-22 14:56:50 +0100 | [diff] [blame] | 945 | print('Tests completed!') |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 946 | |
| 947 | if __name__ == '__main__': |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 948 | main() |