[Piglit] [PATCH] arb_gpu_shader_int64: generate int64 conversion tests.
Dylan Baker
dylan at pnwbakers.com
Wed Jun 29 17:34:19 UTC 2016
Quoting Dave Airlie (2016-06-19 22:05:39)
> From: Dave Airlie <airlied at redhat.com>
>
> This is "ported" from the fp64 conversion generator, it
> probably has a lot of stuff left over it shouldn't, but it
> does generate the tests I expected to test 64-bit integer
> conversions both implicit and explicit.
>
> Signed-off-by: Dave Airlie <airlied at redhat.com>
> ---
> generated_tests/CMakeLists.txt | 18 +
> generated_tests/gen_conversion_int64.py | 569 +++++++++++++++++++++
> .../templates/gen_conversion_int64/base.mako | 12 +
> .../gen_conversion_int64/compiler.frag.mako | 3 +
> .../gen_conversion_int64/compiler.geom.mako | 3 +
> .../gen_conversion_int64/compiler.vert.mako | 3 +
> .../gen_conversion_int64/compiler_base.mako | 25 +
> .../execution.frag.shader_test.mako | 7 +
> .../execution.geom.shader_test.mako | 27 +
> .../execution.vert.shader_test.mako | 16 +
> .../gen_conversion_int64/execution_base.mako | 31 ++
> .../gen_conversion_int64/shader.frag.mako | 16 +
> .../gen_conversion_int64/shader.geom.mako | 25 +
> .../gen_conversion_int64/shader.vert.mako | 18 +
> .../gen_conversion_int64/shader_base.mako | 11 +
> 15 files changed, 784 insertions(+)
> create mode 100644 generated_tests/gen_conversion_int64.py
> create mode 100644 generated_tests/templates/gen_conversion_int64/base.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/compiler.frag.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/compiler.geom.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/compiler.vert.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/compiler_base.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/execution_base.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/shader.frag.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/shader.geom.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/shader.vert.mako
> create mode 100644 generated_tests/templates/gen_conversion_int64/shader_base.mako
>
> diff --git a/generated_tests/CMakeLists.txt b/generated_tests/CMakeLists.txt
> index 0b9048f..f502534 100644
> --- a/generated_tests/CMakeLists.txt
> +++ b/generated_tests/CMakeLists.txt
> @@ -153,6 +153,23 @@ piglit_make_generated_tests(
> templates/gen_conversion_fp64/shader_base.mako
> )
> piglit_make_generated_tests(
> + conversion_int64.list
> + gen_conversion_int64.py
> + templates/gen_conversion_int64/base.mako
> + templates/gen_conversion_int64/compiler.frag.mako
> + templates/gen_conversion_int64/compiler.geom.mako
> + templates/gen_conversion_int64/compiler.vert.mako
> + templates/gen_conversion_int64/compiler_base.mako
> + templates/gen_conversion_int64/execution.frag.shader_test.mako
> + templates/gen_conversion_int64/execution.geom.shader_test.mako
> + templates/gen_conversion_int64/execution.vert.shader_test.mako
> + templates/gen_conversion_int64/execution_base.mako
> + templates/gen_conversion_int64/shader.frag.mako
> + templates/gen_conversion_int64/shader.geom.mako
> + templates/gen_conversion_int64/shader.vert.mako
> + templates/gen_conversion_int64/shader_base.mako
> + )
> +piglit_make_generated_tests(
> shader_precision_tests.list
> gen_shader_precision_tests.py
> builtin_function.py
> @@ -247,6 +264,7 @@ add_custom_target(gen-gl-tests
> vp-tex.list
> variable_index_write_tests.list
> vs_in_fp64.list
> + conversion_int64.list
> )
>
> # Create a custom target for generating OpenCL tests
> diff --git a/generated_tests/gen_conversion_int64.py b/generated_tests/gen_conversion_int64.py
> new file mode 100644
> index 0000000..bbe38e9
> --- /dev/null
> +++ b/generated_tests/gen_conversion_int64.py
> @@ -0,0 +1,569 @@
> +# coding=utf-8
> +#
> +# Copyright © 2016 Intel Corporation
> +#
> +# Permission is hereby granted, free of charge, to any person obtaining a
> +# copy of this software and associated documentation files (the "Software"),
> +# to deal in the Software without restriction, including without limitation
> +# the rights to use, copy, modify, merge, publish, distribute, sublicense,
> +# and/or sell copies of the Software, and to permit persons to whom the
> +# Software is furnished to do so, subject to the following conditions:
> +#
> +# The above copyright notice and this permission notice (including the next
> +# paragraph) shall be included in all copies or substantial portions of the
> +# Software.
> +#
> +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
> +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> +# DEALINGS IN THE SOFTWARE.
> +
> +"""Generate int64 types conversion tests."""
> +
> +from __future__ import print_function, division, absolute_import
> +import abc
> +import argparse
> +import itertools
> +import os
> +import struct
> +
> +import numpy as np
> +
> +from templates import template_dir
> +from modules import utils
> +
> +TEMPLATES = template_dir(os.path.basename(os.path.splitext(__file__)[0]))
> +
> +# pylint: disable=bad-whitespace,line-too-long,bad-continuation
> +DOUBLE_INFS = ['0xfff0000000000000', # -inf
> + '0x7ff0000000000000'] # +inf
> +
> +DOUBLE_NEG_ZERO = ['0x8000000000000000'] # Negative underflow (-0.0)
> +
> +DOUBLE_POS_ZERO = ['0x0000000000000000'] # Positive underflow (+0.0)
> +
> +# Double values causing an underflow to zero in any other type
> +DOUBLE_DENORMAL_VALUES = ['0x800fffffffffffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
> + '0x8000000000000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
> + '0x0000000000000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
> + '0x000fffffffffffff'] # Positive maximum denormalized -- Denormalized may be flushed to 0
> +
> +DOUBLE_NORMAL_VALUES = ['0x8010000000000000', # Negative minimum normalized
> + '0x0010000000000000'] # Positive minimum normalized
> +
> +# Double +/-inf
> +DOUBLE_FLOAT_INFS = ['0xc7effffff0000000', # Negative overflow (-inf)
> + '0x47effffff0000000'] # Positive overflow (+inf)
> +
> +DOUBLE_FLOAT_VALUES = ['0xc7efffffefffffff', # Negative maximum normalized
> + '0xc170000000000000', # -16777216.0
> + '0xc014000000000000', # -5.0
> + '0xbfff25ce60000000', # -1.9467300176620483
> + '0xb80fffffe0000000', # Negative minimum normalized
> + '0xb69fffffffffffff', # Negative underflow
> + '0x369fffffffffffff', # Positive underflow
> + '0x380fffffe0000000', # Positive minimum normalized
> + '0x3fff25ce60000000', # +1.9467300176620483
> + '0x4014000000000000', # +5.0
> + '0x4170000000000000', # +16777216.0
> + '0x47efffffefffffff'] # Positive maximum normalized
> +
> +DOUBLE_UINT_VALUES = ['0xbfeccccccccccccd', # -0.9
> + #'0x8010000000000000', # Negative minimum normalized -- Already checked
> + #'0x800fffffffffffff', # Negative maximum denormalized -- Already checked
> + #'0x8000000000000001', # Negative minimum denormalized -- Already checked
> + #'0x8000000000000000', # Negative minimum (-0) -- Already checked
> + #'0x0000000000000000', # Positive minimum (+0) -- Already checked
> + '0x3fff25ce60000000', # +1.9467300176620483
> + '0x4014000000000000', # +5.0
> + '0x4170000000000000', # +16777216.0
> + '0x41dfffffffc00000', # Signed int low frontier (+2147483647)
> + '0x41e0000000000000', # Signed int up frontier (+2147483648)
> + '0x41efffffffe00000'] # Maximum (+4294967295)
> +
> +DOUBLE_INT_VALUES = ['0xc1e0000000000000', # Minimum (-2147483648)
> + '0xc170000000000000', # -16777216.0
> + '0xc014000000000000', # -5.0
> + '0xbfff25ce60000000', # -1.9467300176620483
> + #'0x8000000000000000', # Negative minimum (-0) -- Already checked
> + #'0x0000000000000000', # Minimum (+0) -- Already checked
> + '0x3fff25ce60000000', # +1.9467300176620483
> + '0x4014000000000000', # +5.0
> + '0x4170000000000000', # +16777216.0
> + '0x41dfffffffc00000'] # Maximum (+2147483647)
> +
> +DOUBLE_BOOL_VALUES = [#'0x8010000000000000', # Minimum negative True value -- Already checked
> + #'0x0000000000000000', # False -- Already checked
> + #'0x0010000000000000', # Minimum positive True value -- Already checked
> + ]
> +
> +FLOAT_INFS = ['0xff800000', # -inf
> + '0x7f800000'] # +inf
> +
> +FLOAT_NEG_ZERO = ['0x80000000'] # Negative underflow (-0.0)
> +
> +FLOAT_POS_ZERO = ['0x00000000'] # Positive underflow (+0.0)
> +
> +FLOAT_NEG_VALUES = ['0xcb800000', # -16777216.0
> + '0xc0a00000', # -5.0
> + '0xbff92e73', # -1.9467300176620483
> + '0x80800000'] # Negative minimum normalized
> +
> +FLOAT_POS_VALUES = [#'0x807fffff', # Negative maximum denormalized -- Denormalized may be flushed to 0
> + #'0x80000001', # Negative minimum denormalized -- Denormalized may be flushed to 0
> + #'0x00000001', # Positive minimum denormalized -- Denormalized may be flushed to 0
> + #'0x007fffff', # Positive maximum denormalized -- Denormalized may be flushed to 0
> + '0x00800000', # Positive minimum normalized
> + '0x3ff92e73', # +1.9467300176620483
> + '0x40a00000', # +5.0
> + '0x4b800000'] # +16777216.0
> +
> +UINT_VALUES = ['0', # Minimum
> + '5',
> + '2147483647', # Signed int low frontier
> + '2147483648', # Signed int up frontier
> + '4294967295'] # Maximum
> +
> +INT_VALUES = ['-2147483648', # Minimum
> + '-5',
> + '-1',
> + '0',
> + '1',
> + '5',
> + '2147483647'] # Maximum
> +
> +UINT64_VALUES = ['0', # Minimum
> + '5',
> + '18446744073709551615'] # Maximum
> +
> +INT64_VALUES = ['-9223372036854775806',# Minimum
> + '-5',
> + '0'
> + '5',
> + '9223372036854775807'] # Maximum
> +
> +BOOL_VALUES = ['0', # False
> + '1'] # True
> +# pylint: enable=bad-whitespace,line-too-long,bad-continuation
> +
> +def get_dir_name(ver, test_type):
> + """Returns the directory name to save tests given a GLSL version and a
> + test type.
> + """
> +
> + assert isinstance(ver, str)
> + assert isinstance(test_type, str)
> + if ver.startswith('GL_'):
> + feature_dir = ver[3:].lower()
> + else:
> + feature_dir = 'glsl-{}.{}'.format(ver[0], ver[1:])
> +
> + return os.path.join('spec', feature_dir, test_type,
> + 'conversion')
> +
> +
> +class TestTuple(object):
> + """A float64 derived and other type derived tuple to generate the
> + needed conversion tests.
> + """
> +
> + @staticmethod
> + def float_to_hex(fvalue):
> + """Returns the hexadecimal representation from a float32 value."""
> + assert isinstance(fvalue, np.float32)
> + return hex(struct.unpack('<I', struct.pack('<f', fvalue))[0])
> +
> + @staticmethod
> + def double_to_hex(fvalue):
> + """Returns the hexadecimal representation from a float64 value."""
> + assert isinstance(fvalue, float)
> + return hex(struct.unpack('<Q', struct.pack('<d', fvalue))[0]).rstrip("L")
> +
> + @staticmethod
> + def hex_to_float(hstr):
> + """Returns a float32 value from its hexadecimal representation."""
> + assert isinstance(hstr, str)
> + return struct.unpack('<f', struct.pack('<I', int(hstr, 16)))[0]
> +
> + @staticmethod
> + def hex_to_double(hstr):
> + """Returns a float64 value from its hexadecimal representation."""
> + assert isinstance(hstr, str)
> + return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0]
> +
> + @staticmethod
> + def hex_to_int64(hstr):
> + """Returns a 64-bit integer value from its hexadecimal representation."""
> +
> + assert isinstance(hstr, str)
> + return struct.unpack('<d', struct.pack('<Q', int(hstr, 16)))[0]
> +
> + @staticmethod
> + def float_hex_to_int64(hstr):
> + """Returns the float64 hexadecimal representation from a float32
> + hexadecimal representation.
> + """
> + assert isinstance(hstr, str)
> + double_value = TestTuple.hex_to_float(hstr)
> + return str(int(double_value))
> +
> + @staticmethod
> + def float_hex_to_uint64(hstr):
> + """Returns the float64 hexadecimal representation from a float32
> + hexadecimal representation.
> + """
> + assert isinstance(hstr, str)
> + double_value = TestTuple.hex_to_float(hstr)
> + int_value = int(double_value) & 0xfffffffffffffff
> + return struct.unpack('<Q', struct.pack('<q', int_value))[0]
> +
> + @staticmethod
> + def double_hex_to_int64(hstr):
> + """Returns the float64 hexadecimal representation from a float32
> + hexadecimal representation.
> + """
> + assert isinstance(hstr, str)
> + double_value = TestTuple.hex_to_double(hstr)
> + return str(int(double_value))
> +
> + @staticmethod
> + def double_hex_to_uint64(hstr):
> + """Returns the float64 hexadecimal representation from a float32
> + hexadecimal representation.
> + """
> + assert isinstance(hstr, str)
> + double_value = TestTuple.hex_to_double(hstr)
> + int_value = int(double_value) & 0xfffffffffffffff
> + return struct.unpack('<Q', struct.pack('<q', int_value))[0]
> +
> + @staticmethod
> + def int_str_to_int64_str(istr):
> + """Returns a int64 string from an int32 string."""
> + assert isinstance(istr, str)
> + return str((istr))
Extra parens?
> +
> + @staticmethod
> + def int64_to_bool_str(hstr):
> + """Returns a bool string from a int64."""
> + assert isinstance(hstr, str)
> + return '1' if int(hstr) != 0 else '0'
> +
> + @staticmethod
> + def int64_to_int_str(int64_val):
> + """Returns an int32 string from a float64 hexadecimal
Should float64 here actually be int64? (and a bunch of other comments
too)
> + representation.
> + """
> + return struct.unpack('<i', struct.pack('<L', int(int64_val) & 0xffffffff))[0]
> +
> + @staticmethod
> + def int64_to_uint_str(int64_val):
> + """Returns an uint32 string from a float64 hexadecimal
> + representation.
> + """
> + return struct.unpack('<i', struct.pack('<L', int(int64_val) & 0xffffffff))[0]
Shouldn't this be '<I' and '<l', since you want an unsigned short and a
signed long?
> +
> + @staticmethod
> + def int64_to_float_str(hstr):
> + """Returns the float32 hexadecimal representation from a float64
> + hexadecimal representation.
> + """
> + assert isinstance(hstr, str)
> + float_double = np.float32(hstr);
> + return TestTuple.float_to_hex(float_double)
> +
> + @staticmethod
> + def int64_to_double_str(hstr):
> + """Returns the float64 hexadecimal representation from a int64
> + hexadecimal representation.
> + """
> + assert isinstance(hstr, str)
> + float_double = np.float64(hstr);
> + return TestTuple.double_to_hex(float_double)
> +
> + def __init__(self, ver, stage,
> + first_dimension, second_dimension,
> + basic_type, output_type, names_only):
> + assert stage in ('vert', 'geom', 'frag')
> + assert first_dimension in ('1', '2', '3', '4')
> + assert second_dimension in ('1', '2', '3', '4')
> + assert isinstance(names_only, bool)
> +
> + self._ver = ver
> + self._stage = stage
> + self._basic_type = basic_type
> + self._names_only = names_only
> + self._output_type = output_type
> + self._conversion_type = ''
> + self._uniform_type = ''
> + self._amount = int(first_dimension) * int(second_dimension)
> + self._filenames = []
> +
> + if first_dimension != '1':
> + dimensional_type = 'mat' + first_dimension
> + if first_dimension != second_dimension:
> + dimensional_type += 'x' + second_dimension
> + elif second_dimension != '1':
> + dimensional_type = 'vec' + second_dimension
> + else:
> + dimensional_type = ''
> +
> + if dimensional_type == '':
> + if basic_type == 'b':
> + self._conversion_type = 'bool'
> + self._uniform_type = 'int'
> + elif basic_type == 'i':
> + self._conversion_type = 'int'
> + elif basic_type == 'u':
> + self._conversion_type = 'uint'
> + elif basic_type == 'f':
> + self._conversion_type = 'float'
> + elif basic_type == 'd':
> + self._conversion_type = 'double'
> +
> + if output_type == 'u64':
> + self._bit64_type = 'uint64_t'
> + elif output_type == 'i64':
> + self._bit64_type = 'int64_t'
> + if self._uniform_type == '':
> + self._uniform_type = self._conversion_type
> + else:
> + self._conversion_type = (basic_type if basic_type != 'f' else '') + dimensional_type
> + if basic_type == 'b':
> + self._uniform_type = 'i' + dimensional_type
> + else:
> + self._uniform_type = self._conversion_type
> + if output_type == 'u64':
> + self._bit64_type = 'u64' + dimensional_type
> + elif output_type == 'i64':
> + self._bit64_type = 'i64' + dimensional_type
> +
> + @abc.abstractmethod
> + def _gen_to_bit64(self):
> + """Generates the test files for conversions to 64-bit integer."""
> +
> + @abc.abstractmethod
> + def _gen_from_bit64(self):
> + """Generates the test files for conversions from 64-bit integers."""
> +
> + @property
> + def filenames(self):
> + """Returns the test file names this tuple will generate."""
> + if self._filenames == []:
> + tmp = self._names_only
> + self._names_only = True
> + self.generate_test_files()
> + self._names_only = tmp
> + return self._filenames
> +
> + def generate_test_files(self):
> + """Generate the GLSL parser tests."""
> + self._filenames = []
> +
> + self._gen_to_bit64()
> + self._gen_from_bit64()
> +
> +
> +class RegularTestTuple(TestTuple):
> + """Derived class for conversion tests using regular values within the
> + edges of the used types.
> + """
> +
> + @staticmethod
> + def all_tests(names_only):
> + """Returns all the possible contained conversion test instances."""
> +
> + assert isinstance(names_only, bool)
> + stages = ['frag'] #, 'geom', 'frag']
> + dimensions = ['1', '2', '3', '4']
> + basic_types = ['b', 'u', 'i', 'f', 'd']
> + glsl_ver = ['GL_ARB_gpu_shader_int64']
> + output_types = ['i64', 'u64']
> +
> + if not names_only:
> + test_types = ['compiler', 'execution']
> + for ver, test_type in itertools.product(glsl_ver, test_types):
> + utils.safe_makedirs(get_dir_name(ver, test_type))
> +
> + for ver, stage, second_dimension, basic_type, output_type in itertools.product(
> + glsl_ver,
> + stages,
> + dimensions,
> + basic_types, output_types):
> + first_dimension = '1'
> + if not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f')):
> + yield RegularTestTuple(ver, stage,
> + first_dimension, second_dimension,
> + basic_type, output_type, names_only)
> +
> + def __init__(self, ver, stage,
> + first_dimension, second_dimension,
> + basic_type, output_type, names_only):
> + assert ver in ('GL_ARB_gpu_shader_int64')
> + assert basic_type in ('b', 'u', 'i', 'f', 'd')
> + assert not (first_dimension != '1' and (second_dimension == '1' or basic_type != 'f'))
> + assert output_type in ('i64', 'u64')
> + super(RegularTestTuple, self).__init__(ver, stage,
> + first_dimension, second_dimension,
> + basic_type, output_type, names_only)
> +
> + def _gen_comp_test(self, from_type, to_type, converted_from):
> + filename = os.path.join(
> + get_dir_name(self._ver, 'compiler'),
> + '{}-conversion-implicit-{}-{}-bad.{}'.format(self._stage, from_type, to_type,
> + self._stage))
> +
> + self._filenames.append(filename)
> +
> + if not self._names_only:
> + with open(filename, 'w') as test_file:
> + test_file.write(TEMPLATES.get_template(
> + 'compiler.{}.mako'.format(self._stage)).render_unicode(
> + ver=self._ver,
> + from_type=from_type,
> + to_type=to_type,
> + converted_from=converted_from))
> +
> + def _gen_exec_test(self, from_type, to_type,
> + uniform_from_type, uniform_to_type,
> + explicit, converted_from, conversions):
> + filename = os.path.join(
> + get_dir_name(self._ver, 'execution'),
> + '{}-conversion-{}-{}-{}.shader_test'.format(self._stage, explicit,
> + from_type, to_type))
> +
> + self._filenames.append(filename)
> +
> + if not self._names_only:
> + with open(filename, 'w') as test_file:
> + test_file.write(TEMPLATES.get_template(
> + 'execution.{}.shader_test.mako'.format(self._stage)).render_unicode(
> + ver=self._ver,
> + amount=self._amount,
> + from_type=from_type,
> + to_type=to_type,
> + converted_from=converted_from,
> + uniform_from_type=uniform_from_type,
> + uniform_to_type=uniform_to_type,
> + conversions=conversions))
> +
> + def _gen_to_bit64(self):
> + converted_from = 'from'
> + explicit = 'implicit'
> +
> + if self._basic_type == 'b':
> + explicit = 'explicit'
> + self._gen_comp_test(self._conversion_type, self._bit64_type,
> + converted_from)
> + converted_from = self._bit64_type + '(from)'
> + conversion_values = BOOL_VALUES
> + conversion_function = TestTuple.int_str_to_int64_str
> + elif self._basic_type == 'i':
> + conversion_values = INT_VALUES
> + conversion_function = TestTuple.int_str_to_int64_str
> + elif self._basic_type == 'u':
> + if self._output_type == 'i64':
> + explicit = 'explicit'
> + self._gen_comp_test(self._conversion_type, self._bit64_type,
> + converted_from)
> + converted_from = self._bit64_type + '(from)'
> + conversion_values = UINT_VALUES
> + conversion_function = TestTuple.int_str_to_int64_str
> + elif self._basic_type == 'f':
> + explicit = 'explicit'
> + self._gen_comp_test(self._conversion_type, self._bit64_type,
> + converted_from)
> + converted_from = self._bit64_type + '(from)'
> + if self._output_type == 'i64':
> + conversion_values = FLOAT_POS_ZERO + FLOAT_NEG_ZERO + FLOAT_POS_VALUES + FLOAT_NEG_VALUES
> + conversion_function = TestTuple.float_hex_to_int64
> + elif self._output_type == 'u64':
> + conversion_values = FLOAT_POS_ZERO + FLOAT_POS_VALUES
> + conversion_function = TestTuple.float_hex_to_uint64
> + elif self._basic_type == 'd':
> + explicit = 'explicit'
> + self._gen_comp_test(self._conversion_type, self._bit64_type,
> + converted_from)
> + converted_from = self._bit64_type + '(from)'
> + if self._output_type == 'i64':
> + conversion_values = DOUBLE_INT_VALUES
> + conversion_function = TestTuple.double_hex_to_int64
> + else:
> + conversion_values = DOUBLE_UINT_VALUES
> + conversion_function = TestTuple.double_hex_to_uint64
> +
> +
> + conversions = []
> + for value in conversion_values:
> + to_value = conversion_function(value)
> + item = {'from': value, 'to': to_value}
> + conversions.append(item)
> +
> + self._gen_exec_test(self._conversion_type, self._bit64_type,
> + self._uniform_type, self._bit64_type,
> + explicit, converted_from, conversions)
> +
> + def _gen_from_bit64(self):
> + converted_from = 'from'
> + explicit = 'implicit'
> +
> + if self._basic_type != 'd':
> + explicit = 'explicit'
> + self._gen_comp_test(self._bit64_type, self._conversion_type,
> + converted_from)
> +
> + converted_from = self._conversion_type + '(from)'
> +
> + if self._output_type == 'u64':
> + conversion_values = UINT64_VALUES
> + elif self._output_type == 'i64':
> + conversion_values = INT64_VALUES
> +
> + if self._basic_type == 'b':
> + conversion_function = TestTuple.int64_to_bool_str
> + elif self._basic_type == 'i':
> + conversion_function = TestTuple.int64_to_int_str
> + elif self._basic_type == 'u':
> + conversion_function = TestTuple.int64_to_uint_str
> + elif self._basic_type == 'f':
> + conversion_function = TestTuple.int64_to_float_str
> + elif self._basic_type == 'd':
> + conversion_function = TestTuple.int64_to_double_str
> +
> + conversions = []
> + for value in conversion_values:
> + to_value = conversion_function(value)
> + item = {'from': value, 'to': to_value}
> + conversions.append(item)
> +
> + self._gen_exec_test(self._bit64_type, self._conversion_type,
> + self._bit64_type, self._uniform_type,
> + explicit, converted_from, conversions)
> +
> +
> +def main():
> + """Main function."""
> +
> + parser = argparse.ArgumentParser(
> + description="Generate shader tests that check the conversions from and "
> + "to int64")
> + parser.add_argument(
> + '--names-only',
> + dest='names_only',
> + action='store_true',
> + default=False,
> + help="Don't output files, just generate a list of filenames to stdout")
> + args = parser.parse_args()
> +
> + np.seterr(divide='ignore')
> +
> + for test in (list(RegularTestTuple.all_tests(args.names_only))):
> + test.generate_test_files()
> + for filename in test.filenames:
> + print(filename)
> +
> +
> +if __name__ == '__main__':
> + main()
> diff --git a/generated_tests/templates/gen_conversion_int64/base.mako b/generated_tests/templates/gen_conversion_int64/base.mako
> new file mode 100644
> index 0000000..2d9162e
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/base.mako
> @@ -0,0 +1,12 @@
> +## coding=utf-8
> +<%def name="versioning()"><%
> + if ver == 'GL_ARB_gpu_shader_int64':
> + glsl_version_int = '400'
> + else:
> + glsl_version_int = ver
> +
> + glsl_version = '{}.{}'.format(glsl_version_int[0], glsl_version_int[1:3])
> +
> + return (glsl_version, glsl_version_int)
> +%></%def>\
> +${next.body()}\
> diff --git a/generated_tests/templates/gen_conversion_int64/compiler.frag.mako b/generated_tests/templates/gen_conversion_int64/compiler.frag.mako
> new file mode 100644
> index 0000000..2ae22df
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/compiler.frag.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.frag.mako"/>\
> diff --git a/generated_tests/templates/gen_conversion_int64/compiler.geom.mako b/generated_tests/templates/gen_conversion_int64/compiler.geom.mako
> new file mode 100644
> index 0000000..1e2e340
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/compiler.geom.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.geom.mako"/>\
> diff --git a/generated_tests/templates/gen_conversion_int64/compiler.vert.mako b/generated_tests/templates/gen_conversion_int64/compiler.vert.mako
> new file mode 100644
> index 0000000..d9148f1
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/compiler.vert.mako
> @@ -0,0 +1,3 @@
> +## coding=utf-8
> +<%inherit file="compiler_base.mako"/>\
> +<%include file="shader.vert.mako"/>\
> diff --git a/generated_tests/templates/gen_conversion_int64/compiler_base.mako b/generated_tests/templates/gen_conversion_int64/compiler_base.mako
> new file mode 100644
> index 0000000..6eb9a92
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/compiler_base.mako
> @@ -0,0 +1,25 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> + (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +/* [config]
> + * expect_result: fail
> + * glsl_version: ${glsl_version}
> +% if ver == 'GL_ARB_gpu_shader_int64':
> + * require_extensions: ${ver}
> + * [end config]
> + *
> + * ${ver} spec states:
> + *
> + * "No implicit conversions are
> + * provided to convert from unsigned to signed integer types, from
> + * floating-point to integer types, or from higher-precision to
> + * lower-precision types. There are no implicit array or structure
> + * conversions."
> +% else:
> + * [end config]
> +% endif
> + */
> +
> +${next.body()}\
> diff --git a/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako
> new file mode 100644
> index 0000000..60507ee
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/execution.frag.shader_test.mako
> @@ -0,0 +1,7 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader passthrough]
> +
> +[fragment shader]
> +<%include file="shader.frag.mako"/>
> diff --git a/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako
> new file mode 100644
> index 0000000..a4d41a6
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/execution.geom.shader_test.mako
> @@ -0,0 +1,27 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +#version 400
> +
> +in vec4 piglit_vertex;
> +out vec4 vertex_to_gs;
> +
> +void main()
> +{
> + vertex_to_gs = piglit_vertex;
> +}
> +
> +[geometry shader]
> +<%include file="shader.geom.mako"/>
> +[fragment shader]
> +#version 400
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> + color = fs_color;
> +}
> +
> diff --git a/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako b/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako
> new file mode 100644
> index 0000000..08657c4
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/execution.vert.shader_test.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="execution_base.mako"/>\
> +
> +[vertex shader]
> +<%include file="shader.vert.mako"/>
> +[fragment shader]
> +#version 400
> +
> +in vec4 fs_color;
> +out vec4 color;
> +
> +void main()
> +{
> + color = fs_color;
> +}
> +
> diff --git a/generated_tests/templates/gen_conversion_int64/execution_base.mako b/generated_tests/templates/gen_conversion_int64/execution_base.mako
> new file mode 100644
> index 0000000..f6ea2e3
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/execution_base.mako
> @@ -0,0 +1,31 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> + (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +<%! from six.moves import range %>\
> +[require]
> +GLSL >= ${glsl_version}
> +% if ver == 'GL_ARB_gpu_shader_int64':
> +${ver}
> +% endif
> +${next.body()}\
> +[test]
> +clear color 0.0 0.0 0.0 0.0
> +
> +% for conversion in conversions:
> +clear
> +uniform ${uniform_from_type} from \
> +% for i in range(amount):
> +${conversion['from']} \
> +% endfor
> +
> +uniform ${uniform_to_type} to \
> +% for i in range(amount):
> +${conversion['to']} \
> +% endfor
> +
> +draw rect -1 -1 2 2
> +probe all rgba 0.0 1.0 0.0 1.0
> +
> +% endfor
> diff --git a/generated_tests/templates/gen_conversion_int64/shader.frag.mako b/generated_tests/templates/gen_conversion_int64/shader.frag.mako
> new file mode 100644
> index 0000000..7a8b07c
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/shader.frag.mako
> @@ -0,0 +1,16 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +out vec4 color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> + ${to_type} converted = ${converted_from};
> + bool match = converted == to;
> + color = match ? GREEN : RED;
> +}
> diff --git a/generated_tests/templates/gen_conversion_int64/shader.geom.mako b/generated_tests/templates/gen_conversion_int64/shader.geom.mako
> new file mode 100644
> index 0000000..bf64065
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/shader.geom.mako
> @@ -0,0 +1,25 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +layout(triangles) in;
> +layout(triangle_strip, max_vertices = 3) out;
> +
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 vertex_to_gs[3];
> +out vec4 fs_color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> + ${to_type} converted = ${converted_from};
> + bool match = converted == to;
> + fs_color = match ? GREEN : RED;
> +
> + for (int i = 0; i < 3; i++) {
> + gl_Position = vertex_to_gs[i];
> + EmitVertex();
> + }
> +}
> diff --git a/generated_tests/templates/gen_conversion_int64/shader.vert.mako b/generated_tests/templates/gen_conversion_int64/shader.vert.mako
> new file mode 100644
> index 0000000..2f3553d
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/shader.vert.mako
> @@ -0,0 +1,18 @@
> +## coding=utf-8
> +<%inherit file="shader_base.mako"/>\
> +uniform ${from_type} from;
> +uniform ${to_type} to;
> +
> +in vec4 piglit_vertex;
> +out vec4 fs_color;
> +
> +#define RED vec4(1.0, 0.0, 0.0, 1.0)
> +#define GREEN vec4(0.0, 1.0, 0.0, 1.0)
> +
> +void main()
> +{
> + gl_Position = piglit_vertex;
> + ${to_type} converted = ${converted_from};
> + bool match = converted == to;
> + fs_color = match ? GREEN : RED;
> +}
> diff --git a/generated_tests/templates/gen_conversion_int64/shader_base.mako b/generated_tests/templates/gen_conversion_int64/shader_base.mako
> new file mode 100644
> index 0000000..64ad985
> --- /dev/null
> +++ b/generated_tests/templates/gen_conversion_int64/shader_base.mako
> @@ -0,0 +1,11 @@
> +## coding=utf-8
> +<%inherit file="base.mako"/>\
> +<%
> + (glsl_version, glsl_version_int) = self.versioning()
> +%>\
> +#version ${glsl_version_int}
> +% if ver == 'GL_ARB_gpu_shader_int64':
> +#extension GL_ARB_gpu_shader_int64 : require
> +% endif
> +
> +${next.body()}\
> --
> 2.5.5
Other than those nits I'm okay with landing this as is, there are some
changes I'd like to see, but I'll just write those myself (the fp64
version has the same issues).
Acked-by: Dylan Baker <dylan at pnwbakers.com>
>
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/piglit
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 473 bytes
Desc: signature
URL: <https://lists.freedesktop.org/archives/piglit/attachments/20160629/91665049/attachment-0001.sig>
More information about the Piglit
mailing list