cl: Generate aligned vloada tests

Signed-off-by: Jan Vesely <jan.vesely@rutgers.edu>

1 files changed, 64 insertions, 44 deletions

diff --git a/generated_tests/gen_cl_vload_tests.py b/generated_tests/gen_cl_vload_tests.py
index 64415c57f..46410904d 100644
--- a/generated_tests/gen_cl_vload_tests.py
+++ b/generated_tests/gen_cl_vload_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", "vload")
 
@@ -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, "vload{}-{}-{}.cl".format(suffix, type_name, addr_space))
     print(file_name)
     f = open(file_name, 'w')
     f.write(textwrap.dedent(("""\
     /*!
     [config]
-    name: Vector load{suffix} {addr_space} {type_name}2,4,8,16
-    clc_version_min: 10
+    name: Vector load{suffix} {addr_space} {type_name}2,3,4,8,16
+    clc_version_min: 11
 
     dimensions: 1
     global_size: 1 0 0
@@ -63,25 +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
+        outsize = size if aligned else 1
+
         data_array = gen_array(size)
         ty_name = type_name + s
         f.write(textwrap.dedent("""
         [test]
         name: vector load{suffix} {addr_space} {type_name}
         kernel_name: vload{suffix}{n}_{addr_space}
-        arg_in:  0 buffer {mem_type}[{size}] 0 {gen_array}
+        arg_in:  0 buffer {mem_type}[{size}] {zeros1}{gen_array}
         arg_out: 1 buffer {type_name}[2] {first_array} {gen_array}
 
         [test]
         name: vector load{suffix} {addr_space} offset {type_name}
         kernel_name: vload{suffix}{n}_{addr_space}_offset
-        arg_in:  0 buffer {mem_type}[{offset_size}] {zeros}{gen_array}
+        arg_in:  0 buffer {mem_type}[{offset_size}] {zeros2}{gen_array}
         arg_out: 1 buffer {type_name}[2] {first_array} {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,
+        """.format(type_name=ty_name, mem_type=mem_type, size=size + offset,
+                   zeros1 = ("0 " * offset), zeros2=("0 " * (modsize + offset)),
+                   offset_size=size + modsize + offset, n=s,
                    gen_array=' '.join(data_array), suffix=suffix,
                    addr_space=addr_space,
-                   first_array="0 " + ' '.join(data_array[:-1]))))
+                   first_array=("0 " * outsize) + ' '.join(data_array[:-outsize]))))
 
     f.write(textwrap.dedent("""
     !*/
@@ -97,32 +102,38 @@ def begin_test(suffix, type_name, mem_type, vec_sizes, addr_space):
     return f
 
 
-def gen_test_constant_global(suffix, t, mem_type, vec_sizes, addr_space):
-    f = begin_test(suffix, t, mem_type, vec_sizes, addr_space)
+def gen_test_constant_global(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:
+        offset = int(s) if aligned else 1
+        offset = 4 if offset == 3 else offset
+
         type_name = t + s
         f.write(textwrap.dedent("""
         kernel void vload{suffix}{n}_{addr_space}({addr_space} {mem_type} *in,
                                      global {type_name} *out) {{
             out[0] = vload{suffix}{n}(0, in);
-            out[1] = vload{suffix}{n}(0, in + 1);
+            out[1] = vload{suffix}{n}(0, in + {offset});
         }}
 
         kernel void vload{suffix}{n}_{addr_space}_offset({addr_space} {mem_type} *in,
                                             global {type_name} *out) {{
             out[0] = vload{suffix}{n}(1, in);
-            out[1] = vload{suffix}{n}(1, in + 1);
+            out[1] = vload{suffix}{n}(1, in + {offset});
         }}
         """.format(type_name=type_name, mem_type=mem_type, n=s, suffix=suffix,
-                   addr_space=addr_space)))
+                   addr_space=addr_space, 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 else size
+        offset = modsize if aligned else 1
+
         type_name = t + s
         f.write(textwrap.dedent("""
         kernel void vload{suffix}{n}_{addr_space}(global {mem_type} *in,
@@ -132,7 +143,7 @@ def gen_test_local_private(suffix, t, mem_type, vec_sizes, addr_space):
                 loc[i] = in[i];
 
             out[0] = vload{suffix}{n}(0, ({addr_space} {mem_type}*)loc);
-            out[1] = vload{suffix}{n}(0, ({addr_space} {mem_type}*)loc + 1);
+            out[1] = vload{suffix}{n}(0, ({addr_space} {mem_type}*)loc + {offset});
         }}
 
         kernel void vload{suffix}{n}_{addr_space}_offset(global {mem_type} *in,
@@ -142,20 +153,24 @@ def gen_test_local_private(suffix, t, mem_type, vec_sizes, addr_space):
                 loc[i] = in[i];
 
             out[0] = vload{suffix}{n}(1, ({addr_space} {mem_type}*)loc);
-            out[1] = vload{suffix}{n}(1, ({addr_space} {mem_type}*)loc + 1);
+            out[1] = vload{suffix}{n}(1, ({addr_space} {mem_type}*)loc + {offset});
         }}
         """.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()
 
 
 # vload_half is special, becuase 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 else size
+        offset = modsize if aligned else 1
+
         type_name = t + s
         f.write(textwrap.dedent("""
         kernel void vload{suffix}{n}_{addr_space}(global half *in,
@@ -165,7 +180,7 @@ def gen_test_local_private_half(suffix, t, vec_sizes, addr_space):
                 loc[i] = ((global short *)in)[i];
 
             out[0] = vload{suffix}{n}(0, ({addr_space} half*)loc);
-            out[1] = vload{suffix}{n}(0, ({addr_space} half*)loc + 1);
+            out[1] = vload{suffix}{n}(0, ({addr_space} half*)loc + {offset});
         }}
 
         kernel void vload{suffix}{n}_{addr_space}_offset(global half *in,
@@ -175,47 +190,52 @@ def gen_test_local_private_half(suffix, t, vec_sizes, addr_space):
                 loc[i] = ((global short *)in)[i];
 
             out[0] = vload{suffix}{n}(1, ({addr_space} half*)loc);
-            out[1] = vload{suffix}{n}(1, ({addr_space} half*)loc + 1);
+            out[1] = vload{suffix}{n}(1, ({addr_space} half*)loc + {offset});
         }}
         """.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 gen_test_global(suffix, t, mem_type, vec_sizes):
-    gen_test_constant_global(suffix, t, mem_type, vec_sizes, 'global')
+def gen_test_global(suffix, t, mem_type, vec_sizes, aligned):
+    gen_test_constant_global(suffix, t, mem_type, vec_sizes, 'global', aligned)
 
 
-def gen_test_constant(suffix, t, mem_type, vec_sizes):
-    gen_test_constant_global(suffix, t, mem_type, vec_sizes, 'constant')
+def gen_test_constant(suffix, t, mem_type, vec_sizes, aligned):
+    gen_test_constant_global(suffix, t, mem_type, vec_sizes, 'constant', aligned)
 
 
 def main():
     utils.safe_makedirs(DIR_NAME)
     for t in TYPES:
-        gen_test_constant('', t, t, VEC_SIZES);
-        gen_test_global('', t, t, VEC_SIZES);
-        gen_test_local('', t, t, VEC_SIZES);
-        gen_test_private('', t, t, VEC_SIZES);
-
-    # There's no vload_half for double type
-    gen_test_constant('_half', 'float',  'half', [''] + VEC_SIZES);
-    gen_test_global('_half', 'float',  'half', [''] + VEC_SIZES);
-    gen_test_local('_half', 'float',  'half', [''] + VEC_SIZES);
-    gen_test_private('_half', 'float',  'half', [''] + VEC_SIZES);
+        gen_test_constant('', t, t, VEC_SIZES, False);
+        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;
+
+        # There's no vload_half for double type
+        gen_test_constant(suffix, 'float',  'half', vec_sizes, aligned);
+        gen_test_global(suffix, 'float',  'half', vec_sizes, aligned);
+        gen_test_local(suffix, 'float',  'half', vec_sizes, aligned);
+        gen_test_private(suffix, 'float',  'half', vec_sizes, aligned);
 
 
 if __name__ == '__main__':