From: Tom Stellard <thomas.stell...@amd.com> --- generated_tests/genclbuiltins.py | 395 ++++++++++++++++++++++++++++ generated_tests/generate-cl-int-builtins.py | 383 +-------------------------- 2 files changed, 402 insertions(+), 376 deletions(-) create mode 100644 generated_tests/genclbuiltins.py
diff --git a/generated_tests/genclbuiltins.py b/generated_tests/genclbuiltins.py new file mode 100644 index 0000000..29dfe39 --- /dev/null +++ b/generated_tests/genclbuiltins.py @@ -0,0 +1,395 @@ +__all__ = ['gen', 'DATA_SIZES', 'MAX_VALUES', 'MAX', 'MIN', 'BMIN', 'BMAX', + 'SMIN', 'SMAX', 'UMIN', 'UMAX', 'TYPE', 'T', 'U', 'B'] + +import os + + +DATA_SIZES = { + 'char': 8, + 'uchar': 8, + 'short': 16, + 'ushort': 16, + '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] +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 +} + +MAX_VALUES = { + 'char': 127, + 'uchar': 255, + 'short': 32767, + 'ushort': 65535, + 'int': 2147483647, + 'uint': 4294967295, + 'long': 9223372036854775807, + 'ulong': 18446744073709551615 +} + +# Define placeholders to reduce magic number usage +MAX = 'MAX_VAL' +MIN = 'MIN_VAL' +BMIN = 'min_for_larger_type' +BMAX = 'max_for_larger_type' +SMIN = 'signed_min_for_type' +SMAX = 'signed_max_for_type' +UMIN = 'unsigned_min_for_type' +UMAX = 'unsigned_max_for_type' +TYPE = 'TYPE' +SIZE = 'SIZE' + +# Identity type list +T = { + 'char': 'char', + 'uchar': 'uchar', + 'short': 'short', + 'ushort': 'ushort', + 'int': 'int', + 'uint': 'uint', + 'long': 'long', + 'ulong': 'ulong' +} +# Signed type for each type +SIGNED = { + 'char': 'char', + 'uchar': 'char', + 'short': 'short', + 'ushort': 'short', + 'int': 'int', + 'uint': 'int', + 'long': 'long', + 'ulong': 'long' +} +# Unsigned type for each source type +U = { + 'char': 'uchar', + 'uchar': 'uchar', + 'short': 'ushort', + 'ushort': 'ushort', + 'int': 'uint', + 'uint': 'uint', + 'long': 'ulong', + 'ulong': 'ulong' +} +# Next larger type with same signedness +B = { + 'char': 'short', + 'uchar': 'ushort', + 'short': 'int', + 'ushort': 'uint', + 'int': 'long', + 'uint': 'ulong', +} + + +# 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') + for arg in range(0, len(inTypes)): + f.write(', global '+inTypes[arg]+'* in'+str(arg)) + f.write('){\n') + + suffix = ';' + if (vecSizes[0] == 1): + f.write(' *out = ') + else: + f.write(' vstore'+str(vecSizes[0])+'(') + suffix = ', 0, out)' + suffix + + f.write(fnName+'(') + suffix = ')' + suffix + + for arg in range(0, len(inTypes)): + if (arg > 0): + f.write(', ') + # if scalar, don't print vload/vstore + if (vecSizes[arg] == 1): + f.write('*in'+str(arg)) + else: + f.write('vload'+str(vecSizes[arg])+'(0, in'+str(arg)+')') + + f.write(suffix+'\n}\n\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 +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], + '') + + +# 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 +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], + '') + + +# 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], '' + ) + + +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') + + +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_') + + +def generate_kernels(f, dataType, fnName, fnDef): + argTypes = getArgTypes(dataType, fnDef['arg_types']) + + # 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 + + if (len(argTypes) == 3 and not fnName is 'upsample'): + gen_kernel_2_arg_same_type(f, fnName, argTypes[1], argTypes[0]) + if (fnDef['function_type'] is 'tss'): + gen_kernel_2_arg_mixed_size(f, fnName, argTypes[1], argTypes[0]) + return + + if (len(argTypes) == 4): + gen_kernel_3_arg_same_type(f, fnName, argTypes[1], argTypes[0]) + if (fnDef['function_type'] is 'tss'): + gen_kernel_3_arg_mixed_size(f, fnName, argTypes[1], argTypes[0]) + return + + if (fnName is 'upsample'): + gen_kernel_2_arg_mixed_sign(f, fnName, argTypes[1], argTypes[2], + argTypes[0]) + return + +def getValue(type, val): + # Check if val is a str, list, or value + if (isinstance(val, str)): + if (val == MIN): + return MIN_VALUES[type] + elif (val == MAX): + return MAX_VALUES[type] + elif (val == BMIN): + return MIN_VALUES[B[type]] + elif (val == BMAX): + return MAX_VALUES[B[type]] + elif (val == SMIN): + return MIN_VALUES[SIGNED[type]] + elif (val == SMAX): + return MAX_VALUES[SIGNED[type]] + elif (val == UMIN): + return MIN_VALUES[U[type]] + elif (val == UMAX): + return MAX_VALUES[U[type]] + elif (val == TYPE): + return type + elif (val == SIZE): + return DATA_SIZES[type] + else: + 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 + + # 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])) + elif (len(val) == 3): + 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])) + else: + 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 + if (isinstance(val, (int, long))): + return val + + print('Invalid value '+repr(val)+' encountered in getValue\n') + + + +def getStrVal(type, val): + return str(getValue(type, val)) + + +def getArgType(baseType, argType): + # 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 + return argType[baseType] + + +def getArgTypes(baseType, argTypes): + ret = [] + for argType in argTypes: + ret.append(getArgType(baseType, argType)) + return ret + + +# 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 (tss): + print_test(f, fnName, argType, functionDef, tests, testIdx, vecSize, + False) + + # 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 + 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' + ) + + argTypes = getArgTypes(argType, functionDef['arg_types']) + argCount = len(argTypes) + + # 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]) + if arg == 0: + argInOut = 'arg_out: ' + 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 + if (arg < 2 or not tss): + 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' + ) + + # Blank line between tests for formatting reasons + f.write('\n') + + +def gen(types, minVersions, functions, testDefs, dirName): + # Create the output directory if required + if not os.path.exists(dirName): + os.makedirs(dirName) + + # Loop over all data types being tested. Create one output file per data + # type + for dataType in types: + for fnName in functions: + # Merge all of the generic/signed/unsigned/custom test definitions + if not testDefs.has_key((dataType, fnName)): + continue + functionDef = testDefs[(dataType, fnName)] + + # Check if the function actually exists for this data type + if (not functionDef.keys()): + continue + + clcVersionMin = minVersions[fnName] + + fileName = 'builtin-' + dataType + '-' + fnName + '-' + \ + str(float(clcVersionMin)/10)+'.generated.cl' + + fileName = os.path.join(dirName, fileName) + + 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 + tests = functionDef['values'] + argCount = len(functionDef['arg_types']) + fnType = functionDef['function_type'] + + outputValues = tests[0] + numTests = len(outputValues) + + # Handle all available scalar/vector widths + sizes = sorted(VEC_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')) + + # Terminate the header section + f.write('!*/\n\n') + + # Generate the actual kernels + generate_kernels(f, dataType, fnName, functionDef) + + f.close() + + diff --git a/generated_tests/generate-cl-int-builtins.py b/generated_tests/generate-cl-int-builtins.py index dca38f1..52184ad 100755 --- a/generated_tests/generate-cl-int-builtins.py +++ b/generated_tests/generate-cl-int-builtins.py @@ -1,6 +1,8 @@ # !/usr/bin/env python import os +from genclbuiltins import gen, DATA_SIZES, MAX_VALUES, MAX, MIN, BMIN, BMAX, \ + SMIN, SMAX, UMIN, UMAX, TYPE, SIZE, T, U, B # Builtins is a data structure of the following: # builtins = { @@ -28,103 +30,10 @@ import os # The builtins_generic, builtins_signed/unsigned are the same, but lack the # {datatype} layer -# Define placeholders to reduce magic number usage -MAX = 'MAX_VAL' -MIN = 'MIN_VAL' - 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, - 'ushort': 16, - '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] -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 -} - -MAX_VALUES = { - 'char': 127, - 'uchar': 255, - 'short': 32767, - 'ushort': 65535, - 'int': 2147483647, - 'uint': 4294967295, - 'long': 9223372036854775807, - 'ulong': 18446744073709551615 -} - -# Identity type list -T = { - 'char': 'char', - 'uchar': 'uchar', - 'short': 'short', - 'ushort': 'ushort', - 'int': 'int', - 'uint': 'uint', - 'long': 'long', - 'ulong': 'ulong' -} -# Signed type for each type -SIGNED = { - 'char': 'char', - 'uchar': 'char', - 'short': 'short', - 'ushort': 'short', - 'int': 'int', - 'uint': 'int', - 'long': 'long', - 'ulong': 'long' -} -# Unsigned type for each source type -U = { - 'char': 'uchar', - 'uchar': 'uchar', - 'short': 'ushort', - 'ushort': 'ushort', - 'int': 'uint', - 'uint': 'uint', - 'long': 'ulong', - 'ulong': 'ulong' -} -# Next larger type with same signedness -B = { - 'char': 'short', - 'uchar': 'ushort', - 'short': 'int', - 'ushort': 'uint', - 'int': 'long', - 'uint': 'ulong', -} -BMIN = 'min_for_larger_type' -BMAX = 'max_for_larger_type' -SMIN = 'signed_min_for_type' -SMAX = 'signed_max_for_type' -UMIN = 'unsigned_min_for_type' -UMAX = 'unsigned_max_for_type' -TYPE = 'TYPE' -SIZE = 'SIZE' CLC_VERSION_MIN = { 'abs': 10, @@ -233,61 +142,6 @@ def sub(val1, val2): return val1-val2 -def getValue(type, val): - # Check if val is a str, list, or value - if (isinstance(val, str)): - if (val == MIN): - return MIN_VALUES[type] - elif (val == MAX): - return MAX_VALUES[type] - elif (val == BMIN): - return MIN_VALUES[B[type]] - elif (val == BMAX): - return MAX_VALUES[B[type]] - elif (val == SMIN): - return MIN_VALUES[SIGNED[type]] - elif (val == SMAX): - return MAX_VALUES[SIGNED[type]] - elif (val == UMIN): - return MIN_VALUES[U[type]] - elif (val == UMAX): - return MAX_VALUES[U[type]] - elif (val == TYPE): - return type - elif (val == SIZE): - return DATA_SIZES[type] - else: - 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 - - # 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])) - elif (len(val) == 3): - 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])) - else: - 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 - if (isinstance(val, (int, long))): - return val - - print('Invalid value '+repr(val)+' encountered in getValue\n') - - -def getStrVal(type, val): - return str(getValue(type, val)) - - # Tests which don't depend on the signedness or bit-width of the inputs generic_tests = { 'abs': { @@ -692,243 +546,20 @@ def getFnNames(): return sorted(list(set(fnNames))) -# 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') - for arg in range(0, len(inTypes)): - f.write(', global '+inTypes[arg]+'* in'+str(arg)) - f.write('){\n') - - suffix = ';' - if (vecSizes[0] == 1): - f.write(' *out = ') - else: - f.write(' vstore'+str(vecSizes[0])+'(') - suffix = ', 0, out)' + suffix - - f.write(fnName+'(') - suffix = ')' + suffix - - for arg in range(0, len(inTypes)): - if (arg > 0): - f.write(', ') - # if scalar, don't print vload/vstore - if (vecSizes[arg] == 1): - f.write('*in'+str(arg)) - else: - f.write('vload'+str(vecSizes[arg])+'(0, in'+str(arg)+')') - - f.write(suffix+'\n}\n\n') - - -def getArgType(baseType, argType): - # 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 - return argType[baseType] - - -def getArgTypes(baseType, argTypes): - ret = [] - for argType in argTypes: - ret.append(getArgType(baseType, argType)) - return ret - - -# 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 (tss): - print_test(f, fnName, argType, functionDef, tests, testIdx, vecSize, - False) - - # 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 - 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' - ) - - argTypes = getArgTypes(argType, functionDef['arg_types']) - argCount = len(argTypes) - - # 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]) - if arg == 0: - argInOut = 'arg_out: ' - 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 - if (arg < 2 or not tss): - 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' - ) - - # 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 -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], - '') - - -# 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 -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], - '') - - -# 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], '' - ) - - -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') - - -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_') - - -def generate_kernels(f, dataType, fnName, fnDef): - argTypes = getArgTypes(dataType, fnDef['arg_types']) - - # 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 - - if (len(argTypes) == 3 and not fnName is 'upsample'): - gen_kernel_2_arg_same_type(f, fnName, argTypes[1], argTypes[0]) - if (fnDef['function_type'] is 'tss'): - gen_kernel_2_arg_mixed_size(f, fnName, argTypes[1], argTypes[0]) - return - - if (len(argTypes) == 4): - gen_kernel_3_arg_same_type(f, fnName, argTypes[1], argTypes[0]) - if (fnDef['function_type'] is 'tss'): - gen_kernel_3_arg_mixed_size(f, fnName, argTypes[1], argTypes[0]) - return - - if (fnName is 'upsample'): - gen_kernel_2_arg_mixed_sign(f, fnName, argTypes[1], argTypes[2], - argTypes[0]) - return - - def main(): - # 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 + testDefs = {} + functions = getFnNames() + for dataType in DATA_TYPES: - functions = getFnNames() # List of all built-in functions for fnName in functions: if (fnName is 'upsample' and (dataType is 'long' or dataType is 'ulong')): continue # Merge all of the generic/signed/unsigned/custom test definitions - functionDef = mergedTestDefinition(dataType, fnName) - - # Check if the function actually exists for this data type - if (not functionDef.keys()): - continue - - clcVersionMin = CLC_VERSION_MIN[fnName] - - fileName = 'builtin-' + dataType + '-' + fnName + '-' + \ - str(float(clcVersionMin)/10)+'.generated.cl' - - fileName = os.path.join(dirName, fileName) - - 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 - tests = functionDef['values'] - argCount = len(functionDef['arg_types']) - fnType = functionDef['function_type'] - - outputValues = tests[0] - numTests = len(outputValues) - - # Handle all available scalar/vector widths - sizes = sorted(VEC_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')) - - # Terminate the header section - f.write('!*/\n\n') - - # Generate the actual kernels - generate_kernels(f, dataType, fnName, functionDef) + testDefs[(dataType, fnName)] = mergedTestDefinition(dataType, fnName) - f.close() + gen(DATA_TYPES, CLC_VERSION_MIN, functions, testDefs, dirName) main() -- 1.7.11.4 _______________________________________________ Piglit mailing list Piglit@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/piglit