New subgroups - full changes set (#1074)

* Extended subgroups - extended types types

* Extended subgroups - non uniform vote tests

* Extended subgroups - non uniform arithmetic tests

* Extended subgroups - ballot tests

* Extended subgroups - clustered reduce tests

* Extended subgroups - shuffle tests

* Extended subgroups - formating issues

* Extended subgroups - review fixes

* Extended subgroups - review fixes

Fixed: removed additional brakes, kernel_sstr

* Extended subgroups - fix macos build error

* Extended subgroups - review fixes

Fixed: mac os build error

* Extended subgroups - data type verification example

* Extended subgroups - error unification

* Extended subgroups - fix header years

* Extended subgroups - use is_half_nan

* Extended subgroups - compare half as float

* Review fixes mostly for ballot functions.

- Modify kernels for better handling active/inactive workitems
- Modify gen/chk functions for handling non uniform workgroup sizes
- Introduce new variables naming convention
- minor fixes

* Extended subgroups - simplification data generation for ballot lsb/msb functions

* Extended subgroups - minor fixes

* Extended subgroups - move common code to function

* Extended subgroups - formatting errors fix

* Extended subgroups - fix build error

* Extended subgroups - sub_group_elect more sophisticated

Define mask which is 4bytes pattern where bit 1 means work item is active.
If workitem in subgroup matches pattern then run sub_group_elect()

* Extended subgroups - fix Ubuntu build error

* Extended subgroups - voting function review fixes

* adjust all function for using masks
* remove calculate templates
* merge code to one common template
* check results only in active workitems
* normalize values on host side
* minor fixes

* Extended subgroups - fix typos

* Set of fixes and improvements after review

* define WorkGroupParams to stop extended parameters list in function
* better workitems mask handing (WorkGroupParams)
* narrow values of data input generation to avoid overflows (arithmetic func)
* implement work item masks for arithmetic functions
* enable half type testing for reduction/scan/broadcast
* minor fixes

* Extended subgroups - fix Linux issues

* Extended subgroups - fix sub_group_local_id data type

* Extended subgroups - use vector instead of array.

* Extended subgroups - change names to subgroup

* Extended subgroups - uncomment code, fix build

* Extended subgroups - build fix, use cl_half_from_float func

* Extended subgroups - remove is_half_nan

* Extended subgroups - do no use undef min/max

* Extended subgroups - use parenthesis, fix formatting

test_conformance/subgroups/test_subgroup_shuffle_relative.cpp

@@ -0,0 +1,81 @@
+//
+// Copyright (c) 2021 The Khronos Group Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "procs.h"
+#include "subhelpers.h"
+#include "subgroup_common_templates.h"
+#include "harness/conversions.h"
+#include "harness/typeWrappers.h"
+
+namespace {
+
+static const char* shuffle_down_source =
+    "__kernel void test_sub_group_shuffle_down(const __global Type *in, "
+    "__global int4 *xy, __global Type *out)\n"
+    "{\n"
+    "    int gid = get_global_id(0);\n"
+    "    XY(xy,gid);\n"
+    "    Type x = in[gid];\n"
+    "    out[gid] = sub_group_shuffle_down(x, xy[gid].z);"
+    "}\n";
+static const char* shuffle_up_source =
+    "__kernel void test_sub_group_shuffle_up(const __global Type *in, __global "
+    "int4 *xy, __global Type *out)\n"
+    "{\n"
+    "    int gid = get_global_id(0);\n"
+    "    XY(xy,gid);\n"
+    "    Type x = in[gid];\n"
+    "    out[gid] = sub_group_shuffle_up(x, xy[gid].z);"
+    "}\n";
+
+template <typename T> int run_shuffle_relative_for_type(RunTestForType rft)
+{
+    int error = rft.run_impl<T, SHF<T, ShuffleOp::shuffle_up>>(
+        "test_sub_group_shuffle_up", shuffle_up_source);
+    error |= rft.run_impl<T, SHF<T, ShuffleOp::shuffle_down>>(
+        "test_sub_group_shuffle_down", shuffle_down_source);
+    return error;
+}
+
+}
+
+int test_subgroup_functions_shuffle_relative(cl_device_id device,
+                                             cl_context context,
+                                             cl_command_queue queue,
+                                             int num_elements)
+{
+    std::vector<std::string> required_extensions = {
+        "cl_khr_subgroup_shuffle_relative"
+    };
+    constexpr size_t global_work_size = 2000;
+    constexpr size_t local_work_size = 200;
+    WorkGroupParams test_params(global_work_size, local_work_size,
+                                required_extensions);
+    RunTestForType rft(device, context, queue, num_elements, test_params);
+
+    int error = run_shuffle_relative_for_type<cl_int>(rft);
+    error |= run_shuffle_relative_for_type<cl_uint>(rft);
+    error |= run_shuffle_relative_for_type<cl_long>(rft);
+    error |= run_shuffle_relative_for_type<cl_ulong>(rft);
+    error |= run_shuffle_relative_for_type<cl_short>(rft);
+    error |= run_shuffle_relative_for_type<cl_ushort>(rft);
+    error |= run_shuffle_relative_for_type<cl_char>(rft);
+    error |= run_shuffle_relative_for_type<cl_uchar>(rft);
+    error |= run_shuffle_relative_for_type<cl_float>(rft);
+    error |= run_shuffle_relative_for_type<cl_double>(rft);
+    error |= run_shuffle_relative_for_type<subgroups::cl_half>(rft);
+
+    return error;
+}