[Piglit] [PATCH v2 1/2] cl: Generate aligned vstorea tests
Jan Vesely
jan.vesely at rutgers.edu
Thu Oct 5 21:12:04 UTC 2017
On Thu, 2017-10-05 at 11:51 -0400, Jan Vesely wrote:
> 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
>
> Signed-off-by: Jan Vesely <jan.vesely at rutgers.edu>
Hi Dylan,
do you mind taking a cursory look at the python changes when you get
time?
Jan
> ---
> generated_tests/gen_cl_vstore_tests.py | 142 ++++++++++++++++++++-------------
> 1 file changed, 86 insertions(+), 56 deletions(-)
>
> diff --git a/generated_tests/gen_cl_vstore_tests.py b/generated_tests/gen_cl_vstore_tests.py
> index 93038aded..22b64d94b 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,21 +63,30 @@ 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
> +
> 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} 0x1.deadp0
> + arg_in: 0 buffer {mem_type}[{size}] {offset_size_zeros} 0x1.deadp0
> 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,
> + arg_out: 0 buffer {mem_type}[{offset_size}] {offset_zeros} {gen_array} {padd_zeros} {gen_array} 0x1.deadp0
> + arg_in: 0 buffer {mem_type}[{offset_size}] {offset_modsize_size_zeros} 0x1.deadp0
> + 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)))
>
> f.write(textwrap.dedent("""
> @@ -94,124 +103,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__':
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 833 bytes
Desc: This is a digitally signed message part
URL: <https://lists.freedesktop.org/archives/piglit/attachments/20171005/6683ba90/attachment.sig>
More information about the Piglit
mailing list