[Piglit] [PATCH] Add initial python built-in test generator

Tom Stellard tom at stellard.net
Tue Feb 5 09:32:22 PST 2013


On Tue, Feb 05, 2013 at 11:26:38AM -0600, Aaron Watry wrote:
> On Tue, Feb 5, 2013 at 9:32 AM, Tom Stellard <tom at stellard.net> wrote:
> 
> > On Mon, Feb 04, 2013 at 01:35:16PM -0600, Aaron Watry wrote:
> > > Initial version only generates tests for the char data type.
> >
> > This looks like a good first step, I am impressed with how thorough the
> > tests
> > are.  I think it is important to try to generate as much stuff as possible,
> > so whenever there is an opportunity to do this, we should try to take
> > advantage.
> > I have made a few comments inline.
> >
> >
> I had started by hand-writing the char tests for every built-in, and
> decided to come up with different test inputs for each part of a char16
> input, which made the first set of test cases fairly verbose when I
> converted to the test generator.  Before I submit a final version for
> inclusion in piglit, I'll trim down the redundant test inputs.
> 
> 
> 
> > > ---
> > >  .../cl/program/execute/builtin/builtin-integer.inc |  291
> > ++++++++++++++++++++
> > >  tests/cl/program/execute/builtin/builtins-gen.py   |  272
> > ++++++++++++++++++
> > >  2 files changed, 563 insertions(+), 0 deletions(-)
> > >  create mode 100644 tests/cl/program/execute/builtin/builtin-integer.inc
> > >  create mode 100755 tests/cl/program/execute/builtin/builtins-gen.py
> > >
> > > diff --git a/tests/cl/program/execute/builtin/builtin-integer.inc
> > b/tests/cl/program/execute/builtin/builtin-integer.inc
> > > new file mode 100644
> > > index 0000000..c0d6796
> > > --- /dev/null
> > > +++ b/tests/cl/program/execute/builtin/builtin-integer.inc
> > > @@ -0,0 +1,291 @@
> > > +typedef T T_TYPE;
> > > +typedef U U_TYPE;
> > > +typedef S S_TYPE;
> > > +
> > > +/*
> > > +   Caveats:
> > > +        1) These tests assume that vstore/vload work for the datatype
> > being
> > > +           tested. There's other tests for this already.
> >
> > Implementing the vstore / vload builitins are on my TODO list, and I'm
> > hoping
> > to finish them before the 9.1 release.
> >
> >
> I need to fix this comment a bit.  Technically we only have tests for
> vstore/vload on 32-bit int data types at the moment (as far as I see).
> 
> 
> > > +        2) These tests assume that you're running on a device capable
> > of CL1.1
> > > +           (e.g. clamp requires 1.1 for int types)
> > > +*/
> > > +
> > > +
> > > +#define gen_kernel_1_arg(fnName, inType, outType) \
> > > +kernel void test_##fnName##_scalar(global outType* out, global inType*
> > in){ \
> > > +  *out = fnName(*in);\
> > > +} \
> > > +kernel void test_##fnName##_2(global outType* out, global inType* in){ \
> > > +  vstore2(fnName(vload2(0, in)), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_4(global outType* out, global inType* in){ \
> > > +  vstore4(fnName(vload4(0, in)), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_8(global outType* out, global inType* in){ \
> > > +  vstore8(fnName(vload8(0, in)), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_16(global outType* out, global inType* in){
> > \
> > > +  vstore16(fnName(vload16(0, in)), 0, out);\
> > > +}
> > > +
> > > +/* 2 argument kernel with input types that match */
> > > +
> > > +#define gen_kernel_2_arg_same_type(fnName, inType, outType) \
> > > +kernel void test_##fnName##_scalar(global outType* out, global inType*
> > in1, global inType* in2){ \
> > > +  *out = fnName(*in1, *in2);\
> > > +} \
> > > +kernel void test_##fnName##_2(global outType* out, global inType* in1,
> > global inType* in2){ \
> > > +  vstore2(fnName(vload2(0, in1), vload2(0, in2)), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_4(global outType* out, global inType* in1,
> > global inType* in2){ \
> > > +  vstore4(fnName(vload4(0, in1), vload4(0, in2)), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_8(global outType* out, global inType* in1,
> > global inType* in2){ \
> > > +  vstore8(fnName(vload8(0, in1), vload8(0, in2)), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_16(global outType* out, global inType* in1,
> > global inType* in2){ \
> > > +  vstore16(fnName(vload16(0, in1), vload16(0, in2)), 0, out);\
> > > +}
> > > +
> > > +#define gen_kernel_2_arg_mixed_size(fnName, inType, outType) \
> > > +kernel void test_##fnName##_tss_2(global outType* out, global inType*
> > in1, global inType* in2){ \
> > > +  vstore2(fnName(vload2(0, in1), *in2), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_tss_4(global outType* out, global inType*
> > in1, global inType* in2){ \
> > > +  vstore4(fnName(vload4(0, in1), *in2), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_tss_8(global outType* out, global inType*
> > in1, global inType* in2){ \
> > > +  vstore8(fnName(vload8(0, in1), *in2), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_tss_16(global outType* out, global inType*
> > in1, global inType* in2){ \
> > > +  vstore16(fnName(vload16(0, in1), *in2), 0, out);\
> > > +}
> > > +
> > > +
> > > +/* 3-argument built-in functions */
> > > +
> > > +#define gen_kernel_3_arg_same_type(fnName, inType, outType) \
> > > +kernel void test_##fnName##_scalar(global outType* out, global inType*
> > in1, global inType* in2, global inType* in3){ \
> > > +  *out = fnName(*in1, *in2, *in3);\
> > > +} \
> > > +kernel void test_##fnName##_2(global outType* out, global inType* in1,
> > global inType* in2, global inType* in3){ \
> > > +  vstore2(fnName(vload2(0, in1), vload2(0, in2), vload2(0, in3)), 0,
> > out);\
> > > +} \
> > > +kernel void test_##fnName##_4(global outType* out, global inType* in1,
> > global inType* in2, global inType* in3){ \
> > > +  vstore4(fnName(vload4(0, in1), vload4(0, in2), vload4(0, in3)), 0,
> > out);\
> > > +} \
> > > +kernel void test_##fnName##_8(global outType* out, global inType* in1,
> > global inType* in2, global inType* in3){ \
> > > +  vstore8(fnName(vload8(0, in1), vload8(0, in2), vload8(0, in3)), 0,
> > out);\
> > > +} \
> > > +kernel void test_##fnName##_16(global outType* out, global inType* in1,
> > global inType* in2, global inType* in3){ \
> > > +  vstore16(fnName(vload16(0, in1), vload16(0, in2), vload16(0, in3)),
> > 0, out);\
> > > +}
> > > +
> > > +#define gen_kernel_3_arg_mixed_size(fnName, inType, outType) \
> > > +kernel void test_##fnName##_tss_2(global outType* out, global inType*
> > in1, global inType* in2, global inType* in3){ \
> > > +  vstore2(fnName(vload2(0, in1), vload2(0, in2), vload2(0, in3)), 0,
> > out);\
> > > +} \
> > > +kernel void test_##fnName##_tss_4(global outType* out, global inType*
> > in1, global inType* in2, global inType* in3){ \
> > > +  vstore4(fnName(vload4(0, in1), *in2, *in3), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_tss_8(global outType* out, global inType*
> > in1, global inType* in2, global inType* in3){ \
> > > +  vstore8(fnName(vload8(0, in1), *in2, *in3), 0, out);\
> > > +} \
> > > +kernel void test_##fnName##_tss_16(global outType* out, global inType*
> > in1, global inType* in2, global inType* in3){ \
> > > +  vstore16(fnName(vload16(0, in1), *in2, *in3), 0, out);\
> > > +}
> > > +
> > > +
> > > +/*
> > > +    Actually start defining the kernels for built-in functions
> > > +*/
> > > +
> >
> > If possible, I think it would be a good idea to try to generate these
> > kernel
> > definitions too.  This would make it easier to have a separate file for
> > each
> > builtin, which I suggest in a comment below.
> >
> >
> Something like a lookup table or other structure that contains the
> function names, number of arguments, signedness of each arg, and whether
> mixed scalar/vector arguments are allowed?
> 

I don't think my comment here was clear.  I think the macros defined above
can all be in the same file, but the kernel definitions below should go
in the builtin specific files.

-Tom

> I'll change the next version to produce a separate file per data
> type/function, but we'll see what form the final code takes to get us
> there.  Since the version I sent out yesterday, I've made some progress
> that should make this easier.
> 
> 
> > > +//Integer Built-in Functions [6.11.3]
> > > +//T is type char, charn, uchar, ucharn, short, shortn, ushort, ushortn,
> > int, intn, uint, uintn, long, longn, ulong, or ulongn.
> > > +//U is the unsigned version of T. S is the scalar version of T.
> > > +
> > > +//U abs (T x) | x |
> > > +gen_kernel_1_arg(abs, T, U)
> > > +
> > > +//U abs_diff (T x, T y) | x – y | without modulo overflow
> > > +gen_kernel_2_arg_same_type(abs_diff, T, U);
> > > +
> > > +//T add_sat (T x, T y) x + y and saturates the result
> > > +gen_kernel_2_arg_same_type(add_sat, T, T);
> > > +
> > > +//T hadd (T x, T y) (x + y) >> 1 without mod. overflow
> > > +gen_kernel_2_arg_same_type(hadd, T, T);
> > > +
> > > +//T rhadd (T x, T y) (x + y + 1) >> 1
> > > +gen_kernel_2_arg_same_type(rhadd, T, T);
> > > +
> > > +//T clz (T x) Number of leading 0-bits in x
> > > +gen_kernel_1_arg(clz, T, T);
> > > +
> > > +//T clamp (T x, T min, T max)
> > > +gen_kernel_3_arg_same_type(clamp, T, T);
> > > +
> > > +//T clamp (T x, S min, S max) min(max(x, minval), maxval)
> > > +gen_kernel_3_arg_mixed_size(clamp, T, T);
> > > +
> > > +//T mad_hi (T a, T b, T c) mul_hi(a, b) + c
> > > +gen_kernel_3_arg_same_type(mad_hi, T, T);
> > > +
> > > +//T mad_sat (T a, T b, T c) a * b + c and saturates the result
> > > +gen_kernel_3_arg_same_type(mad_sat, T, T);
> > > +
> > > +//T max (T x, T y)
> > > +gen_kernel_2_arg_same_type(max, T, T);
> > > +
> > > +//T max (T x, S y) y if x < y, otherwise it returns x
> > > +gen_kernel_2_arg_mixed_size(max, T, T);
> > > +
> > > +//T min (T x, T y) y if y < x, otherwise it returns x
> > > +gen_kernel_2_arg_same_type(min, T, T);
> > > +
> > > +//T min (T x, S y) y if y < x, otherwise it returns x
> > > +gen_kernel_2_arg_mixed_size(min, T, T);
> > > +
> > > +//T mul_hi (T x, T y) high half of the product of x and y
> > > +gen_kernel_2_arg_same_type(mul_hi, T, T);
> > > +
> > > +//T rotate (T v, T i) result[indx] = v[indx] << i[indx]
> > > +gen_kernel_2_arg_same_type(rotate, T, T);
> > > +
> > > +//T sub_sat (T x, T y) x - y and saturates the result
> > > +gen_kernel_2_arg_same_type(sub_sat, T, T);
> > > +
> > > +//For upsample, scalar types are permitted for the vector types below.
> > > +//shortn upsample (charn hi, ucharn lo)
> > > +//result[i]= ((short)hi[i]<< 8) | lo[i]
> > > +kernel void test_upsample_char_1(global short* out, global char* in1,
> > global uchar* in2){
> > > +    *out = upsample(*in1, *in2);
> > > +}
> > > +kernel void test_upsample_char_2(global short* out, global char* in1,
> > global uchar* in2){
> > > +    vstore2(upsample(vload2(0, in1), vload2(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_char_4(global short* out, global char* in1,
> > global uchar* in2){
> > > +    vstore4(upsample(vload4(0, in1), vload4(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_char_8(global short* out, global char* in1,
> > global uchar* in2){
> > > +    vstore8(upsample(vload8(0, in1), vload8(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_char_16(global short* out, global char* in1,
> > global uchar* in2){
> > > +    vstore16(upsample(vload16(0, in1), vload16(0,in2)), 0, out);
> > > +}
> > > +
> > > +//ushortn upsample (ucharn hi, ucharn lo)
> > > +//result[i]=((ushort)hi[i]<< 8) | lo[i]
> > > +kernel void test_upsample_uchar_1(global ushort* out, global uchar*
> > in1, global uchar* in2){
> > > +    *out = upsample(*in1, *in2);
> > > +}
> > > +kernel void test_upsample_uchar_2(global ushort* out, global uchar*
> > in1, global uchar* in2){
> > > +    vstore2(upsample(vload2(0, in1), vload2(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_uchar_4(global ushort* out, global uchar*
> > in1, global uchar* in2){
> > > +    vstore4(upsample(vload4(0, in1), vload4(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_uchar_8(global ushort* out, global uchar*
> > in1, global uchar* in2){
> > > +    vstore8(upsample(vload8(0, in1), vload8(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_uchar_16(global ushort* out, global uchar*
> > in1, global uchar* in2){
> > > +    vstore16(upsample(vload16(0, in1), vload16(0,in2)), 0, out);
> > > +}
> > > +
> > > +//intn upsample (shortn hi, ushortn lo)
> > > +//result[i]=((int)hi[i]<< 16) | lo[i]
> > > +kernel void test_upsample_short_1(global int* out, global short* in1,
> > global ushort* in2){
> > > +    *out = upsample(*in1, *in2);
> > > +}
> > > +kernel void test_upsample_short_2(global int* out, global short* in1,
> > global ushort* in2){
> > > +    vstore2(upsample(vload2(0, in1), vload2(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_short_4(global int* out, global short* in1,
> > global ushort* in2){
> > > +    vstore4(upsample(vload4(0, in1), vload4(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_short_8(global int* out, global short* in1,
> > global ushort* in2){
> > > +    vstore8(upsample(vload8(0, in1), vload8(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_short_16(global int* out, global short* in1,
> > global ushort* in2){
> > > +    vstore16(upsample(vload16(0, in1), vload16(0,in2)), 0, out);
> > > +}
> > > +
> > > +//uintn upsample (ushortn hi, ushortn lo)
> > > +//result[i]=((uint)hi[i]<< 16) | lo[i]
> > > +kernel void test_upsample_ushort_1(global uint* out, global ushort*
> > in1, global ushort* in2){
> > > +    *out = upsample(*in1, *in2);
> > > +}
> > > +kernel void test_upsample_ushort_2(global uint* out, global ushort*
> > in1, global ushort* in2){
> > > +    vstore2(upsample(vload2(0, in1), vload2(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_ushort_4(global uint* out, global ushort*
> > in1, global ushort* in2){
> > > +    vstore4(upsample(vload4(0, in1), vload4(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_ushort_8(global uint* out, global ushort*
> > in1, global ushort* in2){
> > > +    vstore8(upsample(vload8(0, in1), vload8(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_ushort_16(global uint* out, global ushort*
> > in1, global ushort* in2){
> > > +    vstore16(upsample(vload16(0, in1), vload16(0,in2)), 0, out);
> > > +}
> > > +
> > > +//longn upsample (intn hi, uintn lo)
> > > +//result[i]=((long)hi[i]<< 32) | lo[i]
> > > +kernel void test_upsample_int_1(global long* out, global int* in1,
> > global uint* in2){
> > > +    *out = upsample(*in1, *in2);
> > > +}
> > > +kernel void test_upsample_int_2(global long* out, global int* in1,
> > global uint* in2){
> > > +    vstore2(upsample(vload2(0, in1), vload2(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_int_4(global long* out, global int* in1,
> > global uint* in2){
> > > +    vstore4(upsample(vload4(0, in1), vload4(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_int_8(global long* out, global int* in1,
> > global uint* in2){
> > > +    vstore8(upsample(vload8(0, in1), vload8(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_int_16(global long* out, global int* in1,
> > global uint* in2){
> > > +    vstore16(upsample(vload16(0, in1), vload16(0,in2)), 0, out);
> > > +}
> > > +
> > > +//ulongn upsample (uintn hi, uintn lo)
> > > +//result[i]=((ulong)hi[i]<< 32) | lo[i]
> > > +kernel void test_upsample_uint_1(global ulong* out, global uint* in1,
> > global uint* in2){
> > > +    *out = upsample(*in1, *in2);
> > > +}
> > > +kernel void test_upsample_uint_2(global ulong* out, global uint* in1,
> > global uint* in2){
> > > +    vstore2(upsample(vload2(0, in1), vload2(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_uint_4(global ulong* out, global uint* in1,
> > global uint* in2){
> > > +    vstore4(upsample(vload4(0, in1), vload4(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_uint_8(global ulong* out, global uint* in1,
> > global uint* in2){
> > > +    vstore8(upsample(vload8(0, in1), vload8(0,in2)), 0, out);
> > > +}
> > > +kernel void test_upsample_uint_16(global ulong* out, global uint* in1,
> > global uint* in2){
> > > +    vstore16(upsample(vload16(0, in1), vload16(0,in2)), 0, out);
> > > +}
> > > +
> > > +/*
> > > +//The following fast integer functions optimize the performance
> > > +//of kernels. In these functions, T is type int, int2, int3, int4,
> > int8, int16, uint, uint2, uint4, uint8 or uint16.
> > > +
> > > +//T mad24 (T a, T b, T c) Multiply 24-bit int. values a, b, add 32-bit
> > int. result to 32-bit int. c
> > > +//gen_kernel_3_arg_same_type(mad24, T, T);
> > > +
> > > +//T mul24 (T a, T b) Multiply 24-bit int. values a and b
> > > +//gen_kernel_2_arg_same_type(mul24, T, T);
> > > +
> > > +//TODO:
> > > +//For the upsample functions, put them in the file responsible for
> > testing the
> > > +//first argument type: e.g. shortN upsample(charN hi, ucharN lo) goes
> > in char tests.
> > > +//shortn upsample (charn hi, ucharn lo)
> > > +//ushortn upsample (ucharn hi, ucharn lo)
> > > +//intn upsample (shortn hi, ushortn lo)
> > > +//uintn upsample (ushortn hi, ushortn lo)
> > > +//longn upsample (intn hi, uintn lo)
> > > +//ulongn upsample (uintn hi, uintn lo)
> > > +
> > > +//Put these in the signed int test file.
> > > +//T mad24 (T a, T b, T c) Multiply 24-bit int. values a, b, add 32-bit
> > int. result to 32-bit int. c
> > > +//T mul24 (T a, T b) Multiply 24-bit int. values a and b
> > > +
> > > +*/
> > > \ No newline at end of file
> > > diff --git a/tests/cl/program/execute/builtin/builtins-gen.py
> > b/tests/cl/program/execute/builtin/builtins-gen.py
> > > new file mode 100755
> > > index 0000000..40b03d1
> > > --- /dev/null
> > > +++ b/tests/cl/program/execute/builtin/builtins-gen.py
> > > @@ -0,0 +1,272 @@
> > > +#!/usr/bin/python
> > > +
> > > +#The following is a data structure of the following:
> > > +# builtins = {
> > > +#   '{data_type}': { #data type is any of char, uchar, short, ushort,
> > int, uint, long, ulong
> >
> > How about adding a 'generic' data type that is used to generate tests
> > for all types?  This would allow to specify one test that could be run
> > on all data types and then you can add type-specific tests as needed.
> > You might even be able to use this for testing edge cases, by creating
> > a MAX_INT / MIN_INT value that is understood by the script to mean
> > substitute the maximum /minimum value for this type.
> >
> 
> I'll see what I can do.  I definitely agree about adding [MIN|MAX]_{TYPE}
> definitions instead of the magic numbers currently in the code. Adding
> 'generic' tests will be a little more work, but it should speed up the
> process of writing the short/int/long (and unsigned) tests once it's
> completed.
> 
> 
> >
> > > +#       '{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}': {...},
> > > +#   ...
> > > +# }
> > > +
> > > +# Need to create an outer associative array
> > > +# Will need several sets for vector/scalar input types (ttt/tss
> > function)
> > > +builtins = {
> > > +    'char': {
> > > +        'abs': {
> > > +            'arg_types': ['uchar', 'char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +              [0,  1, 2,  3, 4,  5, 6,  7, 8,  9, 10,  11, 12,  13,
> >  128, 127],
> > > +              [0, -1, 2, -3, 4, -5, 6, -7, 8, -9, 10, -11, 12, -13,
> > -128, 127]
> >
> > I think some of these tests are redundant.  It should be sufficient
> > to test the edge cases (i.e. for abs() -1, 0, 1, MAX_INT, MIN_INT)
> > plus one generic cases for each class of inputs (for abs() this would
> > be one positive integer and one negative integer).  Actually for abs()
> > it is probably debatable whether or not -1 and 1 are edge cases and I
> > think that abs(MIN_INT) so maybe there can be less edge cases.
> >
> >
> They are redundant.  I'll cut this down to a more sane number of tests.
> This is an artifact of my having hand-written 16-wide vector tests and not
> wanting to just spam the same values across all components.
> 
> 
> > > +            ]
> > > +        },
> > > +        'abs_diff': {
> > > +            'arg_types': ['uchar','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +               [15, 13, 11, 10,  8,  5,  3,  1,  1,  3,  5,  7,  9, 11,
> >  255,  255],
> > > +               [-8, -7, -6, -6, -5, -3, -2, -1,  0,  1,  2,  3,  4,  5,
> > -128,  127],
> > > +               [ 7,  6,  5,  4,  3,  2,  1,  0, -1, -2, -3, -4, -5, -6,
> >  127, -128]
> > > +            ]
> > > +        },
> > > +        'add_sat': {
> > > +            'arg_types': ['char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +               [  0, -2, 13,  64, -128, 127, 127, -128,   0, -2, 13,
> >  64, -128, 127, 127, -128],
> > > +               [ 32, -8, -7, 127, -120, 127, 100, -100,  32, -8, -7,
> > 127, -120, 127, 100, -100],
> > > +               [-32,  6, 20, -63,  -12,  64,  50,  -50, -32,  6, 20,
> > -63,  -12,  64,  50,  -50]
> > > +            ]
> > > +        },
> > > +        'hadd': {
> > > +            'arg_types': ['char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [32, 0, -33, 10, 32, 0, -33, 10, 32, 0, -33, 10, 32, 0,
> > -33, 10],
> > > +                [32, 1, -33, 12, 32, 1, -33, 12, 32, 1, -33, 12, 32, 1,
> > -33, 12],
> > > +                [33, 0, -32,  8, 33, 0, -32,  8, 33, 0, -32,  8, 33, 0,
> > -32,  8]
> > > +            ]
> > > +        },
> > > +        'rhadd': {
> > > +            'arg_types': ['char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [33, 1, -32, 10, 33, 1, -32, 10, 33, 1, -32, 10, 33, 1,
> > -32, 10],
> > > +                [32, 1, -33, 12, 32, 1, -33, 12, 32, 1, -33, 12, 32, 1,
> > -33, 12],
> > > +                [33, 0, -32,  8, 33, 0, -32,  8, 33, 0, -32,  8, 33, 0,
> > -32,  8]
> > > +            ]
> > > +        },
> > > +        'clz': {
> > > +            'arg_types': ['char', 'char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [ 2,  1, 8,  0,  2,  1, 8,  0,  2,  1, 8,  0,  2,  1,
> > 8,  0],
> > > +                [32, 64, 0, -1, 32, 64, 0, -1, 32, 64, 0, -1, 32, 64,
> > 0, -1]
> > > +            ]
> > > +        },
> > > +        'clamp': {
> > > +            'arg_types': ['char','char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [64,  -64,  1,  0, 64,  -64,  1,  0, 64,  -64,  1,  0,
> > 64,  -64,  1,  0],
> > > +                [92, -128, 64, -1, 92, -128, 64, -1, 92, -128, 64, -1,
> > 92, -128, 64, -1],
> > > +                [ 0,  -64,  0,  0,  0,  -64,  0,  0,  0,  -64,  0,  0,
> >  0,  -64,  0,  0],
> > > +                [64,    0,  1,  1, 64,    0,  1,  1, 64,    0,  1,  1,
> > 64,    0,  1,  1]
> > > +            ]
> > > +        },
> > > +        'mad_hi': {
> > > +            'arg_types': ['char','char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [ 0, -128,  1,    1,  4,   1,    0, -66,  -64,   63,
> >  1, 0, 2,   -2, 0, 0],
> > > +                [92,   -1, 64, -128, 12, 127, -128, 127, -128, -128,
> > 92, 0, 127,  1, 0, 0],
> > > +                [ 2, -128,  1,    2,  4,   1,    1, 127, -128,  127,
> >  1, 0, 2,   -1, 0, 0],
> > > +                [ 0, -128,  1,    2,  4,   1,    1, 127, -128,  127,
> >  1, 0, 2,   -1, 0, 0]
> > > +            ]
> > > +        },
> > > +        'mad_sat': {
> > > +            'arg_types': ['char','char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [127,    0, 65, -128, 52, 127, -128, 127,  127, -128,
> > 93, 0, 127, -2, -128, 127],
> > > +                [ 92,   -1, 64, -128, 12, 127, -128, 127, -128, -128,
> > 92, 0, 127,  1, -128, 127],
> > > +                [  2, -128,  1,    2,  4,   1,    1, 127, -128,  127,
> >  1, 0,   2, -1,    1, 127],
> > > +                [  0, -128,  1,    2,  4,   1,   -1, 127, -128,  127,
> >  1, 0,   2, -1,   -1, 127]
> > > +            ]
> > > +        },
> > > +        'max': {
> > > +            'arg_types': ['char', 'char', 'char'],
> > > +            'function_type': 'tss',
> > > +            'values': [
> > > +                [92,   -1, 64,    2, 12, 127,    1, 127, -128,  127,
> > 92, 0, 127,  1,    1, 127],
> > > +                [92,   -1, 64,    2, 12, 127, -128, 127, -128, -128,
> > 92, 0, 127,  1, -128, 127],
> > > +                [ 2, -128,  1, -128,  4,   1,    1, 127, -128,  127,
> >  1, 0,   2, -1,    1, 127]
> > > +            ]
> > > +        },
> > > +        'min': {
> > > +            'arg_types': ['char', 'char', 'char'],
> > > +            'function_type': 'tss',
> > > +            'values': [
> > > +                [ 2, -128,  1, -128,  4,   1, -128, 127, -128, -128,
> >  1, 0,   2, -1, -128, 127],
> > > +                [92,   -1, 64,    2, 12, 127, -128, 127, -128, -128,
> > 92, 0, 127,  1, -128, 127],
> > > +                [ 2, -128,  1, -128,  4,   1,    1, 127, -128,  127,
> >  1, 0,   2, -1,    1, 127]
> > > +            ]
> > > +        },
> > > +        'mul_hi': {
> > > +            'arg_types': ['char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [ 0,    0,  0,   -1,  0,   0,   -1,  63,   64,  -64,
> >  0, 0,   0, -1, 0, 0],
> > > +                [92,   -1, 64, -128, 12, 127, -128, 127, -128, -128,
> > 92, 0, 127,  1, 0, 0],
> > > +                [ 2, -128,  1,    2,  4,   1,    1, 127, -128,  127,
> >  1, 0,   2, -1, 0, 0]
> > > +            ]
> > > +        },
> > > +        'rotate': {
> > > +            'arg_types': ['char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [1, 2, 4, 8, 16, 32, 64, -128, 1, 2,  4,  8, 16, 32,
> > 64,  1, 1, -128, 64, 32, 16,  8,  4,  2,  1,  -128,  64,  32,  16,   8,
> > 4,   1],
> > > +                [1, 1, 1, 1,  1,  1,  1,    1, 1, 1,  1,  1,  1,  1,
> >  1,  1, 1,    1,  1,  1,  1,  1,  1,  1,  1,     1,   1,   1,   1,   1,
> > 1,   1],
> > > +                [0, 1, 2, 3,  4,  5,  6,    7, 8, 9, 10, 11, 12, 13,
> > 14, 80, 0,   -1, -2, -3, -4, -5, -6, -7, -8,    -9, -10, -11, -12, -13,
> > -14, -80]
> > > +            ]
> > > +        },
> > > +        'sub_sat': {
> > > +            'arg_types': ['char','char','char'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [1,  2,  3, -128, 127,  127,  7,  8,  9, 10,  11,  12,
> >  13,  14,  15,  81],
> > > +                [1,  1,  1,  -64, 120,  127,  1,  1,  1,  1,   1,   1,
> >   1,   1,   1,   1],
> > > +                [0, -1, -2,   64, -32, -128, -6, -7, -8, -9, -10, -11,
> > -12, -13, -14, -80]
> > > +            ]
> > > +        },
> > > +        'upsample': {
> > > +            'arg_types': ['short','char','uchar'],
> > > +            'function_type': 'ttt',
> > > +            'values': [
> > > +                [256, 257,  -1, 32767, 0, 127, -256, 263, 264, 265,
> > 266, 11, 268, 269, 270, 336],
> > > +                [  1,   1,  -1,   127, 0,   0,   -1,   1,   1,   1,
> > 1,  0,   1,   1,   1,   1],
> > > +                [  0,   1, 255,   255, 0, 127,    0,   7,   8,   9,
> >  10, 11,  12,  13,  14,  80]
> > > +            ]
> > > +        }
> > > +    } #End of char tests
> > > +}
> > > +
> > > +#By default, let's just test what is part of the CL1.1 stock spec,
> > leave vec3 for later
> > > +#vector_widths = (2, 3, 4, 8, 16)
> > > +vector_widths = (2, 4, 8, 16)
> > > +
> > > +#### Define helper functions ####
> > > +
> > > +def print_test(f, fnName, fnSuffix, argType, argCount, tests, testIdx,
> > vecSize):
> > > +    f.write('[test]\n' + \
> > > +        'name: ' + fnName + ' ' + argType + str(vecSize) + '\n' + \
> > > +        'kernel_name: test_' + fnName + '_' + fnSuffix + \
> > > +        '\n'
> > > +    )
> > > +
> > > +    for arg in range(0, argCount):
> > > +        argInOut = ''
> > > +        if arg == 0:
> > > +            argInOut = 'arg_out: '
> > > +        else:
> > > +            argInOut = 'arg_in: '
> > > +        argVal = str(tests[arg][testIdx])
> > > +        f.write(argInOut + str(arg) + ' buffer ' + argTypes[arg] + \
> > > +            '[' + str(vecSize) + '] ' + \
> > > +            ' '.join([argVal]*vecSize) + \
> > > +            '\n'
> > > +        )
> > > +
> > > +    #Blank line between tests for formatting clarity
> > > +    f.write('\n')
> > > +
> > > +
> > > +#Print a test with both all-vector inputs/outputs, and mixed
> > vector/scalar args
> > > +def print_test_tss(f, fnName, fnSuffix, argType, argCount, tests,
> > testIdx, vecSize):
> > > +    #Print test using all vector inputs
> > > +    print_test(f, fnName, fnSuffix, argType, argCount, tests, testIdx,
> > vecSize)
> > > +
> > > +    #Print test using mixed vector/scalar inputs
> > > +    f.write('[test]\n' + \
> > > +        'name: ' + fnName + ' ' + argType + str(vecSize) + '\n' + \
> > > +        'kernel_name: test_' + fnName + '_tss_' + fnSuffix + \
> > > +        '\n'
> > > +    )
> > > +
> > > +    for arg in range(0, argCount):
> > > +        argInOut = ''
> > > +        argVal = str(tests[arg][testIdx])
> > > +        if arg == 0:
> > > +            argInOut = 'arg_out: '
> > > +            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')
> > > +
> > > +
> > > +#### Main logic start ####
> > > +
> > > +#Loop over all data types being tested. Create one output file per data
> > type
> > > +for argType in builtins.keys():
> > > +    functions = builtins[argType]
> > > +    filename = 'builtin-' + argType
> > +'-1.1.python_generated.program_test'
> >
> > As I mentioned above, I think there should be one program_test file per
> > builtin, or even one file per builtin/argType combination.  This will help
> > keep
> > things more organized and make it easier to identify and debug failing
> > tests.
> >
> >
> Agreed. I'll take care of that.  I'll create one file per data type and
> function combination.
> 
> --Aaron
> 
> 
> > > +    f = open(filename, 'w')
> > > +    #Write the file header
> > > +    f.write( \
> > > +        '[config]\n' + \
> > > +        'name: '+argType+'-based built-in tests for CL 1.1\n'+ \
> > > +        'clc_version_min: 11\n' + \
> > > +        'dimensions: 1\n' + \
> > > +        'global_size: 1 0 0\n' + \
> > > +        'program_source_file: builtin-integer.inc\n' + \
> > > +        'build_options: -D U=u'+argType+' -D S='+argType+' -D
> > T='+argType+'\n\n'
> > > +    )
> > > +
> > > +    #Write all tests for each built-in function
> > > +    for fnName in sorted(functions.keys()):
> > > +        functionDef = functions[fnName]
> > > +        tests = functionDef['values']
> > > +        argCount = len(functionDef['arg_types'])
> > > +        argTypes = functionDef['arg_types']
> > > +        fnType = functionDef['function_type']
> > > +
> > > +        outputValues = tests[0]
> > > +        numTests = len(outputValues)
> > > +
> > > +        #Handle scalar tests
> > > +        for testIdx in range(0, numTests):
> > > +            print_test(f, fnName, 'scalar', argType, argCount, tests,
> > testIdx, 1)
> > > +
> > > +        #Handle all available vector widths
> > > +        for vecSize in sorted(vector_widths):
> > > +            for testIdx in range(0, numTests):
> > > +                if fnType == 'tss':
> > > +                    print_test_tss(f, fnName, str(vecSize), argType,
> > argCount, tests, testIdx, vecSize)
> > > +                else:
> > > +                    print_test(f, fnName, str(vecSize), argType,
> > argCount, tests, testIdx, vecSize)
> > > +
> > > +    #Hopefully this next part is obvious :)
> > > +    f.close()
> > > --
> > > 1.7.4.4
> > >
> > > _______________________________________________
> > > Piglit mailing list
> > > Piglit at lists.freedesktop.org
> > > http://lists.freedesktop.org/mailman/listinfo/piglit
> >


More information about the Piglit mailing list