From: Jan Vesely <jan.ves...@rutgers.edu> Add type3 vectors and bump required CLC to 1.1. Simplify test to use only 1-2 vstore calls. Zero the output buffer (fixes undefined values in results of some vstore tests).
v2: Add canary after the written values v3: Fixup canary Signed-off-by: Jan Vesely <jan.ves...@rutgers.edu> --- generated_tests/gen_cl_vstore_tests.py | 147 ++++++++++++++++++++------------- 1 file changed, 90 insertions(+), 57 deletions(-) diff --git a/generated_tests/gen_cl_vstore_tests.py b/generated_tests/gen_cl_vstore_tests.py index 93038aded..724f7a2b2 100644 --- a/generated_tests/gen_cl_vstore_tests.py +++ b/generated_tests/gen_cl_vstore_tests.py @@ -29,7 +29,7 @@ from six.moves import range from modules import utils TYPES = ['char', 'uchar', 'short', 'ushort', 'int', 'uint', 'long', 'ulong', 'half', 'float', 'double'] -VEC_SIZES = ['2', '4', '8', '16'] +VEC_SIZES = ['2', '3', '4', '8', '16'] DIR_NAME = os.path.join("cl", "vstore") @@ -47,15 +47,15 @@ def ext_req(type_name): return "" -def begin_test(suffix, type_name, mem_type, vec_sizes, addr_space): +def begin_test(suffix, type_name, mem_type, vec_sizes, addr_space, aligned): file_name = os.path.join(DIR_NAME, "vstore{}-{}-{}.cl".format(suffix, type_name, addr_space)) print(file_name) f = open(file_name, 'w') f.write(textwrap.dedent(("""\ /*! [config] - name: Vector store{suffix} {addr_space} {type_name}2,4,8,16 - clc_version_min: 10 + name: Vector store{suffix} {addr_space} {type_name}2,3,4,8,16 + clc_version_min: 11 dimensions: 1 global_size: 1 0 0 @@ -63,22 +63,34 @@ def begin_test(suffix, type_name, mem_type, vec_sizes, addr_space): .format(type_name=type_name, addr_space=addr_space, suffix=suffix))) for s in vec_sizes: size = int(s) if s != '' else 1 + modsize = 4 if size == 3 and aligned else size + offset = modsize if aligned else 1 + canary= '0xdeadp1' if type_name in ('float', 'double') else '0xdead' + ty_name = type_name + s f.write(textwrap.dedent(""" [test] name: vector store{suffix} {addr_space} {type_name} kernel_name: vstore{suffix}{n}_{addr_space} - arg_out: 0 buffer {mem_type}[{size}] 0 {gen_array} + arg_out: 0 buffer {mem_type}[{size}] {offset_zeros}{gen_array} {canary} + arg_in: 0 buffer {mem_type}[{size}] {offset_size_zeros} {canary} arg_in: 1 buffer {type_name}[1] {gen_array} [test] name: vector store{suffix} {addr_space} offset {type_name} kernel_name: vstore{suffix}{n}_{addr_space}_offset - arg_out: 0 buffer {mem_type}[{offset_size}] {zeros} {gen_array} - arg_in: 1 buffer {type_name}[1] {gen_array} - """.format(type_name=ty_name, mem_type=mem_type, size=size + 1, - zeros=("0 " * (size + 1)), offset_size=size * 2 + 1, n=s, - gen_array=gen_array(size), suffix=suffix, addr_space=addr_space))) + arg_out: 0 buffer {mem_type}[{offset_size}] {offset_zeros} {gen_array} {padd_zeros} {gen_array} {canary} + arg_in: 0 buffer {mem_type}[{offset_size}] {offset_modsize_size_zeros} {canary} + arg_in: 1 buffer {type_name}[1] {gen_array} + """.format(type_name=ty_name, mem_type=mem_type, size=size + offset + 1, + offset_zeros = ("0 " * offset), + offset_size_zeros = ("0 " * (offset + size)), + padd_zeros = ("0 " * (modsize - size)), + offset_modsize_size_zeros = ("0 " * (modsize + size + offset)), + offset_size=modsize + size + offset + 1, n=s, + gen_array=gen_array(size), + suffix=suffix, addr_space=addr_space, + canary=canary))) f.write(textwrap.dedent(""" !*/ @@ -94,124 +106,145 @@ def begin_test(suffix, type_name, mem_type, vec_sizes, addr_space): return f -def gen_test_global(suffix, t, mem_type, vec_sizes): - f = begin_test(suffix, t, mem_type, vec_sizes, 'global') +def gen_test_global(suffix, t, mem_type, vec_sizes, aligned): + f = begin_test(suffix, t, mem_type, vec_sizes, 'global', aligned) for s in vec_sizes: + offset = int(s) if aligned else 1 + offset = 4 if offset == 3 else offset + type_name = t + s f.write(textwrap.dedent(""" kernel void vstore{suffix}{n}_global(global {mem_type} *out, global {type_name} *in) {{ {type_name} tmp = in[0]; - vstore{suffix}{n}(({type_name})0, 0, out); - vstore{suffix}{n}(tmp, 0, out + 1); + vstore{suffix}{n}(tmp, 0, out + {offset}); }} kernel void vstore{suffix}{n}_global_offset(global {mem_type} *out, global {type_name} *in) {{ - {type_name} tmp = ({type_name})0; - vstore{suffix}{n}(tmp, 0, out); - vstore{suffix}{n}(tmp, 0, out + 1); - tmp = in[0]; - vstore{suffix}{n}(tmp, 1, out + 1); + {type_name} tmp = in[0]; + vstore{suffix}{n}(tmp, 0, out + {offset}); + vstore{suffix}{n}(tmp, 1, out + {offset}); }} - """.format(type_name=type_name, mem_type=mem_type, n=s, suffix=suffix))) + """.format(type_name=type_name, mem_type=mem_type, n=s, suffix=suffix, + offset=offset))) f.close() -def gen_test_local_private(suffix, t, mem_type, vec_sizes, addr_space): - f = begin_test(suffix, t, mem_type, vec_sizes, addr_space) +def gen_test_local_private(suffix, t, mem_type, vec_sizes, addr_space, aligned): + f = begin_test(suffix, t, mem_type, vec_sizes, addr_space, aligned) for s in vec_sizes: size = int(s) if s != '' else 1 + modsize = 4 if size == 3 and aligned else size + offset = modsize if aligned else 1 + type_name = t + s f.write(textwrap.dedent(""" kernel void vstore{suffix}{n}_{addr_space}(global {mem_type} *out, global {type_name} *in) {{ {type_name} tmp = in[0]; volatile {addr_space} {mem_type} loc[{size}]; - vstore{suffix}{n}(({type_name})0, 0, ({addr_space} {mem_type}*)loc); - vstore{suffix}{n}(tmp, 0, ({addr_space} {mem_type}*)loc + 1); + for (int i = 0; i < {size}; ++i) + loc[i] = ({mem_type})0; + + vstore{suffix}{n}(tmp, 0, ({addr_space} {mem_type}*)loc + {offset}); for (int i = 0; i < {size}; ++i) out[i] = loc[i]; }} kernel void vstore{suffix}{n}_{addr_space}_offset(global {mem_type} *out, global {type_name} *in) {{ - {type_name} tmp = ({type_name})0; + {type_name} tmp = in[0]; volatile {addr_space} {mem_type} loc[{offset_size}]; - vstore{suffix}{n}(tmp, 0, ({addr_space} {mem_type}*)loc); - vstore{suffix}{n}(tmp, 0, ({addr_space} {mem_type}*)loc + 1); - tmp = in[0]; - vstore{suffix}{n}(tmp, 1, ({addr_space} {mem_type}*)loc + 1); + for (int i = 0; i < {offset_size}; ++i) + loc[i] = ({mem_type})0; + + vstore{suffix}{n}(tmp, 0, ({addr_space} {mem_type}*)loc + {offset}); + vstore{suffix}{n}(tmp, 1, ({addr_space} {mem_type}*)loc + {offset}); for (int i = 0; i < {offset_size}; ++i) out[i] = loc[i]; }} """.format(type_name=type_name, mem_type=mem_type, n=s, suffix=suffix, - offset_size=size * 2 + 1, size=size + 1, addr_space=addr_space))) + offset_size=size + modsize + offset, size=size + offset, + addr_space=addr_space, offset=offset))) f.close() -# vstore_half is special, becuase CLC won't allow us to use half type without +# vstore_half is special, because CLC won't allow us to use half type without # cl_khr_fp16 -def gen_test_local_private_half(suffix, t, vec_sizes, addr_space): - f = begin_test(suffix, t, 'half', vec_sizes, addr_space) +def gen_test_local_private_half(suffix, t, vec_sizes, addr_space, aligned): + f = begin_test(suffix, t, 'half', vec_sizes, addr_space, aligned) for s in vec_sizes: size = int(s) if s != '' else 1 + modsize = 4 if size == 3 and aligned else size + offset = modsize if aligned else 1 + type_name = t + s f.write(textwrap.dedent(""" kernel void vstore{suffix}{n}_{addr_space}(global half *out, global {type_name} *in) {{ {type_name} tmp = in[0]; volatile {addr_space} short loc[{size}]; - vstore{suffix}{n}(({type_name})0, 0, ({addr_space} half*)loc); - vstore{suffix}{n}(tmp, 0, ({addr_space} half*)loc + 1); + for (int i = 0; i < {size}; ++i) + loc[i] = 0; + + vstore{suffix}{n}(tmp, 0, ({addr_space} half*)loc + {offset}); + for (int i = 0; i < {size}; ++i) ((global short *)out)[i] = loc[i]; }} kernel void vstore{suffix}{n}_{addr_space}_offset(global half *out, global {type_name} *in) {{ - {type_name} tmp = ({type_name})0; + {type_name} tmp = in[0]; volatile {addr_space} short loc[{offset_size}]; - vstore{suffix}{n}(tmp, 0, ({addr_space} half*)loc); - vstore{suffix}{n}(tmp, 0, ({addr_space} half*)loc + 1); - tmp = in[0]; - vstore{suffix}{n}(tmp, 1, ({addr_space} half*)loc + 1); + for (int i = 0; i < {offset_size}; ++i) + loc[i] = 0; + + vstore{suffix}{n}(tmp, 0, ({addr_space} half*)loc + {offset}); + vstore{suffix}{n}(tmp, 1, ({addr_space} half*)loc + {offset}); + for (int i = 0; i < {offset_size}; ++i) ((global short *)out)[i] = loc[i]; }} """.format(type_name=type_name, n=s, suffix=suffix, - offset_size=size * 2 + 1, size=size + 1, addr_space=addr_space))) + offset_size=size + modsize + offset, size=size + offset, + addr_space=addr_space, offset=offset))) -def gen_test_local(suffix, t, mem_type, vec_sizes): +def gen_test_local(suffix, t, mem_type, vec_sizes, aligned): if mem_type == 'half': - gen_test_local_private_half(suffix, t, vec_sizes, 'local') + gen_test_local_private_half(suffix, t, vec_sizes, 'local', aligned) else: - gen_test_local_private(suffix, t, mem_type, vec_sizes, 'local') + gen_test_local_private(suffix, t, mem_type, vec_sizes, 'local', aligned) -def gen_test_private(suffix, t, mem_type, vec_sizes): +def gen_test_private(suffix, t, mem_type, vec_sizes, aligned): if mem_type == 'half': - gen_test_local_private_half(suffix, t, vec_sizes, 'private') + gen_test_local_private_half(suffix, t, vec_sizes, 'private', aligned) else: - gen_test_local_private(suffix, t, mem_type, vec_sizes, 'private') + gen_test_local_private(suffix, t, mem_type, vec_sizes, 'private', aligned) def main(): utils.safe_makedirs(DIR_NAME) for t in TYPES: - gen_test_global('', t, t, VEC_SIZES); - gen_test_local('', t, t, VEC_SIZES); - gen_test_private('', t, t, VEC_SIZES); - - gen_test_global('_half', 'float', 'half', [''] + VEC_SIZES); - gen_test_global('_half', 'double', 'half', [''] + VEC_SIZES); - gen_test_local('_half', 'float', 'half', [''] + VEC_SIZES); - gen_test_local('_half', 'double', 'half', [''] + VEC_SIZES); - gen_test_private('_half', 'float', 'half', [''] + VEC_SIZES); - gen_test_private('_half', 'double', 'half', [''] + VEC_SIZES); + gen_test_global('', t, t, VEC_SIZES, False); + gen_test_local('', t, t, VEC_SIZES, False); + gen_test_private('', t, t, VEC_SIZES, False); + + for aligned in False, True: + suffix = "a_half" if aligned else "_half" + vec_sizes = VEC_SIZES if aligned else [''] + VEC_SIZES + + gen_test_global(suffix, 'float', 'half', vec_sizes, aligned); + gen_test_global(suffix, 'double', 'half', vec_sizes, aligned); + gen_test_local(suffix, 'float', 'half', vec_sizes, aligned); + gen_test_local(suffix, 'double', 'half', vec_sizes, aligned); + gen_test_private(suffix, 'float', 'half', vec_sizes, aligned); + gen_test_private(suffix, 'double', 'half', vec_sizes, aligned); if __name__ == '__main__': -- 2.13.6 _______________________________________________ Piglit mailing list Piglit@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/piglit