text: #!/usr/bin/env python3
  
  import sys
  import os
  import os.path
  import subprocess
  import tempfile
  import re
  import itertools
  import hashlib
  import shutil
  import argparse
  import codecs
  import json
  import multiprocessing
  import errno
  from functools import partial
  
  class Paths():
      def __init__(self, spirv_cross, glslang, spirv_as, spirv_val, spirv_opt):
          self.spirv_cross = spirv_cross
          self.glslang = glslang
          self.spirv_as = spirv_as
          self.spirv_val = spirv_val
          self.spirv_opt = spirv_opt
  
  def remove_file(path):
      #print('Removing file:', path)
      os.remove(path)
  
  def create_temporary(suff = ''):
      f, path = tempfile.mkstemp(suffix = suff)
      os.close(f)
      #print('Creating temporary:', path)
      return path
  
  def parse_stats(stats):
      m = re.search('([0-9]+) work registers', stats)
      registers = int(m.group(1)) if m else 0
  
      m = re.search('([0-9]+) uniform registers', stats)
      uniform_regs = int(m.group(1)) if m else 0
  
      m_list = re.findall('(-?[0-9]+)\s+(-?[0-9]+)\s+(-?[0-9]+)', stats)
      alu_short = float(m_list[1][0]) if m_list else 0
      ls_short = float(m_list[1][1]) if m_list else 0
      tex_short = float(m_list[1][2]) if m_list else 0
      alu_long = float(m_list[2][0]) if m_list else 0
      ls_long = float(m_list[2][1]) if m_list else 0
      tex_long = float(m_list[2][2]) if m_list else 0
  
      return (registers, uniform_regs, alu_short, ls_short, tex_short, alu_long, ls_long, tex_long)
  
  def get_shader_type(shader):
      _, ext = os.path.splitext(shader)
      if ext == '.vert':
          return '--vertex'
      elif ext == '.frag':
          return '--fragment'
      elif ext == '.comp':
          return '--compute'
      elif ext == '.tesc':
          return '--tessellation_control'
      elif ext == '.tese':
          return '--tessellation_evaluation'
      elif ext == '.geom':
          return '--geometry'
      else:
          return ''
  
  def get_shader_stats(shader):
      path = create_temporary()
  
      p = subprocess.Popen(['malisc', get_shader_type(shader), '--core', 'Mali-T760', '-V', shader], stdout = subprocess.PIPE, stderr = subprocess.PIPE)
      stdout, stderr = p.communicate()
      remove_file(path)
  
      if p.returncode != 0:
          print(stderr.decode('utf-8'))
          raise OSError('malisc failed')
      p.wait()
  
      returned = stdout.decode('utf-8')
      return parse_stats(returned)
  
  def print_msl_compiler_version():
      try:
          subprocess.check_call(['xcrun', '--sdk', 'iphoneos', 'metal', '--version'])
          print('...are the Metal compiler characteristics.\n')   # display after so xcrun FNF is silent
      except OSError as e:
          if (e.errno != errno.ENOENT):    # Ignore xcrun not found error
              raise
      except subprocess.CalledProcessError:
          pass
  
  def msl_compiler_supports_22():
      try:
          subprocess.check_call(['xcrun', '--sdk', 'macosx', 'metal', '-x', 'metal', '-std=macos-metal2.2', '-'],
                  stdin = subprocess.DEVNULL, stdout = subprocess.DEVNULL, stderr = subprocess.DEVNULL)
          print('Current SDK supports MSL 2.2. Enabling validation for MSL 2.2 shaders.')
          return True
      except OSError as e:
          print('Failed to check if MSL 2.2 is not supported. It probably is not.')
          return False
      except subprocess.CalledProcessError:
          print('Current SDK does NOT support MSL 2.2. Disabling validation for MSL 2.2 shaders.')
          return False
  
  def path_to_msl_standard(shader):
      if '.ios.' in shader:
          if '.msl2.' in shader:
              return '-std=ios-metal2.0'
          elif '.msl21.' in shader:
              return '-std=ios-metal2.1'
          elif '.msl22.' in shader:
              return '-std=ios-metal2.2'
          elif '.msl11.' in shader:
              return '-std=ios-metal1.1'
          elif '.msl10.' in shader:
              return '-std=ios-metal1.0'
          else:
              return '-std=ios-metal1.2'
      else:
          if '.msl2.' in shader:
              return '-std=macos-metal2.0'
          elif '.msl21.' in shader:
              return '-std=macos-metal2.1'
          elif '.msl22.' in shader:
              return '-std=macos-metal2.2'
          elif '.msl11.' in shader:
              return '-std=macos-metal1.1'
          else:
              return '-std=macos-metal1.2'
  
  def path_to_msl_standard_cli(shader):
      if '.msl2.' in shader:
          return '20000'
      elif '.msl21.' in shader:
          return '20100'
      elif '.msl22.' in shader:
          return '20200'
      elif '.msl11.' in shader:
          return '10100'
      else:
          return '10200'
  
  def validate_shader_msl(shader, opt):
      msl_path = reference_path(shader[0], shader[1], opt)
      try:
          if '.ios.' in msl_path:
              msl_os = 'iphoneos'
          else:
              msl_os = 'macosx'
          subprocess.check_call(['xcrun', '--sdk', msl_os, 'metal', '-x', 'metal', path_to_msl_standard(msl_path), '-Werror', '-Wno-unused-variable', msl_path])
          print('Compiled Metal shader: ' + msl_path)   # display after so xcrun FNF is silent
      except OSError as oe:
          if (oe.errno != errno.ENOENT):   # Ignore xcrun not found error
              raise
      except subprocess.CalledProcessError:
          print('Error compiling Metal shader: ' + msl_path)
          raise RuntimeError('Failed to compile Metal shader')
  
  def cross_compile_msl(shader, spirv, opt, iterations, paths):
      spirv_path = create_temporary()
      msl_path = create_temporary(os.path.basename(shader))
  
      spirv_cmd = [paths.spirv_as, '--target-env', 'vulkan1.1', '-o', spirv_path, shader]
      if '.preserve.' in shader:
          spirv_cmd.append('--preserve-numeric-ids')
  
      if spirv:
          subprocess.check_call(spirv_cmd)
      else:
          subprocess.check_call([paths.glslang, '--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader])
  
      if opt:
          subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path])
  
      spirv_cross_path = paths.spirv_cross
  
      msl_args = [spirv_cross_path, '--entry', 'main', '--output', msl_path, spirv_path, '--msl', '--iterations', str(iterations)]
      msl_args.append('--msl-version')
      msl_args.append(path_to_msl_standard_cli(shader))
      if '.swizzle.' in shader:
          msl_args.append('--msl-swizzle-texture-samples')
      if '.ios.' in shader:
          msl_args.append('--msl-ios')
      if '.pad-fragment.' in shader:
          msl_args.append('--msl-pad-fragment-output')
      if '.capture.' in shader:
          msl_args.append('--msl-capture-output')
      if '.domain.' in shader:
          msl_args.append('--msl-domain-lower-left')
      if '.argument.' in shader:
          msl_args.append('--msl-argument-buffers')
      if '.texture-buffer-native.' in shader:
          msl_args.append('--msl-texture-buffer-native')
      if '.discrete.' in shader:
          # Arbitrary for testing purposes.
          msl_args.append('--msl-discrete-descriptor-set')
          msl_args.append('2')
          msl_args.append('--msl-discrete-descriptor-set')
          msl_args.append('3')
      if '.line.' in shader:
          msl_args.append('--emit-line-directives')
      if '.multiview.' in shader:
          msl_args.append('--msl-multiview')
  
      subprocess.check_call(msl_args)
  
      if not shader_is_invalid_spirv(msl_path):
          subprocess.check_call([paths.spirv_val, '--target-env', 'vulkan1.1', spirv_path])
  
      return (spirv_path, msl_path)
  
  def shader_model_hlsl(shader):
      if '.vert' in shader:
          if '.sm30.' in shader:
              return '-Tvs_3_0'
          else:
              return '-Tvs_5_1'
      elif '.frag' in shader:
          if '.sm30.' in shader:
              return '-Tps_3_0'
          else:
              return '-Tps_5_1'
      elif '.comp' in shader:
          return '-Tcs_5_1'
      else:
          return None
  
  def shader_to_win_path(shader):
      # It's (very) convenient to be able to run HLSL testing in wine on Unix-likes, so support that.
      try:
          with subprocess.Popen(['winepath', '-w', shader], stdout = subprocess.PIPE, stderr = subprocess.PIPE) as f:
              stdout_data, stderr_data = f.communicate()
              return stdout_data.decode('utf-8')
      except OSError as oe:
          if (oe.errno != errno.ENOENT): # Ignore not found errors
              return shader
      except subprocess.CalledProcessError:
          raise
  
      return shader
  
  ignore_fxc = False
  def validate_shader_hlsl(shader, force_no_external_validation, paths):
      if not '.nonuniformresource' in shader:
          # glslang HLSL does not support this, so rely on fxc to test it.
          subprocess.check_call([paths.glslang, '-e', 'main', '-D', '--target-env', 'vulkan1.1', '-V', shader])
      is_no_fxc = '.nofxc.' in shader
      global ignore_fxc
      if (not ignore_fxc) and (not force_no_external_validation) and (not is_no_fxc):
          try:
              win_path = shader_to_win_path(shader)
              args = ['fxc', '-nologo', shader_model_hlsl(shader), win_path]
              if '.nonuniformresource.' in shader:
                  args.append('/enable_unbounded_descriptor_tables')
              subprocess.check_call(args)
          except OSError as oe:
              if (oe.errno != errno.ENOENT): # Ignore not found errors
                  print('Failed to run FXC.')
                  ignore_fxc = True
                  raise
              else:
                  print('Could not find FXC.')
                  ignore_fxc = True
          except subprocess.CalledProcessError:
              print('Failed compiling HLSL shader:', shader, 'with FXC.')
              raise RuntimeError('Failed compiling HLSL shader')
  
  def shader_to_sm(shader):
      if '.sm60.' in shader:
          return '60'
      elif '.sm51.' in shader:
          return '51'
      elif '.sm30.' in shader:
          return '30'
      else:
          return '50'
  
  def cross_compile_hlsl(shader, spirv, opt, force_no_external_validation, iterations, paths):
      spirv_path = create_temporary()
      hlsl_path = create_temporary(os.path.basename(shader))
  
      spirv_cmd = [paths.spirv_as, '--target-env', 'vulkan1.1', '-o', spirv_path, shader]
      if '.preserve.' in shader:
          spirv_cmd.append('--preserve-numeric-ids')
  
      if spirv:
          subprocess.check_call(spirv_cmd)
      else:
          subprocess.check_call([paths.glslang, '--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader])
  
      if opt:
          subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path])
  
      spirv_cross_path = paths.spirv_cross
  
      sm = shader_to_sm(shader)
  
      hlsl_args = [spirv_cross_path, '--entry', 'main', '--output', hlsl_path, spirv_path, '--hlsl-enable-compat', '--hlsl', '--shader-model', sm, '--iterations', str(iterations)]
      if '.line.' in shader:
          hlsl_args.append('--emit-line-directives')
      subprocess.check_call(hlsl_args)
  
      if not shader_is_invalid_spirv(hlsl_path):
          subprocess.check_call([paths.spirv_val, '--target-env', 'vulkan1.1', spirv_path])
  
      validate_shader_hlsl(hlsl_path, force_no_external_validation, paths)
      
      return (spirv_path, hlsl_path)
  
  def cross_compile_reflect(shader, spirv, opt, iterations, paths):
      spirv_path = create_temporary()
      reflect_path = create_temporary(os.path.basename(shader))
  
      spirv_cmd = [paths.spirv_as, '--target-env', 'vulkan1.1', '-o', spirv_path, shader]
      if '.preserve.' in shader:
          spirv_cmd.append('--preserve-numeric-ids')
  
      if spirv:
          subprocess.check_call(spirv_cmd)
      else:
          subprocess.check_call([paths.glslang, '--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader])
  
      if opt:
          subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path])
  
      spirv_cross_path = paths.spirv_cross
  
      sm = shader_to_sm(shader)
      subprocess.check_call([spirv_cross_path, '--entry', 'main', '--output', reflect_path, spirv_path, '--reflect', '--iterations', str(iterations)])
      return (spirv_path, reflect_path)
  
  def validate_shader(shader, vulkan, paths):
      if vulkan:
          subprocess.check_call([paths.glslang, '--target-env', 'vulkan1.1', '-V', shader])
      else:
          subprocess.check_call([paths.glslang, shader])
  
  def cross_compile(shader, vulkan, spirv, invalid_spirv, eliminate, is_legacy, flatten_ubo, sso, flatten_dim, opt, push_ubo, iterations, paths):
      spirv_path = create_temporary()
      glsl_path = create_temporary(os.path.basename(shader))
  
      if vulkan or spirv:
          vulkan_glsl_path = create_temporary('vk' + os.path.basename(shader))
  
      spirv_cmd = [paths.spirv_as, '--target-env', 'vulkan1.1', '-o', spirv_path, shader]
      if '.preserve.' in shader:
          spirv_cmd.append('--preserve-numeric-ids')
  
      if spirv:
          subprocess.check_call(spirv_cmd)
      else:
          subprocess.check_call([paths.glslang, '--target-env', 'vulkan1.1', '-V', '-o', spirv_path, shader])
  
      if opt and (not invalid_spirv):
          subprocess.check_call([paths.spirv_opt, '--skip-validation', '-O', '-o', spirv_path, spirv_path])
  
      if not invalid_spirv:
          subprocess.check_call([paths.spirv_val, '--target-env', 'vulkan1.1', spirv_path])
  
      extra_args = ['--iterations', str(iterations)]
      if eliminate:
          extra_args += ['--remove-unused-variables']
      if is_legacy:
          extra_args += ['--version', '100', '--es']
      if flatten_ubo:
          extra_args += ['--flatten-ubo']
      if sso:
          extra_args += ['--separate-shader-objects']
      if flatten_dim:
          extra_args += ['--flatten-multidimensional-arrays']
      if push_ubo:
          extra_args += ['--glsl-emit-push-constant-as-ubo']
      if '.line.' in shader:
          extra_args += ['--emit-line-directives']
  
      spirv_cross_path = paths.spirv_cross
  
      # A shader might not be possible to make valid GLSL from, skip validation for this case.
      if not ('nocompat' in glsl_path):
          subprocess.check_call([spirv_cross_path, '--entry', 'main', '--output', glsl_path, spirv_path] + extra_args)
          validate_shader(glsl_path, False, paths)
      else:
          remove_file(glsl_path)
          glsl_path = None
  
      if vulkan or spirv:
          subprocess.check_call([spirv_cross_path, '--entry', 'main', '--vulkan-semantics', '--output', vulkan_glsl_path, spirv_path] + extra_args)
          validate_shader(vulkan_glsl_path, True, paths)
          # SPIR-V shaders might just want to validate Vulkan GLSL output, we don't always care about the output.
          if not vulkan:
              remove_file(vulkan_glsl_path)
  
      return (spirv_path, glsl_path, vulkan_glsl_path if vulkan else None)
  
  def make_unix_newline(buf):
      decoded = codecs.decode(buf, 'utf-8')
      decoded = decoded.replace('\r', '')
      return codecs.encode(decoded, 'utf-8')
  
  def md5_for_file(path):
      md5 = hashlib.md5()
      with open(path, 'rb') as f:
          for chunk in iter(lambda: make_unix_newline(f.read(8192)), b''):
              md5.update(chunk)
      return md5.digest()
  
  def make_reference_dir(path):
      base = os.path.dirname(path)
      if not os.path.exists(base):
          os.makedirs(base)
  
  def reference_path(directory, relpath, opt):
      split_paths = os.path.split(directory)
      reference_dir = os.path.join(split_paths[0], 'reference/' + ('opt/' if opt else ''))
      reference_dir = os.path.join(reference_dir, split_paths[1])
      return os.path.join(reference_dir, relpath)
  
  def json_ordered(obj):
      if isinstance(obj, dict):
          return sorted((k, json_ordered(v)) for k, v in obj.items())
      if isinstance(obj, list):
          return sorted(json_ordered(x) for x in obj)
      else:
          return obj
      
  def json_compare(json_a, json_b):
      return json_ordered(json_a) == json_ordered(json_b)
  
  def regression_check_reflect(shader, json_file, args):
      reference = reference_path(shader[0], shader[1], args.opt) + '.json'
      joined_path = os.path.join(shader[0], shader[1])
      print('Reference shader reflection path:', reference)
      if os.path.exists(reference):
          actual = ''
          expected = ''
          with open(json_file) as f:
              actual_json = f.read();
              actual = json.loads(actual_json)
          with open(reference) as f:
              expected = json.load(f)
          if (json_compare(actual, expected) != True):
              if args.update:
                  print('Generated reflection json has changed for {}!'.format(reference))
                  # If we expect changes, update the reference file.
                  if os.path.exists(reference):
                      remove_file(reference)
                  make_reference_dir(reference)
                  shutil.move(json_file, reference)
              else:
                  print('Generated reflection json in {} does not match reference {}!'.format(json_file, reference))
                  with open(json_file, 'r') as f:
                      print('')
                      print('Generated:')
                      print('======================')
                      print(f.read())
                      print('======================')
                      print('')
  
                  # Otherwise, fail the test. Keep the shader file around so we can inspect.
                  if not args.keep:
                      remove_file(json_file)
  
                  raise RuntimeError('Does not match reference')
          else:
              remove_file(json_file)
      else:
          print('Found new shader {}. Placing generated source code in {}'.format(joined_path, reference))
          make_reference_dir(reference)
          shutil.move(json_file, reference)
      
  def regression_check(shader, glsl, args):
      reference = reference_path(shader[0], shader[1], args.opt)
      joined_path = os.path.join(shader[0], shader[1])
      print('Reference shader path:', reference)
  
      if os.path.exists(reference):
          if md5_for_file(glsl) != md5_for_file(reference):
              if args.update:
                  print('Generated source code has changed for {}!'.format(reference))
                  # If we expect changes, update the reference file.
                  if os.path.exists(reference):
                      remove_file(reference)
                  make_reference_dir(reference)
                  shutil.move(glsl, reference)
              else:
                  print('Generated source code in {} does not match reference {}!'.format(glsl, reference))
                  with open(glsl, 'r') as f:
                      print('')
                      print('Generated:')
                      print('======================')
                      print(f.read())
                      print('======================')
                      print('')
  
                  # Otherwise, fail the test. Keep the shader file around so we can inspect.
                  if not args.keep:
                      remove_file(glsl)
                  raise RuntimeError('Does not match reference')
          else:
              remove_file(glsl)
      else:
          print('Found new shader {}. Placing generated source code in {}'.format(joined_path, reference))
          make_reference_dir(reference)
          shutil.move(glsl, reference)
  
  def shader_is_vulkan(shader):
      return '.vk.' in shader
  
  def shader_is_desktop(shader):
      return '.desktop.' in shader
  
  def shader_is_eliminate_dead_variables(shader):
      return '.noeliminate.' not in shader
  
  def shader_is_spirv(shader):
      return '.asm.' in shader
  
  def shader_is_invalid_spirv(shader):
      return '.invalid.' in shader
  
  def shader_is_legacy(shader):
      return '.legacy.' in shader
  
  def shader_is_flatten_ubo(shader):
      return '.flatten.' in shader
  
  def shader_is_sso(shader):
      return '.sso.' in shader
  
  def shader_is_flatten_dimensions(shader):
      return '.flatten_dim.' in shader
  
  def shader_is_noopt(shader):
      return '.noopt.' in shader
  
  def shader_is_push_ubo(shader):
      return '.push-ubo.' in shader
  
  def test_shader(stats, shader, args, paths):
      joined_path = os.path.join(shader[0], shader[1])
      vulkan = shader_is_vulkan(shader[1])
      desktop = shader_is_desktop(shader[1])
      eliminate = shader_is_eliminate_dead_variables(shader[1])
      is_spirv = shader_is_spirv(shader[1])
      invalid_spirv = shader_is_invalid_spirv(shader[1])
      is_legacy = shader_is_legacy(shader[1])
      flatten_ubo = shader_is_flatten_ubo(shader[1])
      sso = shader_is_sso(shader[1])
      flatten_dim = shader_is_flatten_dimensions(shader[1])
      noopt = shader_is_noopt(shader[1])
      push_ubo = shader_is_push_ubo(shader[1])
  
      print('Testing shader:', joined_path)
      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)
  
      # Only test GLSL stats if we have a shader following GL semantics.
      if stats and (not vulkan) and (not is_spirv) and (not desktop):
          cross_stats = get_shader_stats(glsl)
  
      if glsl:
          regression_check(shader, glsl, args)
      if vulkan_glsl:
          regression_check((shader[0], shader[1] + '.vk'), vulkan_glsl, args)
  
      remove_file(spirv)
  
      if stats and (not vulkan) and (not is_spirv) and (not desktop):
          pristine_stats = get_shader_stats(joined_path)
  
          a = []
          a.append(shader[1])
          for i in pristine_stats:
              a.append(str(i))
          for i in cross_stats:
              a.append(str(i))
          print(','.join(a), file = stats)
  
  def test_shader_msl(stats, shader, args, paths):
      joined_path = os.path.join(shader[0], shader[1])
      print('\nTesting MSL shader:', joined_path)
      is_spirv = shader_is_spirv(shader[1])
      noopt = shader_is_noopt(shader[1])
      spirv, msl = cross_compile_msl(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths)
      regression_check(shader, msl, args)
  
      # Uncomment the following line to print the temp SPIR-V file path.
      # This temp SPIR-V file is not deleted until after the Metal validation step below.
      # If Metal validation fails, the temp SPIR-V file can be copied out and
      # used as input to an invocation of spirv-cross to debug from Xcode directly.
      # To do so, build spriv-cross using `make DEBUG=1`, then run the spriv-cross
      # executable from Xcode using args: `--msl --entry main --output msl_path spirv_path`.
  #    print('SPRIV shader: ' + spirv)
  
      shader_is_msl22 = 'msl22' in joined_path
      skip_validation = shader_is_msl22 and (not args.msl22)
      if '.invalid.' in joined_path:
          skip_validation = True
  
      if (not args.force_no_external_validation) and (not skip_validation):
          validate_shader_msl(shader, args.opt)
  
      remove_file(spirv)
  
  def test_shader_hlsl(stats, shader, args, paths):
      joined_path = os.path.join(shader[0], shader[1])
      print('Testing HLSL shader:', joined_path)
      is_spirv = shader_is_spirv(shader[1])
      noopt = shader_is_noopt(shader[1])
      spirv, hlsl = cross_compile_hlsl(joined_path, is_spirv, args.opt and (not noopt), args.force_no_external_validation, args.iterations, paths)
      regression_check(shader, hlsl, args)
      remove_file(spirv)
  
  def test_shader_reflect(stats, shader, args, paths):
      joined_path = os.path.join(shader[0], shader[1])
      print('Testing shader reflection:', joined_path)
      is_spirv = shader_is_spirv(shader[1])
      noopt = shader_is_noopt(shader[1])
      spirv, reflect = cross_compile_reflect(joined_path, is_spirv, args.opt and (not noopt), args.iterations, paths)
      regression_check_reflect(shader, reflect, args)
      remove_file(spirv)
  
  def test_shader_file(relpath, stats, args, backend):
      paths = Paths(args.spirv_cross, args.glslang, args.spirv_as, args.spirv_val, args.spirv_opt)
      try:
          if backend == 'msl':
              test_shader_msl(stats, (args.folder, relpath), args, paths)
          elif backend == 'hlsl':
              test_shader_hlsl(stats, (args.folder, relpath), args, paths)
          elif backend == 'reflect':
              test_shader_reflect(stats, (args.folder, relpath), args, paths)
          else:
              test_shader(stats, (args.folder, relpath), args, paths)
          return None
      except Exception as e:
          return e
  
  def test_shaders_helper(stats, backend, args):
      all_files = []
      for root, dirs, files in os.walk(os.path.join(args.folder)):
          files = [ f for f in files if not f.startswith(".") ]   #ignore system files (esp OSX)
          for i in files:
              path = os.path.join(root, i)
              relpath = os.path.relpath(path, args.folder)
              all_files.append(relpath)
  
      # The child processes in parallel execution mode don't have the proper state for the global args variable, so 
      # at this point we need to switch to explicit arguments
      if args.parallel:
          pool = multiprocessing.Pool(multiprocessing.cpu_count())
  
          results = []
          for f in all_files:
              results.append(pool.apply_async(test_shader_file,
                  args = (f, stats, args, backend)))
  
          for res in results:
              error = res.get()
              if error is not None:
                  pool.close()
                  pool.join()
                  print('Error:', error)
                  sys.exit(1)
      else:
          for i in all_files:
              e = test_shader_file(i, stats, args, backend)
              if e is not None:
                  print('Error:', e)
                  sys.exit(1)
  
  def test_shaders(backend, args):
      if args.malisc:
          with open('stats.csv', 'w') as stats:
              print('Shader,OrigRegs,OrigUniRegs,OrigALUShort,OrigLSShort,OrigTEXShort,OrigALULong,OrigLSLong,OrigTEXLong,CrossRegs,CrossUniRegs,CrossALUShort,CrossLSShort,CrossTEXShort,CrossALULong,CrossLSLong,CrossTEXLong', file = stats)
              test_shaders_helper(stats, backend, args)
      else:
          test_shaders_helper(None, backend, args)
  
  def main():
      parser = argparse.ArgumentParser(description = 'Script for regression testing.')
      parser.add_argument('folder',
              help = 'Folder containing shader files to test.')
      parser.add_argument('--update',
              action = 'store_true',
              help = 'Updates reference files if there is a mismatch. Use when legitimate changes in output is found.')
      parser.add_argument('--keep',
              action = 'store_true',
              help = 'Leave failed GLSL shaders on disk if they fail regression. Useful for debugging.')
      parser.add_argument('--malisc',
              action = 'store_true',
              help = 'Use malisc offline compiler to determine static cycle counts before and after spirv-cross.')
      parser.add_argument('--msl',
              action = 'store_true',
              help = 'Test Metal backend.')
      parser.add_argument('--metal',
              action = 'store_true',
              help = 'Deprecated Metal option. Use --msl instead.')
      parser.add_argument('--hlsl',
              action = 'store_true',
              help = 'Test HLSL backend.')
      parser.add_argument('--force-no-external-validation',
              action = 'store_true',
              help = 'Disable all external validation.')
      parser.add_argument('--opt',
              action = 'store_true',
              help = 'Run SPIRV-Tools optimization passes as well.')
      parser.add_argument('--reflect',
              action = 'store_true',
              help = 'Test reflection backend.')
      parser.add_argument('--parallel',
              action = 'store_true',
              help = 'Execute tests in parallel.  Useful for doing regression quickly, but bad for debugging and stat output.')
      parser.add_argument('--spirv-cross',
              default = './spirv-cross',
              help = 'Explicit path to spirv-cross')
      parser.add_argument('--glslang',
              default = 'glslangValidator',
              help = 'Explicit path to glslangValidator')
      parser.add_argument('--spirv-as',
              default = 'spirv-as',
              help = 'Explicit path to spirv-as')
      parser.add_argument('--spirv-val',
              default = 'spirv-val',
              help = 'Explicit path to spirv-val')
      parser.add_argument('--spirv-opt',
              default = 'spirv-opt',
              help = 'Explicit path to spirv-opt')
      parser.add_argument('--iterations',
              default = 1,
              type = int,
              help = 'Number of iterations to run SPIRV-Cross (benchmarking)')
      
      args = parser.parse_args()
      if not args.folder:
          sys.stderr.write('Need shader folder.\n')
          sys.exit(1)
  
      if (args.parallel and (args.malisc or args.force_no_external_validation or args.update)):
          sys.stderr.write('Parallel execution is disabled when using the flags --update, --malisc or --force-no-external-validation\n')
          args.parallel = False
          
      args.msl22 = False
      if args.msl:
          print_msl_compiler_version()
          args.msl22 = msl_compiler_supports_22()
  
      backend = 'glsl'
      if (args.msl or args.metal): 
          backend = 'msl'
      elif args.hlsl: 
          backend = 'hlsl'
      elif args.reflect:
          backend = 'reflect'
  
      test_shaders(backend, args)
      if args.malisc:
          print('Stats in stats.csv!')
      print('Tests completed!')
  
  if __name__ == '__main__':
      main()
  