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)) |
Sebastián Aedo | 2bb0512 | 2021-12-09 13:29:12 -0300 | [diff] [blame^] | 632 | if args.diff: |
| 633 | diff_path = generate_diff_file(reference, glsl) |
| 634 | with open(diff_path, 'r') as f: |
| 635 | print('') |
| 636 | print('Diff:') |
| 637 | print(f.read()) |
| 638 | print('') |
| 639 | remove_file(diff_path) |
| 640 | else: |
| 641 | with open(json_file, 'r') as f: |
| 642 | print('') |
| 643 | print('Generated:') |
| 644 | print('======================') |
| 645 | print(f.read()) |
| 646 | print('======================') |
| 647 | print('') |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 648 | |
| 649 | # 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] | 650 | if not args.keep: |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 651 | remove_file(json_file) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 652 | |
| 653 | raise RuntimeError('Does not match reference') |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 654 | else: |
| 655 | remove_file(json_file) |
| 656 | else: |
| 657 | print('Found new shader {}. Placing generated source code in {}'.format(joined_path, reference)) |
| 658 | make_reference_dir(reference) |
| 659 | shutil.move(json_file, reference) |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 660 | |
Sebastián Aedo | 2bb0512 | 2021-12-09 13:29:12 -0300 | [diff] [blame^] | 661 | def generate_diff_file(origin, generated): |
| 662 | diff_destination = create_temporary() |
| 663 | with open(diff_destination, "w") as f: |
| 664 | try: |
| 665 | subprocess.check_call(["diff", origin, generated], stdout=f) |
| 666 | except subprocess.CalledProcessError as e: |
| 667 | # diff returns 1 when the files are different so we can safely |
| 668 | # ignore this case. |
| 669 | if e.returncode != 1: |
| 670 | raise e |
| 671 | |
| 672 | return diff_destination |
| 673 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 674 | def regression_check(shader, glsl, args): |
| 675 | reference = reference_path(shader[0], shader[1], args.opt) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 676 | joined_path = os.path.join(shader[0], shader[1]) |
| 677 | print('Reference shader path:', reference) |
| 678 | |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 679 | if os.path.exists(reference): |
| 680 | if md5_for_file(glsl) != md5_for_file(reference): |
Hans-Kristian Arntzen | 9ae91c2 | 2019-04-10 11:33:52 +0200 | [diff] [blame] | 681 | if args.update: |
Bill Hollings | 77f5812 | 2017-08-11 14:54:58 -0400 | [diff] [blame] | 682 | print('Generated source code has changed for {}!'.format(reference)) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 683 | # If we expect changes, update the reference file. |
| 684 | if os.path.exists(reference): |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 685 | remove_file(reference) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 686 | make_reference_dir(reference) |
| 687 | shutil.move(glsl, reference) |
| 688 | else: |
Bill Hollings | 77f5812 | 2017-08-11 14:54:58 -0400 | [diff] [blame] | 689 | print('Generated source code in {} does not match reference {}!'.format(glsl, reference)) |
Sebastián Aedo | 2bb0512 | 2021-12-09 13:29:12 -0300 | [diff] [blame^] | 690 | if args.diff: |
| 691 | diff_path = generate_diff_file(reference, glsl) |
| 692 | with open(diff_path, 'r') as f: |
| 693 | print('') |
| 694 | print('Diff:') |
| 695 | print(f.read()) |
| 696 | print('') |
| 697 | remove_file(diff_path) |
| 698 | else: |
| 699 | with open(glsl, 'r') as f: |
| 700 | print('') |
| 701 | print('Generated:') |
| 702 | print('======================') |
| 703 | print(f.read()) |
| 704 | print('======================') |
| 705 | print('') |
Hans-Kristian Arntzen | 45c797d | 2016-12-16 13:48:30 +0100 | [diff] [blame] | 706 | |
Hans-Kristian Arntzen | e50e04c | 2016-03-22 14:56:50 +0100 | [diff] [blame] | 707 | # 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] | 708 | if not args.keep: |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 709 | remove_file(glsl) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 710 | raise RuntimeError('Does not match reference') |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 711 | else: |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 712 | remove_file(glsl) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 713 | else: |
Bill Hollings | 77f5812 | 2017-08-11 14:54:58 -0400 | [diff] [blame] | 714 | 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] | 715 | make_reference_dir(reference) |
| 716 | shutil.move(glsl, reference) |
| 717 | |
Hans-Kristian Arntzen | 8869a16 | 2016-05-11 19:55:57 +0200 | [diff] [blame] | 718 | def shader_is_vulkan(shader): |
| 719 | return '.vk.' in shader |
| 720 | |
Hans-Kristian Arntzen | 2c7d2e4 | 2016-07-11 12:47:46 +0200 | [diff] [blame] | 721 | def shader_is_desktop(shader): |
| 722 | return '.desktop.' in shader |
| 723 | |
Hans-Kristian Arntzen | f61a5d1 | 2016-08-26 12:58:50 +0200 | [diff] [blame] | 724 | def shader_is_eliminate_dead_variables(shader): |
| 725 | return '.noeliminate.' not in shader |
| 726 | |
Hans-Kristian Arntzen | 45ad58a | 2016-05-10 23:39:41 +0200 | [diff] [blame] | 727 | def shader_is_spirv(shader): |
| 728 | return '.asm.' in shader |
| 729 | |
Hans-Kristian Arntzen | 706d3ea | 2016-09-12 20:11:30 +0200 | [diff] [blame] | 730 | def shader_is_invalid_spirv(shader): |
| 731 | return '.invalid.' in shader |
| 732 | |
Hans-Kristian Arntzen | 41f7e5b | 2017-01-13 16:41:27 +0100 | [diff] [blame] | 733 | def shader_is_legacy(shader): |
| 734 | return '.legacy.' in shader |
| 735 | |
Arseny Kapoulkine | 24c6625 | 2017-01-16 14:19:49 -0800 | [diff] [blame] | 736 | def shader_is_flatten_ubo(shader): |
| 737 | return '.flatten.' in shader |
| 738 | |
Hans-Kristian Arntzen | 36650c8 | 2017-05-22 15:30:43 +0200 | [diff] [blame] | 739 | def shader_is_sso(shader): |
| 740 | return '.sso.' in shader |
| 741 | |
Hans-Kristian Arntzen | 470ae7a | 2017-05-22 17:40:00 +0200 | [diff] [blame] | 742 | def shader_is_flatten_dimensions(shader): |
| 743 | return '.flatten_dim.' in shader |
| 744 | |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 745 | def shader_is_noopt(shader): |
| 746 | return '.noopt.' in shader |
| 747 | |
Hans-Kristian Arntzen | 0474848 | 2019-03-19 10:58:37 +0100 | [diff] [blame] | 748 | def shader_is_push_ubo(shader): |
| 749 | return '.push-ubo.' in shader |
| 750 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 751 | def test_shader(stats, shader, args, paths): |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 752 | joined_path = os.path.join(shader[0], shader[1]) |
Hans-Kristian Arntzen | 8869a16 | 2016-05-11 19:55:57 +0200 | [diff] [blame] | 753 | vulkan = shader_is_vulkan(shader[1]) |
Hans-Kristian Arntzen | 2c7d2e4 | 2016-07-11 12:47:46 +0200 | [diff] [blame] | 754 | desktop = shader_is_desktop(shader[1]) |
Hans-Kristian Arntzen | f61a5d1 | 2016-08-26 12:58:50 +0200 | [diff] [blame] | 755 | eliminate = shader_is_eliminate_dead_variables(shader[1]) |
Hans-Kristian Arntzen | b684716 | 2016-09-10 12:52:23 +0200 | [diff] [blame] | 756 | is_spirv = shader_is_spirv(shader[1]) |
Hans-Kristian Arntzen | 706d3ea | 2016-09-12 20:11:30 +0200 | [diff] [blame] | 757 | invalid_spirv = shader_is_invalid_spirv(shader[1]) |
Hans-Kristian Arntzen | 41f7e5b | 2017-01-13 16:41:27 +0100 | [diff] [blame] | 758 | is_legacy = shader_is_legacy(shader[1]) |
Arseny Kapoulkine | 24c6625 | 2017-01-16 14:19:49 -0800 | [diff] [blame] | 759 | flatten_ubo = shader_is_flatten_ubo(shader[1]) |
Hans-Kristian Arntzen | 36650c8 | 2017-05-22 15:30:43 +0200 | [diff] [blame] | 760 | sso = shader_is_sso(shader[1]) |
Hans-Kristian Arntzen | 470ae7a | 2017-05-22 17:40:00 +0200 | [diff] [blame] | 761 | flatten_dim = shader_is_flatten_dimensions(shader[1]) |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 762 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | 0474848 | 2019-03-19 10:58:37 +0100 | [diff] [blame] | 763 | push_ubo = shader_is_push_ubo(shader[1]) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 764 | |
| 765 | print('Testing shader:', joined_path) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 766 | 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] | 767 | |
Hans-Kristian Arntzen | 8869a16 | 2016-05-11 19:55:57 +0200 | [diff] [blame] | 768 | # 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] | 769 | 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] | 770 | cross_stats = get_shader_stats(glsl) |
| 771 | |
Hans-Kristian Arntzen | 146ea76 | 2018-04-11 10:28:39 +0200 | [diff] [blame] | 772 | if glsl: |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 773 | regression_check(shader, glsl, args) |
Hans-Kristian Arntzen | dbee4e4 | 2016-05-05 10:16:22 +0200 | [diff] [blame] | 774 | if vulkan_glsl: |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 775 | regression_check((shader[0], shader[1] + '.vk'), vulkan_glsl, args) |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 776 | |
| 777 | remove_file(spirv) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 778 | |
Hans-Kristian Arntzen | b684716 | 2016-09-10 12:52:23 +0200 | [diff] [blame] | 779 | 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] | 780 | pristine_stats = get_shader_stats(joined_path) |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 781 | |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 782 | a = [] |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 783 | a.append(shader[1]) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 784 | for i in pristine_stats: |
| 785 | a.append(str(i)) |
| 786 | for i in cross_stats: |
| 787 | a.append(str(i)) |
| 788 | print(','.join(a), file = stats) |
| 789 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 790 | def test_shader_msl(stats, shader, args, paths): |
Hans-Kristian Arntzen | 1c28ec6 | 2017-01-18 19:05:57 +0100 | [diff] [blame] | 791 | joined_path = os.path.join(shader[0], shader[1]) |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 792 | print('\nTesting MSL shader:', joined_path) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 793 | is_spirv = shader_is_spirv(shader[1]) |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 794 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 795 | spirv, msl = cross_compile_msl(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths) |
| 796 | regression_check(shader, msl, args) |
Bill Hollings | a68b327 | 2017-12-26 16:32:45 -0500 | [diff] [blame] | 797 | |
| 798 | # Uncomment the following line to print the temp SPIR-V file path. |
| 799 | # This temp SPIR-V file is not deleted until after the Metal validation step below. |
| 800 | # If Metal validation fails, the temp SPIR-V file can be copied out and |
| 801 | # used as input to an invocation of spirv-cross to debug from Xcode directly. |
| 802 | # To do so, build spriv-cross using `make DEBUG=1`, then run the spriv-cross |
| 803 | # executable from Xcode using args: `--msl --entry main --output msl_path spirv_path`. |
| 804 | # print('SPRIV shader: ' + spirv) |
Hans-Kristian Arntzen | 70743b9 | 2017-02-05 11:04:45 +0100 | [diff] [blame] | 805 | |
Hans-Kristian Arntzen | 33fc2ad | 2019-06-18 10:35:17 +0200 | [diff] [blame] | 806 | shader_is_msl22 = 'msl22' in joined_path |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 807 | shader_is_msl23 = 'msl23' in joined_path |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 808 | shader_is_msl24 = 'msl24' in joined_path |
| 809 | 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] | 810 | if '.invalid.' in joined_path: |
| 811 | skip_validation = True |
Hans-Kristian Arntzen | be1e27a | 2019-06-17 16:06:14 +0200 | [diff] [blame] | 812 | |
| 813 | if (not args.force_no_external_validation) and (not skip_validation): |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 814 | validate_shader_msl(shader, args.opt) |
Hans-Kristian Arntzen | 1c28ec6 | 2017-01-18 19:05:57 +0100 | [diff] [blame] | 815 | |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 816 | remove_file(spirv) |
Bill Hollings | a68b327 | 2017-12-26 16:32:45 -0500 | [diff] [blame] | 817 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 818 | def test_shader_hlsl(stats, shader, args, paths): |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 819 | joined_path = os.path.join(shader[0], shader[1]) |
| 820 | print('Testing HLSL shader:', joined_path) |
Hans-Kristian Arntzen | db5d49f | 2017-09-29 11:07:11 +0200 | [diff] [blame] | 821 | is_spirv = shader_is_spirv(shader[1]) |
Hans-Kristian Arntzen | 7e02f7f | 2017-11-22 11:04:29 +0100 | [diff] [blame] | 822 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 823 | spirv, hlsl = cross_compile_hlsl(joined_path, is_spirv, args.opt and (not noopt), args.force_no_external_validation, args.iterations, paths) |
| 824 | regression_check(shader, hlsl, args) |
Hans-Kristian Arntzen | cd442b9 | 2018-04-27 10:31:39 +0200 | [diff] [blame] | 825 | remove_file(spirv) |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 826 | |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 827 | def test_shader_reflect(stats, shader, args, paths): |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 828 | joined_path = os.path.join(shader[0], shader[1]) |
| 829 | print('Testing shader reflection:', joined_path) |
| 830 | is_spirv = shader_is_spirv(shader[1]) |
| 831 | noopt = shader_is_noopt(shader[1]) |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 832 | spirv, reflect = cross_compile_reflect(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths) |
| 833 | regression_check_reflect(shader, reflect, args) |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 834 | remove_file(spirv) |
| 835 | |
Hans-Kristian Arntzen | 852e63e | 2019-03-07 12:43:00 +0100 | [diff] [blame] | 836 | def test_shader_file(relpath, stats, args, backend): |
Hans-Kristian Arntzen | 3a7cb0c | 2019-04-12 14:44:24 +0200 | [diff] [blame] | 837 | 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] | 838 | try: |
| 839 | if backend == 'msl': |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 840 | test_shader_msl(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 841 | elif backend == 'hlsl': |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 842 | test_shader_hlsl(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 843 | elif backend == 'reflect': |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 844 | test_shader_reflect(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 845 | else: |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 846 | test_shader(stats, (args.folder, relpath), args, paths) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 847 | return None |
| 848 | except Exception as e: |
| 849 | return e |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 850 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 851 | def test_shaders_helper(stats, backend, args): |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 852 | all_files = [] |
| 853 | for root, dirs, files in os.walk(os.path.join(args.folder)): |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 854 | 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] | 855 | for i in files: |
| 856 | path = os.path.join(root, i) |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 857 | relpath = os.path.relpath(path, args.folder) |
| 858 | all_files.append(relpath) |
Hans-Kristian Arntzen | 78c9a80 | 2016-05-11 19:39:38 +0200 | [diff] [blame] | 859 | |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 860 | # 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] | 861 | # at this point we need to switch to explicit arguments |
| 862 | if args.parallel: |
Hans-Kristian Arntzen | 35a9b79 | 2020-04-27 16:44:14 +0200 | [diff] [blame] | 863 | with multiprocessing.Pool(multiprocessing.cpu_count()) as pool: |
| 864 | results = [] |
| 865 | for f in all_files: |
| 866 | results.append(pool.apply_async(test_shader_file, |
| 867 | args = (f, stats, args, backend))) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 868 | |
Hans-Kristian Arntzen | 35a9b79 | 2020-04-27 16:44:14 +0200 | [diff] [blame] | 869 | pool.close() |
| 870 | pool.join() |
| 871 | results_completed = [res.get() for res in results] |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 872 | |
Hans-Kristian Arntzen | 35a9b79 | 2020-04-27 16:44:14 +0200 | [diff] [blame] | 873 | for error in results_completed: |
| 874 | if error is not None: |
| 875 | print('Error:', error) |
| 876 | sys.exit(1) |
| 877 | |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 878 | else: |
| 879 | for i in all_files: |
Hans-Kristian Arntzen | 852e63e | 2019-03-07 12:43:00 +0100 | [diff] [blame] | 880 | e = test_shader_file(i, stats, args, backend) |
Hans-Kristian Arntzen | 973b315 | 2019-01-14 11:23:46 +0100 | [diff] [blame] | 881 | if e is not None: |
| 882 | print('Error:', e) |
| 883 | sys.exit(1) |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 884 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 885 | def test_shaders(backend, args): |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 886 | if args.malisc: |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 887 | with open('stats.csv', 'w') as stats: |
| 888 | 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] | 889 | test_shaders_helper(stats, backend, args) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 890 | else: |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 891 | test_shaders_helper(None, backend, args) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 892 | |
| 893 | def main(): |
| 894 | parser = argparse.ArgumentParser(description = 'Script for regression testing.') |
| 895 | parser.add_argument('folder', |
| 896 | help = 'Folder containing shader files to test.') |
| 897 | parser.add_argument('--update', |
| 898 | action = 'store_true', |
| 899 | 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] | 900 | parser.add_argument('--keep', |
| 901 | action = 'store_true', |
| 902 | help = 'Leave failed GLSL shaders on disk if they fail regression. Useful for debugging.') |
Sebastián Aedo | 2bb0512 | 2021-12-09 13:29:12 -0300 | [diff] [blame^] | 903 | parser.add_argument('--diff', |
| 904 | action = 'store_true', |
| 905 | help = 'Displays a diff instead of the generated output on failure. Useful for debugging.') |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 906 | parser.add_argument('--malisc', |
| 907 | action = 'store_true', |
Hans-Kristian Arntzen | 147e53a | 2016-04-04 09:36:04 +0200 | [diff] [blame] | 908 | 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] | 909 | parser.add_argument('--msl', |
Hans-Kristian Arntzen | 1c28ec6 | 2017-01-18 19:05:57 +0100 | [diff] [blame] | 910 | action = 'store_true', |
| 911 | help = 'Test Metal backend.') |
Bill Hollings | 6fdb534 | 2017-03-19 21:46:06 -0400 | [diff] [blame] | 912 | parser.add_argument('--metal', |
| 913 | action = 'store_true', |
| 914 | help = 'Deprecated Metal option. Use --msl instead.') |
Robert Konrad | cec9c70 | 2017-01-26 09:45:17 +0100 | [diff] [blame] | 915 | parser.add_argument('--hlsl', |
| 916 | action = 'store_true', |
| 917 | help = 'Test HLSL backend.') |
Hans-Kristian Arntzen | 70743b9 | 2017-02-05 11:04:45 +0100 | [diff] [blame] | 918 | parser.add_argument('--force-no-external-validation', |
| 919 | action = 'store_true', |
| 920 | help = 'Disable all external validation.') |
Hans-Kristian Arntzen | 230a012 | 2017-11-21 09:52:53 +0100 | [diff] [blame] | 921 | parser.add_argument('--opt', |
| 922 | action = 'store_true', |
| 923 | help = 'Run SPIRV-Tools optimization passes as well.') |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 924 | parser.add_argument('--reflect', |
| 925 | action = 'store_true', |
| 926 | help = 'Test reflection backend.') |
Brad Davis | d0a67ba | 2018-06-19 14:35:25 -0700 | [diff] [blame] | 927 | parser.add_argument('--parallel', |
| 928 | action = 'store_true', |
| 929 | 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] | 930 | parser.add_argument('--spirv-cross', |
| 931 | default = './spirv-cross', |
| 932 | help = 'Explicit path to spirv-cross') |
Hans-Kristian Arntzen | 074f765 | 2019-03-07 12:36:16 +0100 | [diff] [blame] | 933 | parser.add_argument('--glslang', |
| 934 | default = 'glslangValidator', |
| 935 | help = 'Explicit path to glslangValidator') |
| 936 | parser.add_argument('--spirv-as', |
| 937 | default = 'spirv-as', |
| 938 | help = 'Explicit path to spirv-as') |
| 939 | parser.add_argument('--spirv-val', |
| 940 | default = 'spirv-val', |
| 941 | help = 'Explicit path to spirv-val') |
| 942 | parser.add_argument('--spirv-opt', |
| 943 | default = 'spirv-opt', |
| 944 | help = 'Explicit path to spirv-opt') |
Hans-Kristian Arntzen | c60b9a1 | 2019-04-08 11:53:13 +0200 | [diff] [blame] | 945 | parser.add_argument('--iterations', |
| 946 | default = 1, |
| 947 | type = int, |
| 948 | help = 'Number of iterations to run SPIRV-Cross (benchmarking)') |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 949 | |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 950 | args = parser.parse_args() |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 951 | if not args.folder: |
| 952 | sys.stderr.write('Need shader folder.\n') |
| 953 | sys.exit(1) |
| 954 | |
Brad Davis | 7620400 | 2018-06-20 10:25:38 -0700 | [diff] [blame] | 955 | if (args.parallel and (args.malisc or args.force_no_external_validation or args.update)): |
| 956 | 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] | 957 | args.parallel = False |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 958 | |
Hans-Kristian Arntzen | 856a8d2 | 2019-06-18 12:22:46 +0200 | [diff] [blame] | 959 | args.msl22 = False |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 960 | args.msl23 = False |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 961 | args.msl24 = False |
Bill Hollings | 5ad73f3 | 2017-03-19 21:06:21 -0400 | [diff] [blame] | 962 | if args.msl: |
Bill Hollings | be4cb17 | 2017-01-30 22:55:21 -0500 | [diff] [blame] | 963 | print_msl_compiler_version() |
Chip Davis | 2219c4a | 2020-09-28 23:07:55 -0500 | [diff] [blame] | 964 | args.msl22 = msl_compiler_supports_version('2.2') |
| 965 | args.msl23 = msl_compiler_supports_version('2.3') |
丛越 | d52ec1e | 2021-10-21 17:46:45 +0800 | [diff] [blame] | 966 | args.msl24 = msl_compiler_supports_version('2.4') |
Arseny Kapoulkine | 49baf41 | 2017-01-25 00:01:53 -0800 | [diff] [blame] | 967 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 968 | backend = 'glsl' |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 969 | if (args.msl or args.metal): |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 970 | backend = 'msl' |
Dan Sinclair | e5af412 | 2019-11-05 10:59:41 -0500 | [diff] [blame] | 971 | elif args.hlsl: |
Brad Davis | 709d3c6 | 2018-06-03 11:16:37 -0700 | [diff] [blame] | 972 | backend = 'hlsl' |
| 973 | elif args.reflect: |
| 974 | backend = 'reflect' |
Hans-Kristian Arntzen | 70743b9 | 2017-02-05 11:04:45 +0100 | [diff] [blame] | 975 | |
Hans-Kristian Arntzen | 6157bf3 | 2018-10-26 10:53:11 +0200 | [diff] [blame] | 976 | test_shaders(backend, args) |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 977 | if args.malisc: |
| 978 | print('Stats in stats.csv!') |
Hans-Kristian Arntzen | e50e04c | 2016-03-22 14:56:50 +0100 | [diff] [blame] | 979 | print('Tests completed!') |
Hans-Kristian Arntzen | 75471fb | 2016-03-02 18:09:16 +0100 | [diff] [blame] | 980 | |
| 981 | if __name__ == '__main__': |
Hans-Kristian Arntzen | 0a5b3a6 | 2016-03-22 14:44:12 +0100 | [diff] [blame] | 982 | main() |