[Piglit] [PATCH 24/26] generate-cl-int-builtins.py: PEP8 compliance
Aaron Watry
awatry at gmail.com
Wed Jul 10 16:17:04 PDT 2013
On Wed, Jul 10, 2013 at 5:19 PM, Dylan Baker <baker.dylan.c at gmail.com> wrote:
> ---
> generated_tests/generate-cl-int-builtins.py | 690 ++++++++++++++--------------
> 1 file changed, 351 insertions(+), 339 deletions(-)
>
> diff --git a/generated_tests/generate-cl-int-builtins.py b/generated_tests/generate-cl-int-builtins.py
> index ae60ad2..3734031 100755
> --- a/generated_tests/generate-cl-int-builtins.py
> +++ b/generated_tests/generate-cl-int-builtins.py
> @@ -1,34 +1,34 @@
> -#!/usr/bin/env python
> +# !/usr/bin/env python
>
> import os
>
> -#Builtins is a data structure of the following:
> -# builtins = {
> -# '{data_type}': { #data type is any of [u]char, [u]short, [u]int, [u]long
> -# '{builtin_function_name}': {
> -# 'arg_types': ['{data_type}', '{data_type}', ...],
> -# 'function_type': 'ttt'|'tss',
> -# #ttt = all arguments are same-length vectors
> -# #tss = all arguments are either same-length vectors,
> +# Builtins is a data structure of the following:
> +# builtins = {
> +# '{data_type}': { # data type is any of [u]char, [u]short, [u]int, [u]long
> +# '{builtin_function_name}': {
> +# 'arg_types': ['{data_type}', '{data_type}', ...],
> +# 'function_type': 'ttt'|'tss',
> +# ttt = all arguments are same-length vectors
> +# tss = all arguments are either same-length vectors,
> # or a vector followed by scalars
> -# 'values': [
> -# [array of test output (arg0) values],
> -# [array of arg1 values],
> -# [array of arg2 values],
> -# ...
> -# ]
> -# },
> -# '{next_function}': {...},
> -# ...
> -# },
> -# '{next_type}': {...},
> -# ...
> -# }
> +# 'values': [
> +# [array of test output (arg0) values],
> +# [array of arg1 values],
> +# [array of arg2 values],
> +# ...
> +# ]
> +# },
> +# '{next_function}': {...},
> +# ...
> +# },
> +# '{next_type}': {...},
> +# ...
> +# }
> #
> -# The builtins_generic, builtins_signed/unsigned are the same, but lack the
> -# {datatype} layer
> +# The builtins_generic, builtins_signed/unsigned are the same, but lack the
> +# {datatype} layer
>
> -#Define placeholders to reduce magic number usage
> +# Define placeholders to reduce magic number usage
> MAX = 'MAX_VAL'
> MIN = 'MIN_VAL'
>
> @@ -36,78 +36,78 @@ SIGNED_TYPES = ['char', 'short', 'int', 'long']
> UNSIGNED_TYPES = ['uchar', 'ushort', 'uint', 'ulong']
> DATA_TYPES = SIGNED_TYPES + UNSIGNED_TYPES
> DATA_SIZES = {
> - 'char' : 8,
> - 'uchar' : 8,
> - 'short' : 16,
> + 'char': 8,
> + 'uchar': 8,
> + 'short': 16,
> 'ushort': 16,
> - 'int' : 32,
> - 'uint' : 32,
> - 'long' : 64,
> - 'ulong' : 64
> + 'int': 32,
> + 'uint': 32,
> + 'long': 64,
> + 'ulong': 64
> }
>
> -#By default, just test what is part of the CL1.1 spec, leave vec3 for later
> -#VEC_WIDTHS = (2, 3, 4, 8, 16)
> +# By default, just test what is part of the CL1.1 spec, leave vec3 for later
> +# VEC_WIDTHS = (2, 3, 4, 8, 16)
> VEC_WIDTHS = (2, 4, 8, 16)
I've been meaning to get around to this for a while... but, since
you're making coding style fixes anyway, could you change the previous
line to:
VEC_WIDTHS = [2, 4, 8, 16]
Whenever I go to change my generated tests list to only test scalar
values, I keep having to change the parentheses to square brackets
because () is not a valid empty list, but [] is.
> -#ALL_WIDTHS = [1, 2, 3, 4, 8, 16]
> +# ALL_WIDTHS = [1, 2, 3, 4, 8, 16]
> ALL_WIDTHS = [1, 2, 4, 8, 16]
>
> MIN_VALUES = {
> - 'char' : -128,
> - 'uchar' : 0,
> - 'short' : -32768,
> - 'ushort' : 0,
> - 'int' : -2147483648,
> - 'uint' : 0,
> - 'long' : -9223372036854775808,
> - 'ulong' : 0
> + 'char': -128,
> + 'uchar': 0,
> + 'short': -32768,
> + 'ushort': 0,
> + 'int': -2147483648,
> + 'uint': 0,
> + 'long': -9223372036854775808,
> + 'ulong': 0
> }
>
> MAX_VALUES = {
> - 'char' : 127,
> - 'uchar' : 255,
> - 'short' : 32767,
> - 'ushort' : 65535,
> - 'int' : 2147483647,
> - 'uint' : 4294967295,
> - 'long' : 9223372036854775807,
> - 'ulong' : 18446744073709551615
> + 'char': 127,
> + 'uchar': 255,
> + 'short': 32767,
> + 'ushort': 65535,
> + 'int': 2147483647,
> + 'uint': 4294967295,
> + 'long': 9223372036854775807,
> + 'ulong': 18446744073709551615
> }
>
> -#Identity type list
> +# Identity type list
> T = {
> - 'char' : 'char',
> - 'uchar' : 'uchar',
> - 'short' : 'short',
> + 'char': 'char',
> + 'uchar': 'uchar',
> + 'short': 'short',
> 'ushort': 'ushort',
> - 'int' : 'int',
> - 'uint' : 'uint',
> - 'long' : 'long',
> - 'ulong' : 'ulong'
> + 'int': 'int',
> + 'uint': 'uint',
> + 'long': 'long',
> + 'ulong': 'ulong'
> }
> -#Signed type for each type
> +# Signed type for each type
> SIGNED = {
> - 'char' : 'char',
> - 'uchar' : 'char',
> - 'short' : 'short',
> + 'char': 'char',
> + 'uchar': 'char',
> + 'short': 'short',
> 'ushort': 'short',
> - 'int' : 'int',
> - 'uint' : 'int',
> - 'long' : 'long',
> - 'ulong' : 'long'
> + 'int': 'int',
> + 'uint': 'int',
> + 'long': 'long',
> + 'ulong': 'long'
> }
> -#Unsigned type for each source type
> +# Unsigned type for each source type
> U = {
> - 'char' : 'uchar',
> - 'uchar' : 'uchar',
> - 'short' : 'ushort',
> + 'char': 'uchar',
> + 'uchar': 'uchar',
> + 'short': 'ushort',
> 'ushort': 'ushort',
> - 'int' : 'uint',
> - 'uint' : 'uint',
> - 'long' : 'ulong',
> - 'ulong' : 'ulong'
> + 'int': 'uint',
> + 'uint': 'uint',
> + 'long': 'ulong',
> + 'ulong': 'ulong'
> }
> -#Next larger type with same signedness
> +# Next larger type with same signedness
> B = {
> 'char': 'short',
> 'uchar': 'ushort',
> @@ -127,100 +127,113 @@ TYPE = 'TYPE'
> SIZE = 'SIZE'
>
> CLC_VERSION_MIN = {
> - 'abs' : 10,
> - 'abs_diff' : 10,
> - 'add_sat' : 10,
> - 'hadd' : 10,
> - 'rhadd' : 10,
> - 'clz' : 10,
> - 'clamp' : 11,
> - 'mad_hi' : 10,
> - 'mad_sat' : 10,
> - 'max' : 11, #max/min are only same-size in CL1.0, but TSS in CL1.1
> - 'min' : 11,
> - 'mul_hi' : 10,
> - 'rotate' : 10,
> - 'sub_sat' : 10,
> - 'upsample' : 10,
> - 'mad24' : 10,
> - 'mul24' : 10
> -}
> + 'abs': 10,
> + 'abs_diff': 10,
> + 'add_sat': 10,
> + 'hadd': 10,
> + 'rhadd': 10,
> + 'clz': 10,
> + 'clamp': 11,
> + 'mad_hi': 10,
> + 'mad_sat': 10,
> + 'max': 11, # max/min are only same-size in CL1.0, but TSS in CL1.1
> + 'min': 11,
> + 'mul_hi': 10,
> + 'rotate': 10,
> + 'sub_sat': 10,
> + 'upsample': 10,
> + 'mad24': 10,
> + 'mul24': 10}
> +
>
> def abs(val):
> if (val < 0):
> return val*-1
> return val
>
> +
> def add(val1, val2):
> return val1+val2
>
> -#Given a data type, return the next bigger type of given signedness.
> +
> +# Given a data type, return the next bigger type of given signedness.
> def big(type):
> return B[type]
>
> +
> def clz(type, val):
> if (val < 0):
> return 0
> else:
> - #Count the number of times that we can right shift before value = 0 then
> - #subtract that from (data_size - 1)
> - count=0
> + # Count the number of times that we can right shift before value = 0
> + # then subtract that from (data_size - 1)
> + count = 0
> while(val > 0):
> if (val > 0):
> val = val >> 1
> count = count + 1
> return DATA_SIZES[type] - count
>
> +
> def div(val1, val2):
> return val1 / val2
>
> +
> def mad_hi(x, y, z, type):
> res = (x*y) >> DATA_SIZES[type]
> res = res + z
> - while (res > MAX_VALUES[type]): #Emulate overflow... Necessary?
> + while (res > MAX_VALUES[type]): # Emulate overflow... Necessary?
> res = res - (2**DATA_SIZES[type])
> return res
>
> +
> def mul(val1, val2):
> return val1 * val2
>
> -def mul_hi(x,y,type):
> +
> +def mul_hi(x, y, type):
> res = (x*y) >> DATA_SIZES[type]
> return res
>
> -#def pop(val,type):
> -# #TODO: Calculate number of non-zero bits in value (CLC 1.2)
> -# return 0
> +# def pop(val,type):
> +# # TODO: Calculate number of non-zero bits in value (CLC 1.2)
> +# return 0
> +
>
> -def pow(val,pow):
> +def pow(val, pow):
> return val ** pow
>
> +
> def rotate_right(x, n, bits):
> - #Find all bits that will wrap
> + # Find all bits that will wrap
> mask = (2L**n) - 1
> wrapped_bits = x & mask
>
> - #sign extension needs to be masked out
> - se_mask = (1 << (bits - n)) - 1;
> - unwrapped_bits = x >> n;
> - unwrapped_bits &= se_mask;
> + # sign extension needs to be masked out
> + se_mask = (1 << (bits - n)) - 1
> + unwrapped_bits = x >> n
> + unwrapped_bits &= se_mask
>
> return unwrapped_bits | (wrapped_bits << (bits - n))
>
> +
> def rotate_left(x, n, bits):
> return rotate_right(x, bits - n, bits)
>
> +
> def rot(x, n, bits):
> if (n < 0):
> return rotate_right(x, -1*n, bits)
> else:
> return rotate_left(x, n, bits)
>
> +
> def sub(val1, val2):
> return val1-val2
>
> +
> def getValue(type, val):
> - #Check if val is a str, list, or value
> + # Check if val is a str, list, or value
> if (isinstance(val, str)):
> if (val == MIN):
> return MIN_VALUES[type]
> @@ -243,108 +256,103 @@ def getValue(type, val):
> elif (val == SIZE):
> return DATA_SIZES[type]
> else:
> - print('Unknown string value: '+val+'\n')
> + print('Unknown string value: ' + val + '\n')
> elif (isinstance(val, list)):
> - #The list should be of the format: [op, arg1, ... argN] where op is a Fn
> - #ref and arg[1-n] are either MIN/MAX or numbers (They could be nested
> - #lists). The exception for arg1 is TYPE, which means to substitute the
> - #data type
> + # The list should be of the format: [op, arg1, ... argN] where op is a
> + # Fn ref and arg[1-n] are either MIN/MAX or numbers (They could be
> + # nested lists). The exception for arg1 is TYPE, which means to
> + # substitute the data type
>
> - #Evaluate the value of the requested function and arguments
> - #TODO: Change to varargs calls after unshifting the first list element
> + # Evaluate the value of the requested function and arguments
> + # TODO: Change to varargs calls after unshifting the first list element
> if (len(val) == 2):
> - return (val[0])(getValue(type,val[1]))
> + return (val[0])(getValue(type, val[1]))
> elif (len(val) == 3):
> - return (val[0])(getValue(type,val[1]), getValue(type, val[2]))
> + return (val[0])(getValue(type, val[1]), getValue(type, val[2]))
> elif (len(val) == 4):
> - return (val[0])(getValue(type,val[1]), getValue(type, val[2]), \
> - getValue(type, val[3]))
> + return (val[0])(getValue(type, val[1]), getValue(type, val[2]),
> + getValue(type, val[3]))
> else:
> - return (val[0])(getValue(type,val[1]), getValue(type, val[2]), \
> - getValue(type, val[3]), getValue(type, val[4]))
> + return (val[0])(getValue(type, val[1]), getValue(type, val[2]),
> + getValue(type, val[3]), getValue(type, val[4]))
>
> - #At this point, we should have been passed a number
> + # At this point, we should have been passed a number
> if (isinstance(val, (int, long))):
> - return val;
> + return val
>
> print('Invalid value '+repr(val)+' encountered in getValue\n')
>
> +
> def getStrVal(type, val):
> - return str(getValue(type,val))
> + return str(getValue(type, val))
> +
>
> -#Tests which don't depend on the signedness or bit-width of the inputs
> +# Tests which don't depend on the signedness or bit-width of the inputs
> generic_tests = {
> 'abs': {
> 'arg_types': [U, T],
> 'function_type': 'ttt',
> 'values': [
> - [0, 2, [abs,MIN], [abs,MAX]],
> - [0, 2, MIN, MAX]
> + [0, 2, [abs, MIN], [abs, MAX]],
> + [0, 2, MIN, MAX]
> ]
> },
> 'abs_diff': {
> - 'arg_types': [U, T, T],
> - 'function_type': 'ttt',
> - 'values': [
> - [0, 1, 1, UMAX, UMAX],
> - [0, 1, 0, MIN, MAX],
> - [0, 0, 1, MAX, MIN]
> - ]
> + 'arg_types': [U, T, T],
> + 'function_type': 'ttt',
> + 'values': [
> + [0, 1, 1, UMAX, UMAX],
> + [0, 1, 0, MIN, MAX],
> + [0, 0, 1, MAX, MIN]
> + ]
> },
> 'add_sat': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [MAX, MAX ],
> - [MAX, [sub,MAX,1]],
> - [ 64, 50 ]
> + [MAX, MAX],
> + [MAX, [sub, MAX, 1]],
> + [64, 50]
> ]
> },
> 'hadd': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [32, 0, 10, MAX, MIN,
> - [div,[add,MAX,MIN], 2],
> - [div,[add,MIN,MAX], 2]
> - ],
> + [32, 0, 10, MAX, MIN, [div, [add, MAX, MIN], 2],
> + [div, [add, MIN, MAX], 2]],
> [32, 1, 12, MAX, MIN, MAX, MIN],
> - [33, 0, 8, MAX, MIN, MIN, MAX]
> + [33, 0, 8, MAX, MIN, MIN, MAX]
> ]
> },
> 'clz': {
> 'arg_types': [T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ [clz,TYPE,1], [clz,TYPE,64], [clz,TYPE,0], [clz,TYPE, MAX],
> - [clz,TYPE,MIN]
> - ],
> - [ 1 , 64 , 0 , MAX ,
> - MIN
> - ]
> - ]
> + [[clz, TYPE, 1], [clz, TYPE, 64], [clz, TYPE, 0], [clz, TYPE, MAX],
> + [clz, TYPE, MIN]], [1, 64, 0, MAX, MIN]]
> },
> 'clamp': {
> 'arg_types': [T, T, T, T],
> 'function_type': 'tss',
> 'values': [
> - [64, [div, MIN, 2], 1],
> - [92, MIN, 64],
> - [ 0, [div, MIN, 2], 0],
> - [64, 0, 1]
> + [64, [div, MIN, 2], 1],
> + [92, MIN, 64],
> + [0, [div, MIN, 2], 0],
> + [64, 0, 1]
> ]
> },
> 'mad_hi': {
> 'arg_types': [T, T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ [mad_hi,[div,MAX,2],3,1,TYPE], [mad_hi,MIN,2,2,TYPE], 4, 1,
> - [mad_hi,MAX,MAX,MAX,TYPE], [mad_hi,MIN,MIN,MIN,TYPE],
> - [mad_hi,MIN,MAX,MAX,TYPE], [mad_hi,MAX, 2, 2,TYPE]
> - ],
> - [ [div,MAX,2], MIN, 12, MAX, MAX, MIN, MIN, MAX],
> - [ 3, 2, 4, 1, MAX, MIN, MAX, 2],
> - [ 1, 2, 4, 1, MAX, MIN, MAX, 2]
> + [[mad_hi, [div, MAX, 2], 3, 1, TYPE], [mad_hi, MIN, 2, 2, TYPE],
> + 4, 1, [mad_hi, MAX, MAX, MAX, TYPE],
> + [mad_hi, MIN, MIN, MIN, TYPE], [mad_hi, MIN, MAX, MAX, TYPE],
> + [mad_hi, MAX, 2, 2, TYPE]],
> + [[div, MAX, 2], MIN, 12, MAX, MAX, MIN, MIN, MAX],
> + [3, 2, 4, 1, MAX, MIN, MAX, 2],
> + [1, 2, 4, 1, MAX, MIN, MAX, 2]
> ]
> },
> 'mad_sat': {
> @@ -353,37 +361,36 @@ generic_tests = {
> 'values': [
> [52, MAX, 93, 0, MAX, MAX],
> [12, MAX, 92, 0, MAX, MAX],
> - [ 4, 1, 1, 0, 2, MAX],
> - [ 4, 1, 1, 0, 2, MAX]
> + [4, 1, 1, 0, 2, MAX],
> + [4, 1, 1, 0, 2, MAX]
> ]
> },
> 'max': {
> 'arg_types': [T, T, T],
> 'function_type': 'tss',
> 'values': [
> - [92, 2, 12, MAX, 1, MAX, MIN, MAX, MAX, 0],
> - [92, 2, 12, MAX, MIN, MAX, MIN, MIN, MAX, 0],
> - [ 2, MIN, 4, 1, 1, MAX, MIN, MAX, MIN, 0]
> + [92, 2, 12, MAX, 1, MAX, MIN, MAX, MAX, 0],
> + [92, 2, 12, MAX, MIN, MAX, MIN, MIN, MAX, 0],
> + [2, MIN, 4, 1, 1, MAX, MIN, MAX, MIN, 0]
> ]
> },
> 'min': {
> 'arg_types': [T, T, T],
> 'function_type': 'tss',
> 'values': [
> - [ 2, 1, MIN, 4, 1, MIN, MAX, MIN, MIN, 0, MAX],
> - [92, 64, 2, 12, MAX, MIN, MAX, MIN, MIN, 0, MAX],
> - [ 2, 1, MIN, 4, 1, 1, MAX, MIN, MAX, 0, MAX]
> + [2, 1, MIN, 4, 1, MIN, MAX, MIN, MIN, 0, MAX],
> + [92, 64, 2, 12, MAX, MIN, MAX, MIN, MIN, 0, MAX],
> + [2, 1, MIN, 4, 1, 1, MAX, MIN, MAX, 0, MAX]
> ]
> },
> 'mul_hi': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [0, 0, 0, [mul_hi,MAX,MAX,TYPE], [mul_hi,MIN,MIN,TYPE], 0,
> - [mul_hi,MAX,2,TYPE], [div,MIN,2]
> - ],
> + [0, 0, 0, [mul_hi, MAX, MAX, TYPE], [mul_hi, MIN, MIN, TYPE], 0,
> + [mul_hi, MAX, 2, TYPE], [div, MIN, 2]],
> [0, 92, MAX, MAX, MIN, 92, MAX, MIN],
> - [0, 2, 1, MAX, MIN, 1, 2, MAX]
> + [0, 2, 1, MAX, MIN, 1, 2, MAX]
> ]
> },
> 'rhadd': {
> @@ -392,76 +399,77 @@ generic_tests = {
> 'values': [
> [33, 1, 10],
> [32, 1, 12],
> - [33, 0, 8]
> + [33, 0, 8]
> ]
> },
> 'rotate': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [1, 8, 1, 2, 1],
> - [1, 1, 1, 1, 1],
> - [0, 3, SIZE, [add,SIZE,1], [mul,SIZE,10]]
> + [1, 8, 1, 2, 1],
> + [1, 1, 1, 1, 1],
> + [0, 3, SIZE, [add, SIZE, 1], [mul, SIZE, 10]]
> ]
> },
> 'sub_sat': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [1, 25, MAX, 0, 0, MIN, MIN],
> - [1, 57, MAX, MAX, MIN, MIN, [div,MIN,2]],
> - [0, 32, MIN, MAX, MIN, MAX, [add,[div,MAX,2],1]]
> + [1, 25, MAX, 0, 0, MIN, MIN],
> + [1, 57, MAX, MAX, MIN, MIN, [div, MIN, 2]],
> + [0, 32, MIN, MAX, MIN, MAX, [add, [div, MAX, 2], 1]]
> ]
> },
> 'upsample': {
> - 'arg_types': [B,T,U],
> + 'arg_types': [B, T, U],
> 'function_type': 'ttt',
> 'values': [
> - [[pow,2,SIZE], [add,[pow,2,SIZE],1], BMAX, 0, MAX,
> - [add,[pow,2,SIZE],7]
> - ],
> - [ 1, 1, MAX, 0, 0, 1],
> - [ 0, 1, UMAX, 0, MAX, 7]
> + [[pow, 2, SIZE],
> + [add, [pow, 2, SIZE], 1],
> + BMAX, 0, MAX,
> + [add, [pow, 2, SIZE], 7]],
> + [1, 1, MAX, 0, 0, 1],
> + [0, 1, UMAX, 0, MAX, 7]
> ]
> }
> }
>
> -#Any test that conceivably includes a negative number as input/output
> +# Any test that conceivably includes a negative number as input/output
> signed_generic_tests = {
> 'abs': {
> 'arg_types': [U, T],
> 'function_type': 'ttt',
> 'values': [
> - [ 1, 13],
> - [-1, -13]
> + [1, 13],
> + [-1, -13]
> ]
> },
> 'abs_diff': {
> - 'arg_types': [U, T, T],
> - 'function_type': 'ttt',
> - 'values': [
> - [1, 15],
> - [0, -8],
> - [1, 7]
> - ]
> + 'arg_types': [U, T, T],
> + 'function_type': 'ttt',
> + 'values': [
> + [1, 15],
> + [0, -8],
> + [1, 7]
> + ]
> },
> 'add_sat': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ 0, -2, [sub,MAX,63], MIN, MIN ],
> - [ 32, -8, MAX, MIN, [add,MIN,10]],
> - [-32, 6, -63, -12, -50 ]
> + [0, -2, [sub, MAX, 63], MIN, MIN],
> + [32, -8, MAX, MIN, [add, MIN, 10]],
> + [-32, 6, -63, -12, -50]
> ]
> },
> 'clamp': {
> 'arg_types': [T, T, T, T],
> 'function_type': 'tss',
> 'values': [
> - [ -64, 0],
> + [-64, 0],
> [-128, -1],
> - [ -64, 0],
> - [ 0, 1]
> + [-64, 0],
> + [0, 1]
> ]
> },
> 'mad_hi': {
> @@ -469,7 +477,7 @@ signed_generic_tests = {
> 'function_type': 'ttt',
> 'values': [
> [MIN, -2],
> - [ -1, 1],
> + [-1, 1],
> [MIN, -1],
> [MIN, -1]
> ]
> @@ -478,19 +486,19 @@ signed_generic_tests = {
> 'arg_types': [T, T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ 0, MIN, MIN, MAX, MIN, -2],
> - [ -1, MIN, MIN, MIN, MIN, 1],
> - [ MIN, 2, 1, MIN, MAX, -1],
> - [ MIN, 2, -1, MIN, MAX, -1]
> + [0, MIN, MIN, MAX, MIN, -2],
> + [-1, MIN, MIN, MIN, MIN, 1],
> + [MIN, 2, 1, MIN, MAX, -1],
> + [MIN, 2, -1, MIN, MAX, -1]
> ]
> },
> 'max': {
> 'arg_types': [T, T, T],
> 'function_type': 'tss',
> 'values': [
> - [ -1, 1],
> - [ -1, 1],
> - [ MIN, -1]
> + [-1, 1],
> + [-1, 1],
> + [MIN, -1]
> ]
> },
> 'min': {
> @@ -498,17 +506,17 @@ signed_generic_tests = {
> 'function_type': 'tss',
> 'values': [
> [MIN, -1, MIN],
> - [ -1, 1, MIN],
> - [MIN, -1, -1]
> + [-1, 1, MIN],
> + [MIN, -1, -1]
> ]
> },
> 'mul_hi': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ 0, -1, -1, -1],
> - [ -1, MIN, MIN, 1],
> - [MIN, 2, 1, -1]
> + [0, -1, -1, -1],
> + [-1, MIN, MIN, 1],
> + [MIN, 2, 1, -1]
> ]
> },
> 'rhadd': {
> @@ -524,63 +532,61 @@ signed_generic_tests = {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ MIN, MIN, [rot,1,-3,SIZE], 1,
> - MIN, [pow,2,[sub,SIZE,2]], MIN, [rot,-2,-1,SIZE]],
> - [ 1, 1, 1, 1,
> - 1, 1, 1, -2],
> - [[sub,SIZE,1], -1, -3, [mul,SIZE,-1],
> - [mul,[add,SIZE,1],-1], [mul,[add,SIZE,2],-1], [sub,SIZE,1], -1]
> + [MIN, MIN, [rot, 1, -3, SIZE], 1, MIN, [pow, 2, [sub, SIZE, 2]],
> + MIN, [rot, -2, -1, SIZE]], [1, 1, 1, 1, 1, 1, 1, -2],
> + [[sub, SIZE, 1], -1, -3, [mul, SIZE, -1],
> + [mul, [add, SIZE, 1], -1],
> + [mul, [add, SIZE, 2], -1], [sub, SIZE, 1], -1]
> ]
> },
> 'sub_sat': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ MAX , 81],
> - [[sub,MAX,8], 1],
> - [ -32 , -80]
> + [MAX, 81],
> + [[sub, MAX, 8], 1],
> + [-32, -80]
> ]
> },
> 'upsample': {
> - 'arg_types': [B,T,U],
> + 'arg_types': [B, T, U],
> 'function_type': 'ttt',
> 'values': [
> - [ -1, [mul,[pow,2,SIZE],-1]],
> - [ -1, -1],
> - [ UMAX, 0]
> + [-1, [mul, [pow, 2, SIZE], -1]],
> + [-1, -1],
> + [UMAX, 0]
> ]
> }
>
> }
>
> -#This list contains all numeric tests which never include negative integers
> -#that can't go into generic_tests.
> +# This list contains all numeric tests which never include negative integers
> +# that can't go into generic_tests.
> unsigned_generic_tests = {
> 'mad_sat': {
> 'arg_types': [T, T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [ 2, MIN, MAX],
> + [2, MIN, MAX],
> [MIN, MIN, MIN],
> - [ 2, MIN, MAX],
> - [ 2, MIN, MAX]
> + [2, MIN, MAX],
> + [2, MIN, MAX]
> ]
> },
> 'rotate': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [[div,[add,MAX,1],2], [div,[add,MAX,1],2]],
> - [ 1, 1],
> - [ [sub,SIZE,1], [sub,SIZE,1]]
> + [[div, [add, MAX, 1], 2], [div, [add, MAX, 1], 2]],
> + [1, 1], [[sub, SIZE, 1], [sub, SIZE, 1]]
> ]
> },
> }
>
> -#Hand-coded tests which are data type specific.
> +# Hand-coded tests which are data type specific.
> builtins = {
> 'int': {
> - 'mad24':{
> + 'mad24': {
> 'arg_types': [T, T, T, T],
> 'function_type': 'ttt',
> 'values': [
> @@ -590,18 +596,18 @@ builtins = {
> [0, 1, -1, 8]
> ]
> },
> - 'mul24':{
> + 'mul24': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [0,1, 1, 512, 4278190081],
> - [0,1,-1, 32, 2**23-1],
> - [0,1,-1, 16, 2**23-1]
> + [0, 1, 1, 512, 4278190081],
> + [0, 1, -1, 32, 2**23-1],
> + [0, 1, -1, 16, 2**23-1]
> ]
> }
> },
> 'uint': {
> - 'mad24':{
> + 'mad24': {
> 'arg_types': [T, T, T, T],
> 'function_type': 'ttt',
> 'values': [
> @@ -611,19 +617,21 @@ builtins = {
> [0, 1, 2**24-1, 8]
> ]
> },
> - 'mul24':{
> + 'mul24': {
> 'arg_types': [T, T, T],
> 'function_type': 'ttt',
> 'values': [
> - [0,1,4261412865, 512],
> - [0,1, 2**24-1, 32],
> - [0,1, 2**24-1, 16]
> + [0, 1, 4261412865, 512],
> + [0, 1, 2**24-1, 32],
> + [0, 1, 2**24-1, 16]
> ]
> }
> }
> }
>
> -#### Define helper functions ####
> +
> +# # # # Define helper functions # # # #
> +
>
> def addTestValues(origDef, origValues):
> fnDef = dict(origDef)
> @@ -632,14 +640,14 @@ def addTestValues(origDef, origValues):
> fnDef['values'] = []
> for idx in range(0, len(values)):
> fnDef['values'].append(list(values[idx]))
> -
> else:
> for arg in range(0, len(values)):
> fnDef['values'][arg] += values[arg]
> return fnDef
>
> -#Given a data type and function name, create one set of combined applicable
> -#test definitions.
> +
> +# Given a data type and function name, create one set of combined applicable
> +# test definitions.
> def mergedTestDefinition(dataType, fnName):
> mergedTest = dict()
>
> @@ -660,6 +668,7 @@ def mergedTestDefinition(dataType, fnName):
> mergedTest = addTestValues(dict(mergedTest), list(fnDef['values']))
> return mergedTest
>
> +
> def getFnNames():
> fnNames = []
> fnNames += generic_tests.keys()
> @@ -669,15 +678,15 @@ def getFnNames():
> if (type in builtins):
> fnNames += builtins[type].keys()
>
> - #Get the sorted unique set of function names
> + # Get the sorted unique set of function names
> return sorted(list(set(fnNames)))
>
> -#vecSizes has the layout [in0width, ..., inNwidth] where outType width is
> -#assumed to match the width of the first input
> +
> +# vecSizes has the layout [in0width, ..., inNwidth] where outType width is
> +# assumed to match the width of the first input
> def gen_kernel(f, fnName, inTypes, outType, vecSizes, typePrefix):
> - f.write( \
> - 'kernel void test_' + typePrefix + str(vecSizes[0]) + '_' + fnName + \
> - '_' + inTypes[0]+'(global '+outType+'* out')
> + f.write('kernel void test_' + typePrefix + str(vecSizes[0]) + '_' + fnName
> + + '_' + inTypes[0]+'(global '+outType+'* out')
> for arg in range(0, len(inTypes)):
> f.write(', global '+inTypes[arg]+'* in'+str(arg))
> f.write('){\n')
> @@ -695,7 +704,7 @@ def gen_kernel(f, fnName, inTypes, outType, vecSizes, typePrefix):
> for arg in range(0, len(inTypes)):
> if (arg > 0):
> f.write(', ')
> - #if scalar, don't print vload/vstore
> + # if scalar, don't print vload/vstore
> if (vecSizes[arg] == 1):
> f.write('*in'+str(arg))
> else:
> @@ -705,47 +714,47 @@ def gen_kernel(f, fnName, inTypes, outType, vecSizes, typePrefix):
>
>
> def getArgType(baseType, argType):
> - #If the argType is a string, it's a literal data type... return it
> + # If the argType is a string, it's a literal data type... return it
> if (isinstance(argType, str)):
> return argType
> - #otherwise it's a list to pick from
> + # otherwise it's a list to pick from
> return argType[baseType]
>
> +
> def getArgTypes(baseType, argTypes):
> ret = []
> for argType in argTypes:
> - ret.append(getArgType(baseType,argType))
> + ret.append(getArgType(baseType, argType))
> return ret
>
> -#Print a test with all-vector inputs/outputs and/or mixed vector/scalar args
> +
> +# Print a test with all-vector inputs/outputs and/or mixed vector/scalar args
> def print_test(f, fnName, argType, functionDef, tests, testIdx, vecSize, tss):
> - #If the test allows mixed vector/scalar arguments, handle the case with
> - #only vector arguments through a recursive call.
> + # If the test allows mixed vector/scalar arguments, handle the case with
> + # only vector arguments through a recursive call.
> if (tss):
> - print_test(f, fnName, argType, functionDef, tests, testIdx, vecSize, \
> - False)
> + print_test(f, fnName, argType, functionDef, tests, testIdx, vecSize,
> + False)
>
> - #The tss && vecSize==1 case is handled in the non-tss case.
> + # The tss && vecSize==1 case is handled in the non-tss case.
> if (tss and vecSize == 1):
> return
>
> - #If we're handling mixed vector/scalar input widths, the kernels have
> - #different names than when the vector widths match
> + # If we're handling mixed vector/scalar input widths, the kernels have
> + # different names than when the vector widths match
> tssStr = 'tss_'
> if (not tss):
> tssStr = ''
>
> - #Write the test header
> - f.write('[test]\n' + \
> - 'name: ' + fnName + ' ' + argType + str(vecSize) + '\n' + \
> - 'kernel_name: test_'+ tssStr + str(vecSize) + '_' + fnName + '_' + \
> - argType + '\n'
> - )
> + # Write the test header
> + f.write('[test]\n' + 'name: ' + fnName + ' ' + argType + str(vecSize) +
> + '\n' + 'kernel_name: test_' + tssStr + str(vecSize) + '_' + fnName
> + + '_' + argType + '\n')
>
> argTypes = getArgTypes(argType, functionDef['arg_types'])
> argCount = len(argTypes)
>
> - #For each argument, write a line containing its type, index, and values
> + # For each argument, write a line containing its type, index, and values
> for arg in range(0, argCount):
> argInOut = ''
> argVal = getStrVal(argType, tests[arg][testIdx])
> @@ -754,70 +763,75 @@ def print_test(f, fnName, argType, functionDef, tests, testIdx, vecSize, tss):
> else:
> argInOut = 'arg_in: '
>
> - #The output argument and first tss argument are vectors, any that follow
> - #are scalar. If !tss, then everything has a matching vector width
> + # The output argument and first tss argument are vectors, any that
> + # follow are scalar. If !tss, then everything has a matching vector
> + # width
> if (arg < 2 or not tss):
> - f.write(argInOut + str(arg) + ' buffer ' + argTypes[arg] + \
> - '[' + str(vecSize) + '] ' + \
> - ' '.join([argVal]*vecSize) + \
> - '\n'
> - )
> + f.write(argInOut + str(arg) + ' buffer ' + argTypes[arg] +
> + '[' + str(vecSize) + '] ' + ' '.join([argVal]*vecSize) +
> + '\n')
> else:
> argInOut = 'arg_in: '
> - f.write(argInOut + str(arg) + ' buffer ' + argTypes[arg] + \
> - '[1] ' + argVal + '\n'
> - )
> + f.write(argInOut + str(arg) + ' buffer ' + argTypes[arg] + '[1] ' +
> + argVal + '\n')
>
> - #Blank line between tests for formatting reasons
> + # Blank line between tests for formatting reasons
> f.write('\n')
>
> +
> def gen_kernel_1_arg(f, fnName, inType, outType):
> for vecSize in ALL_WIDTHS:
> gen_kernel(f, fnName, [inType], outType, [vecSize], '')
>
> -# 2 argument kernel with input types that match
> +
> +# 2 argument kernel with input types that match
> def gen_kernel_2_arg_same_type(f, fnName, inType, outType):
> for vecSize in ALL_WIDTHS:
> - gen_kernel(f, fnName, [inType, inType], outType, [vecSize, vecSize], '')
> + gen_kernel(f, fnName, [inType, inType], outType, [vecSize, vecSize],
> + '')
> +
>
> -# 2 argument kernel with 1 vector and one scalar input argument
> +# 2 argument kernel with 1 vector and one scalar input argument
> def gen_kernel_2_arg_mixed_size(f, fnName, inType, outType):
> for vecSize in VEC_WIDTHS:
> gen_kernel(f, fnName, [inType, inType], outType, [vecSize, 1], 'tss_')
>
> -# 2 argument kernel with 1 vector and one scalar input argument with multiple
> -# input data types
> +
> +# 2 argument kernel with 1 vector and one scalar input argument with multiple
> +# input data types
> def gen_kernel_2_arg_mixed_sign(f, fnName, inType1, inType2, outType):
> for vecSize in ALL_WIDTHS:
> - gen_kernel(f, fnName, [inType1, inType2], outType, [vecSize, vecSize], \
> - '')
> + gen_kernel(f, fnName, [inType1, inType2], outType, [vecSize, vecSize],
> + '')
> +
> +
> +# 3-argument built-in functions
>
> -# 3-argument built-in functions
>
> def gen_kernel_3_arg_same_type(f, fnName, inType, outType):
> for vecSize in ALL_WIDTHS:
> - gen_kernel(f, fnName, [inType, inType, inType], outType, \
> - [vecSize, vecSize, vecSize], '')
> + gen_kernel(f, fnName, [inType, inType, inType], outType,
> + [vecSize, vecSize, vecSize], '')
> +
>
> def gen_kernel_3_arg_mixed_size_vector(f, fnName, inType, outType, vecSize):
> - f.write( \
> - 'kernel void test_tss_' + vecSize + '_' + fnName + '_' + inType + \
> - '(global ' + outType + '* out, global ' + inType + '* in1, global ' + \
> - inType+'* in2, global '+inType+'* in3){\n' + \
> - ' vstore' + vecSize + '(' + fnName + '(vload' + vecSize + \
> - '(0, in1), *in2, *in3), 0, out);\n' + \
> - '}\n\n'
> - )
> + f.write('kernel void test_tss_' + vecSize + '_' + fnName + '_' + inType +
> + '(global ' + outType + '* out, global ' + inType + '* in1, global '
> + + inType+'* in2, global '+inType+'* in3){\n' + ' vstore' + vecSize
> + + '(' + fnName + '(vload' + vecSize +
> + '(0, in1), *in2, *in3), 0, out);\n' + '}\n\n')
> +
>
> def gen_kernel_3_arg_mixed_size(f, fnName, inType, outType):
> for vecSize in VEC_WIDTHS:
> - gen_kernel(f, fnName, [inType, inType, inType], outType, \
> - [vecSize, 1, 1], 'tss_')
> + gen_kernel(f, fnName, [inType, inType, inType], outType,
> + [vecSize, 1, 1], 'tss_')
> +
>
> def generate_kernels(f, dataType, fnName, fnDef):
> - argTypes = getArgTypes(dataType,fnDef['arg_types'])
> + argTypes = getArgTypes(dataType, fnDef['arg_types'])
>
> - #For len(argTypes), remember that this includes the output arg
> + # For len(argTypes), remember that this includes the output arg
> if (len(argTypes) == 2):
> gen_kernel_1_arg(f, fnName, argTypes[1], argTypes[0])
> return
> @@ -835,29 +849,29 @@ def generate_kernels(f, dataType, fnName, fnDef):
> return
>
> if (fnName is 'upsample'):
> - gen_kernel_2_arg_mixed_sign(f, fnName, argTypes[1], argTypes[2], \
> - argTypes[0])
> + gen_kernel_2_arg_mixed_sign(f, fnName, argTypes[1], argTypes[2],
> + argTypes[0])
> return
>
> -#### Main logic start ####
>
> def main():
> - #Create the output directory if required
> - dirName = os.path.join( "cl", "builtin", "int")
> + # Create the output directory if required
> + dirName = os.path.join("cl", "builtin", "int")
> if not os.path.exists(dirName):
> os.makedirs(dirName)
>
> - #Loop over all data types being tested. Create one output file per data type
> + # Loop over all data types being tested. Create one output file per data
> + # type
> for dataType in DATA_TYPES:
> - functions = getFnNames() #List of all built-in functions
> + functions = getFnNames() # List of all built-in functions
> for fnName in functions:
> - if (fnName is 'upsample' and (dataType is 'long' \
> - or dataType is 'ulong')):
> + if (fnName is 'upsample' and
> + (dataType is 'long' or dataType is 'ulong')):
> continue
> - #Merge all of the generic/signed/unsigned/custom test definitions
> + # Merge all of the generic/signed/unsigned/custom test definitions
> functionDef = mergedTestDefinition(dataType, fnName)
>
> - #Check if the function actually exists for this data type
> + # Check if the function actually exists for this data type
> if (not functionDef.keys()):
> continue
>
> @@ -870,17 +884,15 @@ def main():
>
> f = open(fileName, 'w')
> print(fileName)
> - #Write the file header
> - f.write( \
> - '/*!\n' + \
> - '[config]\n' + \
> - 'name: Test '+dataType+' '+fnName+' built-in on CL 1.1\n'+ \
> - 'clc_version_min: '+str(clcVersionMin)+'\n' + \
> - 'dimensions: 1\n' + \
> - 'global_size: 1 0 0\n\n'
> - )
> -
> - #Write all tests for the built-in function
> + # Write the file header
> + f.write('/*!\n' +
> + '[config]\n' +
> + 'name: Test '+dataType+' '+fnName+' built-in on CL 1.1\n' +
> + 'clc_version_min: '+str(clcVersionMin)+'\n' +
> + 'dimensions: 1\n' +
> + 'global_size: 1 0 0\n\n')
> +
> + # Write all tests for the built-in function
> tests = functionDef['values']
> argCount = len(functionDef['arg_types'])
> fnType = functionDef['function_type']
> @@ -888,20 +900,20 @@ def main():
> outputValues = tests[0]
> numTests = len(outputValues)
>
> - #Handle all available scalar/vector widths
> + # Handle all available scalar/vector widths
> sizes = sorted(VEC_WIDTHS)
> - sizes.insert(0,1) #Add 1-wide scalar to the vector widths
> + sizes.insert(0, 1) # Add 1-wide scalar to the vector widths
> for vecSize in sizes:
> for testIdx in range(0, numTests):
> - print_test(f, fnName, dataType, functionDef, tests, \
> - testIdx, vecSize, (fnType is 'tss'))
> + print_test(f, fnName, dataType, functionDef, tests,
> + testIdx, vecSize, (fnType is 'tss'))
>
> - #Terminate the header section
> + # Terminate the header section
> f.write('!*/\n\n')
>
> - #Generate the actual kernels
> + # Generate the actual kernels
> generate_kernels(f, dataType, fnName, functionDef)
>
> - #Hopefully this next part is obvious :)
Don't like my snarky comments? ;-)
I've verified that there is no difference in the output of this script
compared with the previous version. Tests are generated identically,
and they seems to still work fine.
With, or without, the change for the VEC_WIDTHS definition suggested
above, this patch is:
Reviewed-by: Aaron Watry <awatry at gmail.com>
> f.close()
> +
> main()
> --
> 1.8.3.1
>
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
More information about the Piglit
mailing list