[Piglit] [PATCH v3 26/29] generate-cl-int-builtins.py: PEP8 compliance
Dylan Baker
baker.dylan.c at gmail.com
Wed Jul 24 14:57:09 PDT 2013
v2: - Add noncompliant formatting back to tables. This increases
readability, even if it's not PEP8 compliant per Chad
v3: - Revert some changes that were false positives from an old version
of the pep8 tool
Reviewed-by: Aaron Watry <awatry at gmail.com>
Reviewed-by: Chad Versace <chad.versace at linux.intel.com>
Signed-off-by: Dylan Baker <baker.dylan.c at gmail.com>
---
generated_tests/generate-cl-int-builtins.py | 659 +++++++++++++++-------------
1 file changed, 343 insertions(+), 316 deletions(-)
diff --git a/generated_tests/generate-cl-int-builtins.py b/generated_tests/generate-cl-int-builtins.py
index ae60ad2..dca38f1 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)
-VEC_WIDTHS = (2, 4, 8, 16)
-#ALL_WIDTHS = [1, 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]
+# 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,114 @@ 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,61 +257,63 @@ 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': {
@@ -305,9 +321,8 @@ generic_tests = {
'function_type': 'ttt',
'values': [
[32, 0, 10, MAX, MIN,
- [div,[add,MAX,MIN], 2],
- [div,[add,MIN,MAX], 2]
- ],
+ [div, [add, MAX, MIN], 2],
+ [div, [add, MIN, MAX], 2]],
[32, 1, 12, MAX, MIN, MAX, MIN],
[33, 0, 8, MAX, MIN, MIN, MAX]
]
@@ -316,13 +331,12 @@ generic_tests = {
'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],
@@ -330,7 +344,7 @@ generic_tests = {
'values': [
[64, [div, MIN, 2], 1],
[92, MIN, 64],
- [ 0, [div, MIN, 2], 0],
+ [0, [div, MIN, 2], 0],
[64, 0, 1]
]
},
@@ -338,13 +352,15 @@ generic_tests = {
'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': {
@@ -379,11 +395,14 @@ generic_tests = {
'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': {
@@ -399,59 +418,62 @@ generic_tests = {
'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': {
@@ -478,19 +500,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': {
@@ -506,7 +528,7 @@ signed_generic_tests = {
'arg_types': [T, T, T],
'function_type': 'ttt',
'values': [
- [ 0, -1, -1, -1],
+ [ 0 , -1, -1, -1],
[ -1, MIN, MIN, 1],
[MIN, 2, 1, -1]
]
@@ -514,73 +536,67 @@ signed_generic_tests = {
'rhadd': {
'arg_types': [T, T, T],
'function_type': 'ttt',
- 'values': [
- [-32],
- [-33],
- [-32]
- ]
+ 'values': [[-32], [-33], [-32]]
},
'rotate': {
'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 +606,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 +627,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 +650,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 +678,7 @@ def mergedTestDefinition(dataType, fnName):
mergedTest = addTestValues(dict(mergedTest), list(fnDef['values']))
return mergedTest
+
def getFnNames():
fnNames = []
fnNames += generic_tests.keys()
@@ -669,15 +688,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 +714,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 +724,48 @@ 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 +774,78 @@ 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 +863,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 +898,16 @@ 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 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 all tests for the built-in function
tests = functionDef['values']
argCount = len(functionDef['arg_types'])
fnType = functionDef['function_type']
@@ -888,20 +915,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 :)
f.close()
+
main()
--
1.8.3.1
More information about the Piglit
mailing list