Initial open source release of OpenCL 2.2 CTS.

test_conformance/workgroups/CMakeLists.txt

@@ -0,0 +1,26 @@
+set(MODULE_NAME WORKGROUPS)
+
+set(${MODULE_NAME}_SOURCES
+    main.c
+    test_wg_all.c
+    test_wg_any.c
+    test_wg_broadcast.c
+    test_wg_reduce.c
+    test_wg_reduce_max.c
+    test_wg_reduce_min.c
+    test_wg_scan_exclusive_add.c
+    test_wg_scan_exclusive_min.c
+    test_wg_scan_exclusive_max.c
+    test_wg_scan_inclusive_add.c
+    test_wg_scan_inclusive_min.c
+    test_wg_scan_inclusive_max.c
+    ../../test_common/harness/errorHelpers.c
+    ../../test_common/harness/testHarness.c
+    ../../test_common/harness/kernelHelpers.c
+    ../../test_common/harness/mt19937.c
+    ../../test_common/harness/msvc9.c
+    ../../test_common/harness/conversions.c
+    ../../test_common/harness/parseParameters.cpp
+)
+
+include(../CMakeCommon.txt)

test_conformance/workgroups/Makefile

@@ -0,0 +1,50 @@
+ifdef BUILD_WITH_ATF
+ATF = -framework ATF
+USE_ATF = -DUSE_ATF
+endif
+
+SRCS = main.c \
+		  test_wg_all.c \
+		  test_wg_any.c \
+		  test_wg_reduce.c \
+		  test_wg_reduce_min.c \
+		  test_wg_reduce_max.c \
+		  test_wg_scan_inclusive_add.c \
+		  test_wg_scan_exclusive_add.c \
+		  test_wg_broadcast.c \
+		  ../../test_common/harness/errorHelpers.c \
+		  ../../test_common/harness/threadTesting.c \
+		  ../../test_common/harness/testHarness.c \
+		  ../../test_common/harness/conversions.c \
+		  ../../test_common/harness/mt19937.c \
+		  ../../test_common/harness/kernelHelpers.c
+		  
+DEFINES = 
+
+SOURCES = $(abspath $(SRCS))
+LIBPATH += -L/System/Library/Frameworks/OpenCL.framework/Libraries
+LIBPATH += -L.
+FRAMEWORK = $(SOURCES)
+HEADERS = 
+TARGET = test_workgroup_fns
+INCLUDE = 
+COMPILERFLAGS = -c -Wall -g -Wshorten-64-to-32 -Os
+CC = c++
+CFLAGS = $(COMPILERFLAGS) ${RC_CFLAGS} ${USE_ATF} $(DEFINES:%=-D%) $(INCLUDE)
+CXXFLAGS = $(COMPILERFLAGS) ${RC_CFLAGS} ${USE_ATF} $(DEFINES:%=-D%) $(INCLUDE)
+LIBRARIES = -framework OpenCL -framework OpenGL -framework GLUT -framework AppKit ${ATF}
+
+OBJECTS := ${SOURCES:.c=.o}
+OBJECTS := ${OBJECTS:.cpp=.o}
+
+TARGETOBJECT =
+all: $(TARGET)
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(RC_CFLAGS) $(OBJECTS) -o $@ $(LIBPATH) $(LIBRARIES)
+
+clean:
+	rm -f $(TARGET) $(OBJECTS)
+
+.DEFAULT:
+	@echo The target \"$@\" does not exist in Makefile.

test_conformance/workgroups/main.c

@@ -0,0 +1,70 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include "procs.h"
+#include "../../test_common/harness/testHarness.h"
+#if !defined(_WIN32)
+#include <unistd.h>
+#endif
+
+basefn    basefn_list[] = {
+            test_work_group_all,
+            test_work_group_any,
+            test_work_group_reduce_add,
+            test_work_group_reduce_min,
+            test_work_group_reduce_max,
+            test_work_group_scan_inclusive_add,
+            test_work_group_scan_inclusive_min,
+            test_work_group_scan_inclusive_max,
+            test_work_group_scan_exclusive_add,
+            test_work_group_scan_exclusive_min,
+            test_work_group_scan_exclusive_max,
+            test_work_group_broadcast_1D,
+            test_work_group_broadcast_2D,
+            test_work_group_broadcast_3D,
+};
+
+
+const char    *basefn_names[] = {
+            "work_group_all",
+            "work_group_any",
+            "work_group_reduce_add",
+            "work_group_reduce_min",
+            "work_group_reduce_max",
+            "work_group_scan_inclusive_add",
+            "work_group_scan_inclusive_min",
+            "work_group_scan_inclusive_max",
+            "work_group_scan_exclusive_add",
+            "work_group_scan_exclusive_min",
+            "work_group_scan_exclusive_max",
+            "work_group_broadcast_1D",
+            "work_group_broadcast_2D",
+            "work_group_broadcast_3D",
+};
+
+ct_assert((sizeof(basefn_names) / sizeof(basefn_names[0])) == (sizeof(basefn_list) / sizeof(basefn_list[0])));
+
+int    num_fns = sizeof(basefn_names) / sizeof(char *);
+
+int main(int argc, const char *argv[])
+{
+    return runTestHarness( argc, argv, num_fns, basefn_list, basefn_names, false, false, 0 );
+}
+
+

test_conformance/workgroups/procs.h

@@ -0,0 +1,38 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/testHarness.h"
+#include "../../test_common/harness/kernelHelpers.h"
+#include "../../test_common/harness/errorHelpers.h"
+#include "../../test_common/harness/conversions.h"
+#include "../../test_common/harness/mt19937.h"
+
+extern int      create_program_and_kernel(const char *source, const char *kernel_name, cl_program *program_ret, cl_kernel *kernel_ret);
+
+extern int test_work_group_all(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_any(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_broadcast_1D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_broadcast_2D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_broadcast_3D(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_reduce_add(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_reduce_min(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_reduce_max(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+
+extern int test_work_group_scan_exclusive_add(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_scan_exclusive_min(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_scan_exclusive_max(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_scan_inclusive_add(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_scan_inclusive_min(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
+extern int test_work_group_scan_inclusive_max(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);

test_conformance/workgroups/testBase.h

@@ -0,0 +1,31 @@
+//
+// Copyright (c) 2017 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.
+//
+#ifndef _testBase_h
+#define _testBase_h
+
+#include "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+#endif // _testBase_h
+
+
+

test_conformance/workgroups/test_wg_all.c

@@ -0,0 +1,167 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_all_kernel_code =
+"__kernel void test_wg_all(global float *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_all((input[tid] > input[tid+1]));\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_all(float *inptr, int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        int predicate_all = 0xFFFFFFFF;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if (!(inptr[i+j] > inptr[i+j+1]))
+            {
+                predicate_all = 0;
+                break;
+            }
+        }
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( (predicate_all && (outptr[i+j] == 0)) ||
+                 ((predicate_all == 0) && outptr[i+j]) )
+            {
+                log_info("work_group_all: Error at %lu: expected = %d, got = %d\n", i+j, predicate_all, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int
+test_work_group_all(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_float     *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_all_kernel_code, "test_wg_all", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * (num_elements+1));
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * (num_elements+1));
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * (num_elements+1), NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<(num_elements+1); i++)
+    {
+        p[i] = get_random_float((float)(-100000.f * M_PI), (float)(100000.f * M_PI) ,d);
+    }
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_float)*(num_elements+1), (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_float)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_all(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_all test failed\n");
+        return -1;
+    }
+    log_info("work_group_all test passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+

test_conformance/workgroups/test_wg_any.c

@@ -0,0 +1,167 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_any_kernel_code =
+"__kernel void test_wg_any(global float *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_any((input[tid] > input[tid+1]));\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_any(float *inptr, int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        int predicate_any = 0x0;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if (inptr[i+j] > inptr[i+j+1])
+            {
+                predicate_any = 0xFFFFFFFF;
+                break;
+            }
+        }
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( (predicate_any && (outptr[i+j] == 0)) ||
+                 ((predicate_any == 0) && outptr[i+j]) )
+            {
+                log_info("work_group_any: Error at %lu: expected = %d, got = %d\n", i+j, predicate_any, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int
+test_work_group_any(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_float     *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_any_kernel_code, "test_wg_any", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * (num_elements+1));
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * (num_elements+1));
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * (num_elements+1), NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<(num_elements+1); i++)
+    {
+        p[i] = get_random_float((float)(-100000.f * M_PI), (float)(100000.f * M_PI) ,d);
+    }
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_float)*(num_elements+1), (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_float)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_any(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_any test failed\n");
+        return -1;
+    }
+    log_info("work_group_any test passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+

test_conformance/workgroups/test_wg_broadcast.c

@@ -0,0 +1,523 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_broadcast_1D_kernel_code =
+"__kernel void test_wg_broadcast_1D(global float *input, global float *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    float result = work_group_broadcast(input[tid], get_group_id(0) % get_local_size(0));\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_broadcast_2D_kernel_code =
+"__kernel void test_wg_broadcast_2D(global float *input, global float *output)\n"
+"{\n"
+"    size_t tid_x = get_global_id(0);\n"
+"    size_t tid_y = get_global_id(1);\n"
+"    size_t x = get_group_id(0) % get_local_size(0);\n"
+"    size_t y = get_group_id(1) % get_local_size(1);\n"
+"\n"
+"    size_t indx = (tid_y * get_global_size(0)) + tid_x;\n"
+"    float result = work_group_broadcast(input[indx], x, y);\n"
+"    output[indx] = result;\n"
+"}\n";
+
+const char *wg_broadcast_3D_kernel_code =
+"__kernel void test_wg_broadcast_3D(global float *input, global float *output)\n"
+"{\n"
+"    size_t tid_x = get_global_id(0);\n"
+"    size_t tid_y = get_global_id(1);\n"
+"    size_t tid_z = get_global_id(2);\n"
+"    size_t x = get_group_id(0) % get_local_size(0);\n"
+"    size_t y = get_group_id(1) % get_local_size(1);\n"
+"    size_t z = get_group_id(2) % get_local_size(2);\n"
+"\n"
+"    size_t indx = (tid_z * get_global_size(1) * get_global_size(0)) + (tid_y * get_global_size(0)) + tid_x;\n"
+"    float result = work_group_broadcast(input[indx], x, y, z);\n"
+"    output[indx] = result;\n"
+"}\n";
+
+static int
+verify_wg_broadcast_1D(float *inptr, float *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+    size_t     group_id;
+
+    for (i=0,group_id=0; i<n; i+=wg_size,group_id++)
+    {
+        int local_size = (n-i) > wg_size ? wg_size : (n-i);
+        float broadcast_result = inptr[i + (group_id % local_size)];
+        for (j=0; j<local_size; j++)
+        {
+            if ( broadcast_result != outptr[i+j] )
+            {
+                log_info("work_group_broadcast: Error at %u: expected = %f, got = %f\n", i+j, broadcast_result, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_broadcast_2D(float *inptr, float *outptr, size_t nx, size_t ny, size_t wg_size_x, size_t wg_size_y)
+{
+    size_t i, j, _i, _j;
+    size_t group_id_x, group_id_y;
+
+    for (i=0,group_id_y=0; i<ny; i+=wg_size_y,group_id_y++)
+    {
+        size_t y = group_id_y % wg_size_y;
+        size_t local_size_y = (ny-i) > wg_size_y ? wg_size_y : (ny-i);
+        for (_i=0; _i < local_size_y; _i++)
+        {
+            for (j=0,group_id_x=0; j<nx; j+=wg_size_x,group_id_x++)
+            {
+                size_t x = group_id_x % wg_size_x;
+                size_t local_size_x = (nx-j) > wg_size_x ? wg_size_x : (nx-j);
+                float  broadcast_result = inptr[(i + y) * nx + (j + x)];
+                for (_j=0; _j < local_size_x; _j++)
+                {
+                    size_t indx = (i + _i) * nx + (j + _j);
+                    if ( broadcast_result != outptr[indx] )
+                    {
+                        log_info("work_group_broadcast: Error at (%u, %u): expected = %f, got = %f\n", j+_j, i+_i, broadcast_result, outptr[indx]);
+                        return -1;
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_broadcast_3D(float *inptr, float *outptr, size_t nx, size_t ny, size_t nz, size_t wg_size_x, size_t wg_size_y, size_t wg_size_z)
+{
+    size_t i, j, k, _i, _j, _k;
+    size_t group_id_x, group_id_y, group_id_z;
+
+    for (i=0,group_id_z=0; i<nz; i+=wg_size_z,group_id_z++)
+    {
+        size_t z = group_id_z % wg_size_z;
+        size_t local_size_z = (nz-i) > wg_size_z ? wg_size_z : (nz-i);
+        for (_i=0; _i < local_size_z; _i++)
+        {
+            for (j=0,group_id_y=0; j<ny; j+=wg_size_y,group_id_y++)
+            {
+                size_t y = group_id_y % wg_size_y;
+                size_t local_size_y = (ny-j) > wg_size_y ? wg_size_y : (ny-j);
+                for (_j=0; _j < local_size_y; _j++)
+                {
+                    for (k=0,group_id_x=0; k<nx; k+=wg_size_x,group_id_x++)
+                    {
+                        size_t x = group_id_x % wg_size_x;
+                        size_t local_size_x = (nx-k) > wg_size_x ? wg_size_x : (nx-k);
+                        float  broadcast_result = inptr[(i + z) * ny * nz + (j + y) * nx + (k + x)];
+                        for (_k=0; _k < local_size_x; _k++)
+                        {
+                            size_t indx = (i + _i) * ny * nx + (j + _j) * nx + (k + _k);
+                            if ( broadcast_result != outptr[indx] )
+                            {
+                                log_info("work_group_broadcast: Error at (%u, %u, %u): expected = %f, got = %f\n", k+_k, j+_j, i+_i, broadcast_result, outptr[indx]);
+                                return -1;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+int
+test_work_group_broadcast_1D(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_float     *input_ptr[1], *p;
+    cl_float     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       globalsize[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_broadcast_1D_kernel_code, "test_wg_broadcast_1D", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
+    output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+    {
+        p[i] = get_random_float((float)(-100000.f * M_PI), (float)(100000.f * M_PI) ,d);
+    }
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_float)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    globalsize[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, globalsize, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_float)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_float)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_broadcast_1D(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_broadcast_1D test failed\n");
+        return -1;
+    }
+    log_info("work_group_broadcast_1D test passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_broadcast_2D(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_float     *input_ptr[1], *p;
+    cl_float     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       globalsize[2];
+    size_t       localsize[2];
+    size_t       wg_size[1];
+    size_t       num_workgroups;
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_broadcast_2D_kernel_code, "test_wg_broadcast_2D", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    if (wg_size[0] >= 256)
+    {
+        localsize[0] = localsize[1] = 16;
+    }
+    else if (wg_size[0] >=64)
+    {
+        localsize[0] = localsize[1] = 8;
+    }
+    else if (wg_size[0] >= 16)
+    {
+        localsize[0] = localsize[1] = 4;
+    }
+    else
+    {
+        localsize[0] = localsize[1] = 1;
+    }
+
+    num_workgroups = MAX(n_elems/wg_size[0], 16);
+    globalsize[0] = num_workgroups * localsize[0];
+    globalsize[1] = num_workgroups * localsize[1];
+    num_elements = globalsize[0] * globalsize[1];
+
+    input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
+    output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+    {
+        p[i] = get_random_float((float)(-100000.f * M_PI), (float)(100000.f * M_PI) ,d);
+    }
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_float)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    err = clEnqueueNDRangeKernel( queue, kernel, 2, NULL, globalsize, localsize, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_float)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_float)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_broadcast_2D(input_ptr[0], output_ptr, globalsize[0], globalsize[1], localsize[0], localsize[1]))
+    {
+        log_error("work_group_broadcast_2D test failed\n");
+        return -1;
+    }
+    log_info("work_group_broadcast_2D test passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_broadcast_3D(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_float     *input_ptr[1], *p;
+    cl_float     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       globalsize[3];
+    size_t       localsize[3];
+    size_t       wg_size[1];
+    size_t       num_workgroups;
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_broadcast_3D_kernel_code, "test_wg_broadcast_3D", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    if (wg_size[0] >=512)
+    {
+        localsize[0] = localsize[1] = localsize[2] = 8;
+    }
+    else if (wg_size[0] >= 64)
+    {
+        localsize[0] = localsize[1] = localsize[2] = 4;
+    }
+    else if (wg_size[0] >= 8)
+    {
+        localsize[0] = localsize[1] = localsize[2] = 2;
+    }
+    else
+    {
+        localsize[0] = localsize[1] = localsize[2] = 1;
+    }
+
+    num_workgroups = MAX(n_elems/wg_size[0], 8);
+    globalsize[0] = num_workgroups * localsize[0];
+    globalsize[1] = num_workgroups * localsize[1];
+    globalsize[2] = num_workgroups * localsize[2];
+    num_elements = globalsize[0] * globalsize[1] * globalsize[2];
+
+    input_ptr[0] = (cl_float*)malloc(sizeof(cl_float) * num_elements);
+    output_ptr = (cl_float*)malloc(sizeof(cl_float) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_float) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+    {
+        p[i] = get_random_float((float)(-100000.f * M_PI), (float)(100000.f * M_PI) ,d);
+    }
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_float)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    err = clEnqueueNDRangeKernel( queue, kernel, 3, NULL, globalsize, localsize, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_float)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_float)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_broadcast_3D(input_ptr[0], output_ptr, globalsize[0], globalsize[1], globalsize[2], localsize[0], localsize[1], localsize[2]))
+    {
+        log_error("work_group_broadcast_3D test failed\n");
+        return -1;
+    }
+    log_info("work_group_broadcast_3D test passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_broadcast(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_broadcast_1D(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_broadcast_2D(device, context, queue, n_elems);
+    if (err) return err;
+    return err;
+}
+
+

test_conformance/workgroups/test_wg_reduce.c

@@ -0,0 +1,580 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_reduce_add_kernel_code_int =
+"__kernel void test_wg_reduce_add_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_reduce_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_reduce_add_kernel_code_uint =
+"__kernel void test_wg_reduce_add_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_reduce_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_reduce_add_kernel_code_long =
+"__kernel void test_wg_reduce_add_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_reduce_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_reduce_add_kernel_code_ulong =
+"__kernel void test_wg_reduce_add_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_reduce_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_reduce_add_int(int *inptr, int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        int sum = 0;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            sum += inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( sum != outptr[i+j] )
+            {
+                log_info("work_group_reduce_add int: Error at %u: expected = %d, got = %d\n", i+j, sum, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_add_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        unsigned int sum = 0;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            sum += inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( sum != outptr[i+j] )
+            {
+                log_info("work_group_reduce_add uint: Error at %u: expected = %d, got = %d\n", i+j, sum, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_add_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        cl_long sum = 0;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            sum += inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( sum != outptr[i+j] )
+            {
+                log_info("work_group_reduce_add long: Error at %u: expected = %lld, got = %lld\n", i+j, sum, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_add_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        cl_ulong sum = 0;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            sum += inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( sum != outptr[i+j] )
+            {
+                log_info("work_group_reduce_add ulong: Error at %u: expected = %llu, got = %llu\n", i+j, sum, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+
+int
+test_work_group_reduce_add_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_add_kernel_code_int, "test_wg_reduce_add_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_add_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_add int failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_add int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_add_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_add_kernel_code_uint, "test_wg_reduce_add_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_add_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_add uint failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_add uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_reduce_add_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_add_kernel_code_long, "test_wg_reduce_add_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_add_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_add long failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_add long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_add_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_add_kernel_code_ulong, "test_wg_reduce_add_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_add_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_add ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_add ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_add(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_reduce_add_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_add_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_add_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_add_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_reduce_max.c

@@ -0,0 +1,580 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_reduce_max_kernel_code_int =
+"__kernel void test_wg_reduce_max_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_reduce_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_reduce_max_kernel_code_uint =
+"__kernel void test_wg_reduce_max_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_reduce_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_reduce_max_kernel_code_long =
+"__kernel void test_wg_reduce_max_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_reduce_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_reduce_max_kernel_code_ulong =
+"__kernel void test_wg_reduce_max_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_reduce_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_reduce_max_int(int *inptr, int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        int max = CL_INT_MIN;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            max = (max > inptr[i+j]) ? max : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( max != outptr[i+j] )
+            {
+                log_info("work_group_reduce_max int: Error at %u: expected = %d, got = %d\n", i+j, max, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_max_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        unsigned int max = 0;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            max = (max > inptr[i+j]) ? max : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( max != outptr[i+j] )
+            {
+                log_info("work_group_reduce_max uint: Error at %u: expected = %d, got = %d\n", i+j, max, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_max_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        cl_long max = CL_LONG_MIN;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            max = (max > inptr[i+j]) ? max : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( max != outptr[i+j] )
+            {
+                log_info("work_group_reduce_max long: Error at %u: expected = %lld, got = %lld\n", i+j, max, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_max_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        cl_ulong max = 0;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            max = (max > inptr[i+j]) ? max : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( max != outptr[i+j] )
+            {
+                log_info("work_group_reduce_max ulong: Error at %u: expected = %llu, got = %llu\n", i+j, max, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+
+int
+test_work_group_reduce_max_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_max_kernel_code_int, "test_wg_reduce_max_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_max_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_max int failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_max int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_max_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_max_kernel_code_uint, "test_wg_reduce_max_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_max_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_max uint failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_max uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_reduce_max_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_max_kernel_code_long, "test_wg_reduce_max_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_max_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_max long failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_max long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_max_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_max_kernel_code_ulong, "test_wg_reduce_max_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_max_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_max ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_max ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_max(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_reduce_max_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_max_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_max_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_max_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_reduce_min.c

@@ -0,0 +1,580 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_reduce_min_kernel_code_int =
+"__kernel void test_wg_reduce_min_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_reduce_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_reduce_min_kernel_code_uint =
+"__kernel void test_wg_reduce_min_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_reduce_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_reduce_min_kernel_code_long =
+"__kernel void test_wg_reduce_min_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_reduce_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_reduce_min_kernel_code_ulong =
+"__kernel void test_wg_reduce_min_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_reduce_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_reduce_min_int(int *inptr, int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        int min = CL_INT_MAX;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            min = (min < inptr[i+j]) ? min : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( min != outptr[i+j] )
+            {
+                log_info("work_group_reduce_min int: Error at %u: expected = %d, got = %d\n", i+j, min, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_min_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        unsigned int min = CL_UINT_MAX;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            min = (min < inptr[i+j]) ? min : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( min != outptr[i+j] )
+            {
+                log_info("work_group_reduce_min uint: Error at %u: expected = %d, got = %d\n", i+j, min, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_min_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        cl_long min = CL_ULONG_MAX;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            min = (min < inptr[i+j]) ? min : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( min != outptr[i+j] )
+            {
+                log_info("work_group_reduce_min long: Error at %u: expected = %lld, got = %lld\n", i+j, min, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_reduce_min_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size)
+{
+    size_t     i, j;
+
+    for (i=0; i<n; i+=wg_size)
+    {
+        cl_ulong min = CL_ULONG_MAX;
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+            min = (min < inptr[i+j]) ? min : inptr[i+j];
+
+        for (j=0; j<((n-i) > wg_size ? wg_size : (n-i)); j++)
+        {
+            if ( min != outptr[i+j] )
+            {
+                log_info("work_group_reduce_min ulong: Error at %u: expected = %llu, got = %llu\n", i+j, min, outptr[i+j]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+
+int
+test_work_group_reduce_min_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_min_kernel_code_int, "test_wg_reduce_min_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_min_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_min int failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_min int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_min_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_min_kernel_code_uint, "test_wg_reduce_min_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_min_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_min uint failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_min uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_reduce_min_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_min_kernel_code_long, "test_wg_reduce_min_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_min_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_min long failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_min long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_min_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_reduce_min_kernel_code_ulong, "test_wg_reduce_min_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_reduce_min_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_reduce_min ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_reduce_min ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_reduce_min(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_reduce_min_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_min_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_min_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_reduce_min_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_scan_exclusive_add.c

@@ -0,0 +1,588 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_scan_exclusive_add_kernel_code_int =
+"__kernel void test_wg_scan_exclusive_add_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_scan_exclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_exclusive_add_kernel_code_uint =
+"__kernel void test_wg_scan_exclusive_add_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_scan_exclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_scan_exclusive_add_kernel_code_long =
+"__kernel void test_wg_scan_exclusive_add_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_scan_exclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_exclusive_add_kernel_code_ulong =
+"__kernel void test_wg_scan_exclusive_add_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_scan_exclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_scan_exclusive_add_int(int *inptr, int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+    int s, lasts;
+
+
+
+    for (j = 0; j < n; j += wg_size) {
+        m = n - j;
+        if (m > wg_size) m = wg_size;
+
+        s = 0;
+        lasts = 0;
+        for (i = 0; i < m; ++i) {
+            s += inptr[j + i];
+            if (outptr[j + i] != lasts) {
+                log_info("work_group_scan_exclusive_add int: Error at %u: expected = %d, got = %d\n",
+                         (unsigned int)(j + i), lasts, outptr[j + i]);
+                return -1;
+            }
+            lasts = s;
+        }
+    }
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_add_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+    unsigned int s, lasts;
+
+    for (j = 0; j < n; j += wg_size) {
+        m = n - j;
+        if (m > wg_size) m = wg_size;
+        s = 0;
+        lasts = 0;
+        for (i = 0; i < m; ++i) {
+            s += inptr[j + i];
+            if (outptr[j + i] != lasts) {
+                log_info("work_group_scan_exclusive_add uint: Error at %u: expected = %u, got = %u\n",
+                        (unsigned int)(j + i), lasts, outptr[j + i]);
+                return -1;
+            }
+            lasts = s;
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_add_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+    cl_long s, lasts;
+
+    for (j = 0; j < n; j += wg_size) {
+        m = n - j;
+        if (m > wg_size) m = wg_size;
+        s = 0;
+
+        lasts = 0;
+        for (i = 0; i < m; ++i) {
+            s += inptr[j + i];
+
+            if (outptr[j + i] != lasts) {
+                log_info("work_group_scan_exclusive_add long: Error at %u: expected = %lld, got = %lld\n",
+                         (unsigned int)(j + i), (long long)lasts, (long long)outptr[j + i]);
+                return -1;
+            }
+            lasts = s;
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_add_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    cl_ulong s, lasts;
+
+    for (j = 0; j < n; j += wg_size) {
+        m = n - j;
+        if (m > wg_size) m = wg_size;
+
+        s = 0;
+        lasts = 0;
+        for (i = 0; i < m; ++i) {
+            s += inptr[j + i];
+            if (outptr[j + i] != lasts) {
+                log_info("work_group_scan_exclusive_add ulong: Error at %u: expected = %llu, got = %llu\n",
+                         (unsigned int)(j + i), (unsigned long long)lasts, (unsigned long long)outptr[j + i]);
+                return -1;
+            }
+            lasts = s;
+        }
+    }
+    return 0;
+}
+
+
+int
+test_work_group_scan_exclusive_add_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_add_kernel_code_int, "test_wg_scan_exclusive_add_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_add_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_add int failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_add int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_add_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_add_kernel_code_uint, "test_wg_scan_exclusive_add_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_add_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_add uint failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_add uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_scan_exclusive_add_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_add_kernel_code_long, "test_wg_scan_exclusive_add_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_add_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_add long failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_add long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_add_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_add_kernel_code_ulong, "test_wg_scan_exclusive_add_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_add_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusiveadd ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_add ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_add(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_scan_exclusive_add_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_add_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_add_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_add_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_scan_exclusive_max.c

@@ -0,0 +1,579 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_scan_exclusive_max_kernel_code_int =
+"__kernel void test_wg_scan_exclusive_max_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_scan_exclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_exclusive_max_kernel_code_uint =
+"__kernel void test_wg_scan_exclusive_max_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_scan_exclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_scan_exclusive_max_kernel_code_long =
+"__kernel void test_wg_scan_exclusive_max_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_scan_exclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_exclusive_max_kernel_code_ulong =
+"__kernel void test_wg_scan_exclusive_max_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_scan_exclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_scan_exclusive_max_int(int *inptr, int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        int max_ = 0x80000000;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_exclusive_max int: Error at %u: expected = %d, got = %d\n", (unsigned int)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+            max_ = MAX(inptr[j+i], max_);
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_max_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        unsigned int max_ = 0x0;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_exclusive_max int: Error at %u: expected = %u, got = %u\n", (unsigned int)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+            max_ = MAX(inptr[j+i], max_);
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_max_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        cl_long max_ = 0x8000000000000000ULL;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_exclusive_max long: Error at %u: expected = %lld, got = %lld\n", (unsigned int)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+            max_ = MAX(inptr[j+i], max_);
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_max_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        cl_ulong max_ = 0x0;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_exclusive_max ulong: Error at %u: expected = %llu, got = %llu\n", (unsigned int)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+            max_ = MAX(inptr[j+i], max_);
+        }
+    }
+
+    return 0;
+}
+
+
+int
+test_work_group_scan_exclusive_max_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_max_kernel_code_int, "test_wg_scan_exclusive_max_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_max_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_max int failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_max int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_max_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_max_kernel_code_uint, "test_wg_scan_exclusive_max_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_max_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_max uint failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_max uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_scan_exclusive_max_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_max_kernel_code_long, "test_wg_scan_exclusive_max_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_max_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_max long failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_max long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_max_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_max_kernel_code_ulong, "test_wg_scan_exclusive_max_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_max_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusiveadd ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_max ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_max(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_scan_exclusive_max_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_max_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_max_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_max_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_scan_exclusive_min.c

@@ -0,0 +1,580 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_scan_exclusive_min_kernel_code_int =
+"__kernel void test_wg_scan_exclusive_min_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_scan_exclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_exclusive_min_kernel_code_uint =
+"__kernel void test_wg_scan_exclusive_min_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_scan_exclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_scan_exclusive_min_kernel_code_long =
+"__kernel void test_wg_scan_exclusive_min_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_scan_exclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_exclusive_min_kernel_code_ulong =
+"__kernel void test_wg_scan_exclusive_min_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_scan_exclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+
+static int
+verify_wg_scan_exclusive_min_int(int *inptr, int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        int min_ = 0x7fffffff;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_exclusive_min int: Error at %u: expected = %d, got = %d\n", (unsigned int)(j+i), min_, outptr[j+i]);
+                return -1;
+            }
+            min_ = MIN(inptr[j+i], min_);
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_min_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        unsigned int min_ = 0xffffffff;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_exclusive_min int: Error at %u: expected = %u, got = %u\n", j+i, min_, outptr[j+i]);
+                return -1;
+            }
+            min_ = MIN(inptr[j+i], min_);
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_min_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        cl_long min_ = 0x7fffffffffffffffULL;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_exclusive_min long: Error at %u: expected = %lld, got = %lld\n", (unsigned int)(j+i), min_, outptr[j+i]);
+                return -1;
+            }
+            min_ = MIN(inptr[j+i], min_);
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_exclusive_min_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+     for (j=0; j<n; j+=wg_size) {
+        cl_ulong min_ = 0xffffffffffffffffULL;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_exclusive_min ulong: Error at %u: expected = %llu, got = %llu\n", (unsigned int)(j+i), min_, outptr[j+i]);
+                return -1;
+            }
+            min_ = MIN(inptr[j+i], min_);
+        }
+    }
+
+    return 0;
+}
+
+
+int
+test_work_group_scan_exclusive_min_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_min_kernel_code_int, "test_wg_scan_exclusive_min_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_min_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_min int failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_min int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_min_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_min_kernel_code_uint, "test_wg_scan_exclusive_min_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_min_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_min uint failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_min uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_scan_exclusive_min_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_min_kernel_code_long, "test_wg_scan_exclusive_min_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_min_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusive_min long failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_min long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_min_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_exclusive_min_kernel_code_ulong, "test_wg_scan_exclusive_min_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_exclusive_min_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_exclusiveadd ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_exclusive_min ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_exclusive_min(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_scan_exclusive_min_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_min_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_min_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_exclusive_min_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_scan_inclusive_add.c

@@ -0,0 +1,577 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_scan_inclusive_add_kernel_code_int =
+"__kernel void test_wg_scan_inclusive_add_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_scan_inclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_inclusive_add_kernel_code_uint =
+"__kernel void test_wg_scan_inclusive_add_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_scan_inclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_scan_inclusive_add_kernel_code_long =
+"__kernel void test_wg_scan_inclusive_add_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_scan_inclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_inclusive_add_kernel_code_ulong =
+"__kernel void test_wg_scan_inclusive_add_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_scan_inclusive_add(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_scan_inclusive_add_int(int *inptr, int *outptr, size_t n, size_t wg_size)
+{
+    size_t i, j, m;
+    int s;
+
+    for (j=0; j<n; j+=wg_size) {
+    m = n - j;
+    if (m > wg_size)
+        m = wg_size;
+
+    s = 0;
+    for (i=0; i<m; ++i) {
+        s += inptr[j+i];
+        if (outptr[j+i] != s) {
+                log_info("work_group_scan_inclusive_add int: Error at %u: expected = %d, got = %d\n", (unsigned int)(j+i), s, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_add_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size)
+{
+    size_t i, j, m;
+    unsigned int s;
+
+    for (j=0; j<n; j+=wg_size) {
+    m = n - j;
+    if (m > wg_size)
+        m = wg_size;
+
+    s = 0;
+    for (i=0; i<m; ++i) {
+        s += inptr[j+i];
+        if (outptr[j+i] != s) {
+                log_info("work_group_scan_inclusive_add uint: Error at %u: expected = %u, got = %u\n", (unsigned int)(j+i), s, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_add_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size)
+{
+    size_t i, j, m;
+    cl_long s;
+
+    for (j=0; j<n; j+=wg_size) {
+    m = n - j;
+    if (m > wg_size)
+        m = wg_size;
+
+    s = 0;
+    for (i=0; i<m; ++i) {
+        s += inptr[j+i];
+        if (outptr[j+i] != s) {
+                log_info("work_group_scan_inclusive_add long: Error at %u: expected = %lld, got = %lld\n",
+            (unsigned int)(j+i), (long long)s, (long long)outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_add_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size)
+{
+    size_t i, j, m;
+    cl_ulong s;
+
+    for (j=0; j<n; j+=wg_size) {
+    m = n - j;
+    if (m > wg_size)
+        m = wg_size;
+
+    s = 0;
+    for (i=0; i<m; ++i) {
+        s += inptr[j+i];
+        if (outptr[j+i] != s) {
+                log_info("work_group_scan_inclusive_add int: Error at %u: expected = %llu, got = %llu\n",
+            (unsigned int)(j+i), (unsigned long long)s, (unsigned long long)outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+    return 0;
+}
+
+
+int
+test_work_group_scan_inclusive_add_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_add_kernel_code_int, "test_wg_scan_inclusive_add_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_add_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_add int failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_add int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_add_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_add_kernel_code_uint, "test_wg_scan_inclusive_add_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_add_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_add uint failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_add uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_scan_inclusive_add_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_add_kernel_code_long, "test_wg_scan_inclusive_add_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_add_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_add long failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_add long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_add_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_add_kernel_code_ulong, "test_wg_scan_inclusive_add_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_add_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusiveadd ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_add ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_add(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_scan_inclusive_add_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_add_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_add_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_add_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_scan_inclusive_max.c

@@ -0,0 +1,579 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_scan_inclusive_max_kernel_code_int =
+"__kernel void test_wg_scan_inclusive_max_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_scan_inclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_inclusive_max_kernel_code_uint =
+"__kernel void test_wg_scan_inclusive_max_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_scan_inclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_scan_inclusive_max_kernel_code_long =
+"__kernel void test_wg_scan_inclusive_max_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_scan_inclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_inclusive_max_kernel_code_ulong =
+"__kernel void test_wg_scan_inclusive_max_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_scan_inclusive_max(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_scan_inclusive_max_int(int *inptr, int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        int max_ = 0x80000000;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            max_ = MAX(inptr[j+i], max_);
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_inclusive_max int: Error at %u: expected = %d, got = %d\n", (unsigned int)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_max_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        unsigned int max_ = 0x0;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            max_ = MAX(inptr[j+i], max_);
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_inclusive_max int: Error at %lu: expected = %u, got = %u\n", (unsigned long)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_max_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        cl_long max_ = 0x8000000000000000ULL;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            max_ = MAX(inptr[j+i], max_);
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_inclusive_max long: Error at %u: expected = %lld, got = %lld\n", (unsigned int)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_max_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        cl_ulong max_ = 0x0;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            max_ = MAX(inptr[j+i], max_);
+            if (outptr[j+i] != max_) {
+                log_info("work_group_scan_inclusive_max ulong: Error at %u: expected = %llu, got = %llu\n", (unsigned int)(j+i), max_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+int
+test_work_group_scan_inclusive_max_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_max_kernel_code_int, "test_wg_scan_inclusive_max_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_max_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_max int failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_max int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_max_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_max_kernel_code_uint, "test_wg_scan_inclusive_max_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_max_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_max uint failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_max uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_scan_inclusive_max_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_max_kernel_code_long, "test_wg_scan_inclusive_max_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_max_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_max long failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_max long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_max_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_max_kernel_code_ulong, "test_wg_scan_inclusive_max_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_max_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusiveadd ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_max ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_max(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_scan_inclusive_max_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_max_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_max_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_max_ulong(device, context, queue, n_elems);
+    return err;
+}
+

test_conformance/workgroups/test_wg_scan_inclusive_min.c

@@ -0,0 +1,579 @@
+//
+// Copyright (c) 2017 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 "../../test_common/harness/compat.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "procs.h"
+
+
+const char *wg_scan_inclusive_min_kernel_code_int =
+"__kernel void test_wg_scan_inclusive_min_int(global int *input, global int *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    int result = work_group_scan_inclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_inclusive_min_kernel_code_uint =
+"__kernel void test_wg_scan_inclusive_min_uint(global uint *input, global uint *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    uint result = work_group_scan_inclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+const char *wg_scan_inclusive_min_kernel_code_long =
+"__kernel void test_wg_scan_inclusive_min_long(global long *input, global long *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    long result = work_group_scan_inclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+const char *wg_scan_inclusive_min_kernel_code_ulong =
+"__kernel void test_wg_scan_inclusive_min_ulong(global ulong *input, global ulong *output)\n"
+"{\n"
+"    int  tid = get_global_id(0);\n"
+"\n"
+"    ulong result = work_group_scan_inclusive_min(input[tid]);\n"
+"    output[tid] = result;\n"
+"}\n";
+
+
+static int
+verify_wg_scan_inclusive_min_int(int *inptr, int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        int min_ = 0x7fffffff;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            min_ = MIN(inptr[j+i], min_);
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_inclusive_min int: Error at %u: expected = %d, got = %d\n", (unsigned int)(j+i), min_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_min_uint(unsigned int *inptr, unsigned int *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        unsigned int min_ = 0xffffffff;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            min_ = MIN(inptr[j+i], min_);
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_inclusive_min int: Error at %u: expected = %u, got = %u\n", (unsigned int)(j+i), min_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_min_long(cl_long *inptr, cl_long *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+    for (j=0; j<n; j+=wg_size) {
+        cl_long min_ = 0x7fffffffffffffffULL;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            min_ = MIN(inptr[j+i], min_);
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_inclusive_min long: Error at %u: expected = %lld, got = %lld\n", (unsigned int)(j+i), min_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int
+verify_wg_scan_inclusive_min_ulong(cl_ulong *inptr, cl_ulong *outptr, size_t n, size_t wg_size) {
+
+    size_t i, j, m;
+
+     for (j=0; j<n; j+=wg_size) {
+        cl_ulong min_ = 0xffffffffffffffffULL;
+
+        m = n - j;
+        if (m > wg_size)
+            m = wg_size;
+
+        for (i = 0; i < m; ++i) {
+            min_ = MIN(inptr[j+i], min_);
+            if (outptr[j+i] != min_) {
+                log_info("work_group_scan_inclusive_min ulong: Error at %u: expected = %llu, got = %llu\n", (unsigned int)(j+i), min_, outptr[j+i]);
+                return -1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+
+int
+test_work_group_scan_inclusive_min_int(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_int       *input_ptr[1], *p;
+    cl_int       *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_min_kernel_code_int, "test_wg_scan_inclusive_min_int", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    output_ptr = (cl_int*)malloc(sizeof(cl_int) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_int) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_int) * num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)num_elements;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_int)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_int)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_min_int(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_min int failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_min int passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_min_uint(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_uint      *input_ptr[1], *p;
+    cl_uint      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_min_kernel_code_uint, "test_wg_scan_inclusive_min_uint", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    output_ptr = (cl_uint*)malloc(sizeof(cl_uint) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_uint) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int32(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_uint)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_uint)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_uint)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_min_uint(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_min uint failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_min uint passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+int
+test_work_group_scan_inclusive_min_long(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_long      *input_ptr[1], *p;
+    cl_long      *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_min_kernel_code_long, "test_wg_scan_inclusive_min_long", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    output_ptr = (cl_long*)malloc(sizeof(cl_long) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_long) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_long)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_long)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_long)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_min_long(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusive_min long failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_min long passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_min_ulong(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    cl_mem       streams[2];
+    cl_ulong     *input_ptr[1], *p;
+    cl_ulong     *output_ptr;
+    cl_program   program;
+    cl_kernel    kernel;
+    void         *values[2];
+    size_t       threads[1];
+    size_t       wg_size[1];
+    size_t       num_elements;
+    int          err;
+    int          i;
+    MTdata       d;
+
+    err = create_single_kernel_helper_with_build_options( context, &program, &kernel, 1, &wg_scan_inclusive_min_kernel_code_ulong, "test_wg_scan_inclusive_min_ulong", "-cl-std=CL2.0" );
+    if (err)
+        return -1;
+
+    err = clGetKernelWorkGroupInfo( kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), wg_size, NULL);
+    if (err)
+        return -1;
+
+    num_elements = n_elems;
+
+    input_ptr[0] = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    output_ptr = (cl_ulong*)malloc(sizeof(cl_ulong) * num_elements);
+    streams[0] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[0])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    streams[1] = clCreateBuffer( context, (cl_mem_flags)(CL_MEM_READ_WRITE),  sizeof(cl_ulong) * num_elements, NULL, NULL );
+    if (!streams[1])
+    {
+        log_error("clCreateBuffer failed\n");
+        return -1;
+    }
+
+    p = input_ptr[0];
+    d = init_genrand( gRandomSeed );
+    for (i=0; i<num_elements; i++)
+        p[i] = genrand_int64(d);
+    free_mtdata(d); d = NULL;
+
+    err = clEnqueueWriteBuffer( queue, streams[0], true, 0, sizeof(cl_ulong)*num_elements, (void *)input_ptr[0], 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clWriteArray failed\n");
+        return -1;
+    }
+
+    values[0] = streams[0];
+    values[1] = streams[1];
+    err = clSetKernelArg(kernel, 0, sizeof streams[0], &streams[0] );
+    err |= clSetKernelArg(kernel, 1, sizeof streams[1], &streams[1] );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clSetKernelArgs failed\n");
+        return -1;
+    }
+
+    // Line below is troublesome...
+    threads[0] = (size_t)n_elems;
+    err = clEnqueueNDRangeKernel( queue, kernel, 1, NULL, threads, wg_size, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueNDRangeKernel failed\n");
+        return -1;
+    }
+
+    cl_uint dead = 0xdeaddead;
+    memset_pattern4(output_ptr, &dead, sizeof(cl_ulong)*num_elements);
+    err = clEnqueueReadBuffer( queue, streams[1], true, 0, sizeof(cl_ulong)*num_elements, (void *)output_ptr, 0, NULL, NULL );
+    if (err != CL_SUCCESS)
+    {
+        log_error("clEnqueueReadBuffer failed\n");
+        return -1;
+    }
+
+    if (verify_wg_scan_inclusive_min_ulong(input_ptr[0], output_ptr, num_elements, wg_size[0]))
+    {
+        log_error("work_group_scan_inclusiveadd ulong failed\n");
+        return -1;
+    }
+    log_info("work_group_scan_inclusive_min ulong passed\n");
+
+    clReleaseMemObject(streams[0]);
+    clReleaseMemObject(streams[1]);
+    clReleaseKernel(kernel);
+    clReleaseProgram(program);
+    free(input_ptr[0]);
+    free(output_ptr);
+
+    return err;
+}
+
+
+int
+test_work_group_scan_inclusive_min(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
+{
+    int err;
+
+    err = test_work_group_scan_inclusive_min_int(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_min_uint(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_min_long(device, context, queue, n_elems);
+    if (err) return err;
+    err = test_work_group_scan_inclusive_min_ulong(device, context, queue, n_elems);
+    return err;
+}
+