[v5] cl: add clEnqueue-read_write BufferRect releated tests

Submitted by Meng, Mengmeng on Aug. 2, 2015, 5:59 p.m.

Details

Message ID 1438538384-26333-1-git-send-email-mengmeng.meng@intel.com
State New
Headers show

Not browsing as part of any series.

Commit Message

Meng, Mengmeng Aug. 2, 2015, 5:59 p.m.
It's a simple function test for clEnqueueReadBufferRect and
clEnqueueWriteBufferRect.
---
 tests/cl.py                                   |   2 +
 tests/cl/api/CMakeLists.cl.txt                |   1 +
 tests/cl/api/enqueue-read_write-buffer-rect.c | 338 ++++++++++++++++++++++++++
 3 files changed, 341 insertions(+)
 create mode 100644 tests/cl/api/enqueue-read_write-buffer-rect.c

Patch hide | download patch | download mbox

diff --git a/tests/cl.py b/tests/cl.py
index 4668ddc..572ccdc 100644
--- a/tests/cl.py
+++ b/tests/cl.py
@@ -58,6 +58,8 @@  with profile.group_manager(PiglitCLTest, 'api') as g:
     g(['cl-api-enqueue-copy-buffer-rect'], 'clEnqueueCopyBufferRect')
     g(['cl-api-enqueue-read_write-buffer'],
       'clEnqueueReadBuffer and clEnqueueWriteBuffer')
+    g(['cl-api-enqueue-read_write-buffer-rect'],
+      'clEnqueueReadBufferRect and clEnqueueWriteBufferRect')
     g(['cl-api-get-mem-object-info'], 'clGetMemObjectInfo')
     g(['cl-api-get-image-info'], 'clGetImageInfo')
     g(['cl-api-retain_release-mem-object'],
diff --git a/tests/cl/api/CMakeLists.cl.txt b/tests/cl/api/CMakeLists.cl.txt
index b598528..f0a388f 100644
--- a/tests/cl/api/CMakeLists.cl.txt
+++ b/tests/cl/api/CMakeLists.cl.txt
@@ -21,6 +21,7 @@  piglit_cl_add_api_test (enqueue-copy-buffer enqueue-copy-buffer.c)
 piglit_cl_add_api_test (enqueue-map-buffer enqueue-map-buffer.c)
 piglit_cl_add_api_test (enqueue-copy-buffer-rect enqueue-copy-buffer-rect.c)
 piglit_cl_add_api_test (enqueue-read_write-buffer enqueue-read_write-buffer.c)
+piglit_cl_add_api_test (enqueue-read_write-buffer-rect enqueue-read_write-buffer-rect.c)
 piglit_cl_add_api_test (retain_release-mem-object retain_release-mem-object.c)
 piglit_cl_add_api_test (get-mem-object-info get-mem-object-info.c)
 piglit_cl_add_api_test (get-image-info get-image-info.c)
diff --git a/tests/cl/api/enqueue-read_write-buffer-rect.c b/tests/cl/api/enqueue-read_write-buffer-rect.c
new file mode 100644
index 0000000..6f7d2ca
--- /dev/null
+++ b/tests/cl/api/enqueue-read_write-buffer-rect.c
@@ -0,0 +1,338 @@ 
+/*
+ * Copyright © 2015 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Meng Mengmeng <mengmeng.meng at intel.com>
+ *
+ */
+
+#include "piglit-framework-cl-api.h"
+#include "piglit-util-cl.h"
+
+
+PIGLIT_CL_API_TEST_CONFIG_BEGIN
+
+	config.name = "clEnqueueReadBufferRect and clEnqueueWriteBufferRect";
+	config.version_min = 11;
+
+	config.run_per_platform = true;
+	config.create_context = true;
+
+PIGLIT_CL_API_TEST_CONFIG_END
+
+static bool
+test_read_rect(cl_command_queue command_queue,
+               cl_mem buffer,
+               cl_bool blocking_read,
+               const size_t * buffer_origin,
+               const size_t * host_origin,
+               const size_t * region,
+               size_t buffer_row_pitch,
+               size_t buffer_slice_pitch,
+               size_t host_row_pitch,
+               size_t host_slice_pitch,
+               void *ptr,
+               cl_uint num_events_in_wait_list,
+               const cl_event *event_wait_list,
+               cl_event *event,
+               cl_int expected_error,
+               enum piglit_result* result,
+               const char* test_str) {
+	cl_int errNo;
+
+	errNo = clEnqueueReadBufferRect(command_queue,
+	                                buffer,
+	                                blocking_read,
+	                                buffer_origin,
+	                                host_origin,
+	                                region,
+	                                buffer_row_pitch,
+	                                buffer_slice_pitch,
+	                                host_row_pitch,
+	                                host_slice_pitch,
+	                                ptr,
+	                                num_events_in_wait_list,
+	                                event_wait_list,
+	                                event);
+
+	if(!piglit_cl_check_error(errNo, expected_error)) {
+		fprintf(stderr, "clEnqueueReadBufferRect: Failed (error code: %s): %s.\n",
+		        piglit_cl_get_error_name(errNo), test_str);
+		piglit_merge_result(result, PIGLIT_FAIL);
+		return false;
+	}
+
+	return true;
+}
+
+static bool
+test_write_rect(cl_command_queue command_queue,
+                cl_mem buffer,
+                cl_bool blocking_write,
+                const size_t * buffer_origin,
+                const size_t * host_origin,
+                const size_t * region,
+                size_t buffer_row_pitch,
+                size_t buffer_slice_pitch,
+                size_t host_row_pitch,
+                size_t host_slice_pitch,
+                void *ptr,
+                cl_uint num_events_in_wait_list,
+                const cl_event *event_wait_list,
+                cl_event *event,
+                cl_int expected_error,
+                enum piglit_result* result,
+                const char* test_str) {
+	cl_int errNo;
+
+	errNo = clEnqueueWriteBufferRect(command_queue,
+	                                 buffer,
+	                                 blocking_write,
+	                                 buffer_origin,
+	                                 host_origin,
+	                                 region,
+	                                 buffer_row_pitch,
+	                                 buffer_slice_pitch,
+	                                 host_row_pitch,
+	                                 host_slice_pitch,
+	                                 ptr,
+	                                 num_events_in_wait_list,
+	                                 event_wait_list,
+	                                 event);
+
+	if(!piglit_cl_check_error(errNo, expected_error)) {
+		fprintf(stderr, "clEnqueueWiteBufferRect: Failed (error code: %s): %s.\n",
+		        piglit_cl_get_error_name(errNo), test_str);
+		piglit_merge_result(result, PIGLIT_FAIL);
+		return false;
+	}
+
+	return true;
+}
+enum piglit_result
+piglit_cl_test(const int argc,
+               const char **argv,
+               const struct piglit_cl_api_test_config* config,
+               const struct piglit_cl_api_test_env* env)
+{
+
+	enum piglit_result result = PIGLIT_PASS;
+	piglit_cl_context context;
+
+	cl_event valid_event;
+	cl_event invalid_event = NULL;
+
+	cl_int i, j;
+	cl_int k = 0;
+	float full_matrix[81], result_matrix[9];
+	const size_t buffer_origin[3] = {3 * sizeof(float), 3, 0};
+	const size_t host_origin[3] = {3 * sizeof(float), 3, 0};
+	const size_t host_new_origin[3] = {0 * sizeof(float), 0, 0};
+	const size_t region[3] = {3 * sizeof(float), 3, 1};
+	cl_mem matrix_buffer;
+
+	for(i=0; i<81; i++) {
+		full_matrix[i] = i * 1.0f;
+	}
+	for(i=0; i<9; i++) {
+		result_matrix[i] = 0.0f;
+	}
+
+	float reference_matrix[9] = {30.0f, 31.0f, 32.0f,
+	                             39.0f, 40.0f, 41.0f, 48.0f, 49.0f, 50.0f};
+
+	matrix_buffer = piglit_cl_create_buffer(env->context, CL_MEM_READ_WRITE , sizeof(full_matrix));
+
+	/*
+	* Write to a buffer object from host memory(9*9 matrix), then read
+	* rectangular the region 3*3 from that buffer object to host memory,
+	* finally compare the read result with reference matrix.
+	*/
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
+	                CL_SUCCESS, &result,
+	                "clEnqueueWriteBufferRec: Failed when write to a buffer object 9*9 from host memor");
+	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	               buffer_origin,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL,
+	               CL_SUCCESS, &result,
+	               "clEnqueueReadBufferRect: Failed when read from a rectangular region 3*3 to host memory");
+
+	for(i = 0; i < 3; ++i){
+		for(j = 0; j < 3; ++j){
+			if(result_matrix[j+i*3] != reference_matrix[k]){
+				fprintf(stderr,
+				        "clEnqueueWriteBufferRect and clEnqueueReadBufferRect: Failed (expected %f, but got %f)\n",
+				        reference_matrix[k],result_matrix[j+i*3]);
+				piglit_merge_result(&result, PIGLIT_FAIL);
+			}else
+				k++;
+		}
+	}
+
+	/*
+	* CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command-queue.
+	*/
+	test_write_rect(NULL, matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
+	                CL_INVALID_COMMAND_QUEUE, &result,
+	                "Trigger CL_INVALID_COMMAND_QUEUE when command_queue is not a valid command-queue");
+	test_read_rect(NULL, matrix_buffer, CL_TRUE,
+	               buffer_origin,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL,
+	               CL_INVALID_COMMAND_QUEUE, &result,
+	               "Trigger CL_INVALID_COMMAND_QUEUE when command_queue is not a valid command-queue");
+
+	/*
+	* CL_INVALID_CONTEXT if the context associated with command_queue
+	* and buffer are not the same or if the context associated with command_queue
+	* and events in event_wait_list are not the same.
+	*/
+	context = piglit_cl_create_context(env->platform_id,
+	                                   env->context->device_ids,
+	                                   1);
+	if(context != NULL){
+		test_write_rect(context->command_queues[0], matrix_buffer, CL_TRUE,
+		                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+		                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
+		                CL_INVALID_CONTEXT, &result,
+		                "Trigger CL_INVALID_CONTEXT when context associated with command_queue and buffer are not the same");
+		test_read_rect(context->command_queues[0], matrix_buffer, CL_TRUE,
+		               buffer_origin,  host_new_origin, region, 9 * sizeof(float), 0,
+		               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL,
+		               CL_INVALID_CONTEXT, &result,
+		               "Trigger CL_INVALID_CONTEXT when context associated with command_queue and buffer are not the same");
+	}else {
+		fprintf(stderr, "Could not test triggering CL_INVALID_CONTEXT.\n");
+		piglit_merge_result(&result, PIGLIT_WARN);
+	}
+
+	/*
+	* CL_INVALID_MEM_OBJECT if buffer is not a valid buffer object.
+	*/
+	test_write_rect(env->context->command_queues[0], NULL, CL_TRUE,
+	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
+	                CL_INVALID_MEM_OBJECT, &result,
+	                "Trigger CL_INVALID_MEM_OBJECT when buffer is not a valid buffer object");
+	test_read_rect(env->context->command_queues[0], NULL, CL_TRUE,
+	               buffer_origin,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL,
+	               CL_INVALID_MEM_OBJECT, &result,
+	               "Trigger CL_INVALID_MEM_OBJECT when buffer is not a valid buffer object");
+
+	/*
+	* CL_INVALID_VALUE if the region being read specified by
+	* (buffer_origin, region) is out of bounds or if ptr is a NULL value.
+	*/
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin + 1, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
+	                CL_INVALID_VALUE, &result,
+	                "Trigger CL_INVALID_VALUE if the region being write specified by (buffer_origin, region) is out of bounds");
+	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	               buffer_origin + 1,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL,
+	               CL_INVALID_VALUE, &result,
+	               "Trigger CL_INVALID_VALUE if the region being read specified by (buffer_origin, region) is out of bounds");
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region + 1, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
+	                CL_INVALID_VALUE, &result,
+	                "Trigger CL_INVALID_VALUE if the region being write specified by (buffer_origin, region) is out of bounds");
+	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	               buffer_origin ,  host_new_origin, region + 1, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL,
+	               CL_INVALID_VALUE, &result,
+	               "Trigger CL_INVALID_VALUE if the region being read specified by (buffer_origin, region) is out of bounds");
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region , 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, NULL, 0, NULL, NULL,
+	                CL_INVALID_VALUE, &result,
+	                "Trigger CL_INVALID_VALUE if ptr is a NULL value");
+	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	               buffer_origin ,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, NULL, 0, NULL, NULL,
+	               CL_INVALID_VALUE, &result,
+	               "Trigger CL_INVALID_VALUE if ptr is a NULL value");
+
+	/*
+	* CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and
+	* num_events_in_wait_list greater than 0,or event_wait_list
+	* is not NULL and num_events_in_wait_list is 0, or if event
+	* objects in event_wait_list are not valid events.
+	*/
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 0, NULL, &valid_event,
+	                CL_SUCCESS, &result,
+	                "Create an event");
+
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 1, NULL, NULL,
+	                CL_INVALID_EVENT_WAIT_LIST, &result,
+	                "Trigger CL_INVALID_EVENT_WAIT_LIST when event_wait_list is NULL and num_events_in_wait_list greater than 0");
+	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	               buffer_origin ,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 1, NULL, NULL,
+	               CL_INVALID_EVENT_WAIT_LIST, &result,
+	               "Trigger CL_INVALID_EVENT_WAIT_LIST when event_wait_list is NULL and num_events_in_wait_list greater than 0");
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 0, &valid_event, NULL,
+	                CL_INVALID_EVENT_WAIT_LIST, &result,
+	                "Trigger CL_INVALID_EVENT_WAIT_LIST when vent_wait_list is not NULL and num_events_in_wait_list is 0");
+	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	               buffer_origin ,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 0, &valid_event, NULL,
+	               CL_INVALID_EVENT_WAIT_LIST, &result,
+	               "Trigger CL_INVALID_EVENT_WAIT_LIST when vent_wait_list is not NULL and num_events_in_wait_list is 0");
+	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
+	                9 * sizeof(float), 0, full_matrix, 1, &invalid_event, NULL,
+	                CL_INVALID_EVENT_WAIT_LIST, &result,
+	                "Trigger CL_INVALID_EVENT_WAIT_LIST when event objects in event_wait_list are not valid events");
+	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
+	               buffer_origin ,  host_new_origin, region, 9 * sizeof(float), 0,
+	               3 * sizeof(float), 0, result_matrix, 0, &invalid_event, NULL,
+	               CL_INVALID_EVENT_WAIT_LIST, &result,
+	               "Trigger CL_INVALID_EVENT_WAIT_LIST when event objects in event_wait_list are not valid event");
+
+	clReleaseEvent(valid_event);
+
+	/*
+	* CL_MISALIGNED_SUB_BUFFER_OFFSET if buffer is a sub-buffer
+	* object and offset specified when the sub-buffer object is
+	* created is not aligned to CL_DEVICE_MEM_BASE_ADDR_ALIGN
+	* value for device associated with queue.
+	*/
+
+	/*
+	* CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST if the read
+	* and write operations are blocking and the execution status of any
+	* of the events in event_wait_list is a negative integer value.
+	*/
+
+	return result;
+}

Comments

Hello

I was about to push it, be find that some of the errors tests return CL_SUCCESS 
when they shouldn't have, sorry about that.
Does this test pass on INTEL OCL?

See comments below

On Monday 03 August 2015 01:59:44 Meng Mengmeng wrote:
> It's a simple function test for clEnqueueReadBufferRect and
> clEnqueueWriteBufferRect.
> ---
>  tests/cl.py                                   |   2 +
>  tests/cl/api/CMakeLists.cl.txt                |   1 +
>  tests/cl/api/enqueue-read_write-buffer-rect.c | 338
> ++++++++++++++++++++++++++ 3 files changed, 341 insertions(+)
>  create mode 100644 tests/cl/api/enqueue-read_write-buffer-rect.c
> 
> diff --git a/tests/cl.py b/tests/cl.py
> index 4668ddc..572ccdc 100644
> --- a/tests/cl.py
> +++ b/tests/cl.py
> @@ -58,6 +58,8 @@ with profile.group_manager(PiglitCLTest, 'api') as g:
>      g(['cl-api-enqueue-copy-buffer-rect'], 'clEnqueueCopyBufferRect')
>      g(['cl-api-enqueue-read_write-buffer'],
>        'clEnqueueReadBuffer and clEnqueueWriteBuffer')
> +    g(['cl-api-enqueue-read_write-buffer-rect'],
> +      'clEnqueueReadBufferRect and clEnqueueWriteBufferRect')
>      g(['cl-api-get-mem-object-info'], 'clGetMemObjectInfo')
>      g(['cl-api-get-image-info'], 'clGetImageInfo')
>      g(['cl-api-retain_release-mem-object'],
> diff --git a/tests/cl/api/CMakeLists.cl.txt b/tests/cl/api/CMakeLists.cl.txt
> index b598528..f0a388f 100644
> --- a/tests/cl/api/CMakeLists.cl.txt
> +++ b/tests/cl/api/CMakeLists.cl.txt
> @@ -21,6 +21,7 @@ piglit_cl_add_api_test (enqueue-copy-buffer
> enqueue-copy-buffer.c) piglit_cl_add_api_test (enqueue-map-buffer
> enqueue-map-buffer.c)
>  piglit_cl_add_api_test (enqueue-copy-buffer-rect
> enqueue-copy-buffer-rect.c) piglit_cl_add_api_test
> (enqueue-read_write-buffer enqueue-read_write-buffer.c)
> +piglit_cl_add_api_test (enqueue-read_write-buffer-rect
> enqueue-read_write-buffer-rect.c) piglit_cl_add_api_test
> (retain_release-mem-object retain_release-mem-object.c)
> piglit_cl_add_api_test (get-mem-object-info get-mem-object-info.c)
> piglit_cl_add_api_test (get-image-info get-image-info.c)
> diff --git a/tests/cl/api/enqueue-read_write-buffer-rect.c
> b/tests/cl/api/enqueue-read_write-buffer-rect.c new file mode 100644
> index 0000000..6f7d2ca
> --- /dev/null
> +++ b/tests/cl/api/enqueue-read_write-buffer-rect.c
> @@ -0,0 +1,338 @@
> +/*
> + * Copyright © 2015 Intel Corporation
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the
> "Software"), + * to deal in the Software without restriction, including
> without limitation + * the rights to use, copy, modify, merge, publish,
> distribute, sublicense, + * and/or sell copies of the Software, and to
> permit persons to whom the + * Software is furnished to do so, subject to
> the following conditions: + *
> + * The above copyright notice and this permission notice (including the
> next + * paragraph) shall be included in all copies or substantial portions
> of the + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
> OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
> MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
> IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
> CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
> TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE
> SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE.
> + *
> + * Authors: Meng Mengmeng <mengmeng.meng at intel.com>
> + *
> + */
> +
> +#include "piglit-framework-cl-api.h"
> +#include "piglit-util-cl.h"
> +
> +
> +PIGLIT_CL_API_TEST_CONFIG_BEGIN
> +
> +	config.name = "clEnqueueReadBufferRect and clEnqueueWriteBufferRect";
> +	config.version_min = 11;
> +
> +	config.run_per_platform = true;
> +	config.create_context = true;
> +
> +PIGLIT_CL_API_TEST_CONFIG_END
> +
> +static bool
> +test_read_rect(cl_command_queue command_queue,
> +               cl_mem buffer,
> +               cl_bool blocking_read,
> +               const size_t * buffer_origin,
> +               const size_t * host_origin,
> +               const size_t * region,
> +               size_t buffer_row_pitch,
> +               size_t buffer_slice_pitch,
> +               size_t host_row_pitch,
> +               size_t host_slice_pitch,
> +               void *ptr,
> +               cl_uint num_events_in_wait_list,
> +               const cl_event *event_wait_list,
> +               cl_event *event,
> +               cl_int expected_error,
> +               enum piglit_result* result,
> +               const char* test_str) {
> +	cl_int errNo;
> +
> +	errNo = clEnqueueReadBufferRect(command_queue,
> +	                                buffer,
> +	                                blocking_read,
> +	                                buffer_origin,
> +	                                host_origin,
> +	                                region,
> +	                                buffer_row_pitch,
> +	                                buffer_slice_pitch,
> +	                                host_row_pitch,
> +	                                host_slice_pitch,
> +	                                ptr,
> +	                                num_events_in_wait_list,
> +	                                event_wait_list,
> +	                                event);
> +
> +	if(!piglit_cl_check_error(errNo, expected_error)) {

Please add space after if: if (!pigli...

> +		fprintf(stderr, "clEnqueueReadBufferRect: Failed (error code: %s):
> %s.\n", +		        piglit_cl_get_error_name(errNo), test_str);
> +		piglit_merge_result(result, PIGLIT_FAIL);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +
> +static bool
> +test_write_rect(cl_command_queue command_queue,
> +                cl_mem buffer,
> +                cl_bool blocking_write,
> +                const size_t * buffer_origin,
> +                const size_t * host_origin,
> +                const size_t * region,
> +                size_t buffer_row_pitch,
> +                size_t buffer_slice_pitch,
> +                size_t host_row_pitch,
> +                size_t host_slice_pitch,
> +                void *ptr,
> +                cl_uint num_events_in_wait_list,
> +                const cl_event *event_wait_list,
> +                cl_event *event,
> +                cl_int expected_error,
> +                enum piglit_result* result,
> +                const char* test_str) {
> +	cl_int errNo;
> +
> +	errNo = clEnqueueWriteBufferRect(command_queue,
> +	                                 buffer,
> +	                                 blocking_write,
> +	                                 buffer_origin,
> +	                                 host_origin,
> +	                                 region,
> +	                                 buffer_row_pitch,
> +	                                 buffer_slice_pitch,
> +	                                 host_row_pitch,
> +	                                 host_slice_pitch,
> +	                                 ptr,
> +	                                 num_events_in_wait_list,
> +	                                 event_wait_list,
> +	                                 event);
> +
> +	if(!piglit_cl_check_error(errNo, expected_error)) {

same here

> +		fprintf(stderr, "clEnqueueWiteBufferRect: Failed (error code: %s):
> %s.\n", +		        piglit_cl_get_error_name(errNo), test_str);
> +		piglit_merge_result(result, PIGLIT_FAIL);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +enum piglit_result
> +piglit_cl_test(const int argc,
> +               const char **argv,
> +               const struct piglit_cl_api_test_config* config,
> +               const struct piglit_cl_api_test_env* env)
> +{
> +
> +	enum piglit_result result = PIGLIT_PASS;
> +	piglit_cl_context context;
> +
> +	cl_event valid_event;
> +	cl_event invalid_event = NULL;
> +
> +	cl_int i, j;
> +	cl_int k = 0;
> +	float full_matrix[81], result_matrix[9];
> +	const size_t buffer_origin[3] = {3 * sizeof(float), 3, 0};
> +	const size_t host_origin[3] = {3 * sizeof(float), 3, 0};
> +	const size_t host_new_origin[3] = {0 * sizeof(float), 0, 0};
> +	const size_t region[3] = {3 * sizeof(float), 3, 1};
> +	cl_mem matrix_buffer;
> +
> +	for(i=0; i<81; i++) {

as for the if, please put a space here

> +		full_matrix[i] = i * 1.0f;
> +	}
> +	for(i=0; i<9; i++) {

same here

> +		result_matrix[i] = 0.0f;
> +	}
> +
> +	float reference_matrix[9] = {30.0f, 31.0f, 32.0f,
> +	                             39.0f, 40.0f, 41.0f, 48.0f, 49.0f, 50.0f};
> +
> +	matrix_buffer = piglit_cl_create_buffer(env->context, CL_MEM_READ_WRITE ,
> sizeof(full_matrix)); +
> +	/*
> +	* Write to a buffer object from host memory(9*9 matrix), then read
> +	* rectangular the region 3*3 from that buffer object to host memory,
> +	* finally compare the read result with reference matrix.
> +	*/
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
> +	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
> +	                CL_SUCCESS, &result,
> +	                "clEnqueueWriteBufferRec: Failed when write to a buffer
> object 9*9 from host memor");
> +	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	               buffer_origin,  host_new_origin, region, 9 *
> sizeof(float), 0, +	               3 * sizeof(float), 0, result_matrix, 0,
> NULL, NULL, +	               CL_SUCCESS, &result,
> +	               "clEnqueueReadBufferRect: Failed when read from a
> rectangular region 3*3 to host memory"); +
> +	for(i = 0; i < 3; ++i){
> +		for(j = 0; j < 3; ++j){
> +			if(result_matrix[j+i*3] != reference_matrix[k]){
> +				fprintf(stderr,
> +				        "clEnqueueWriteBufferRect and 
clEnqueueReadBufferRect: Failed
> (expected %f, but got %f)\n", +				       
> reference_matrix[k],result_matrix[j+i*3]);
> +				piglit_merge_result(&result, PIGLIT_FAIL);
> +			}else

Please put a space and add an extra { 

> +				k++;
> +		}
> +	}
> +
> +	/*
> +	* CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command-queue.
> +	*/
> +	test_write_rect(NULL, matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
> +	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
> +	                CL_INVALID_COMMAND_QUEUE, &result,
> +	                "Trigger CL_INVALID_COMMAND_QUEUE when command_queue is
> not a valid command-queue"); +	test_read_rect(NULL, matrix_buffer, 
CL_TRUE,
> +	               buffer_origin,  host_new_origin, region, 9 * sizeof(float),
> 0, +	               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL, +	
 
>              CL_INVALID_COMMAND_QUEUE, &result,
> +	               "Trigger CL_INVALID_COMMAND_QUEUE when command_queue is not
> a valid command-queue"); +
> +	/*
> +	* CL_INVALID_CONTEXT if the context associated with command_queue
> +	* and buffer are not the same or if the context associated with
> command_queue +	* and events in event_wait_list are not the same.
> +	*/
> +	context = piglit_cl_create_context(env->platform_id,
> +	                                   env->context->device_ids,
> +	                                   1);
> +	if(context != NULL){

same here + space before {

> +		test_write_rect(context->command_queues[0], matrix_buffer, CL_TRUE,
> +		                buffer_origin, host_origin, region, 9 * sizeof(float), 
0,
> +		                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL, +		
   
>             CL_INVALID_CONTEXT, &result,
> +		                "Trigger CL_INVALID_CONTEXT when context associated 
with
> command_queue and buffer are not the same");
> +		test_read_rect(context->command_queues[0], matrix_buffer, CL_TRUE, +		
  
>             buffer_origin,  host_new_origin, region, 9 * sizeof(float), 0,
> +		               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL, +	
	  
>             CL_INVALID_CONTEXT, &result,
> +		               "Trigger CL_INVALID_CONTEXT when context associated 
with
> command_queue and buffer are not the same"); 

add piglit_cl_release_context(context)

> +	}else {

a space here

> +		fprintf(stderr, "Could not test triggering CL_INVALID_CONTEXT.\n");
> +		piglit_merge_result(&result, PIGLIT_WARN);
> +	}
> +
> +	/*
> +	* CL_INVALID_MEM_OBJECT if buffer is not a valid buffer object.
> +	*/
> +	test_write_rect(env->context->command_queues[0], NULL, CL_TRUE,
> +	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
> +	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL,
> +	                CL_INVALID_MEM_OBJECT, &result,
> +	                "Trigger CL_INVALID_MEM_OBJECT when buffer is not a valid
> buffer object"); +	test_read_rect(env->context->command_queues[0], NULL,
> CL_TRUE,
> +	               buffer_origin,  host_new_origin, region, 9 * sizeof(float),
> 0, +	               3 * sizeof(float), 0, result_matrix, 0, NULL, NULL, +	
 
>              CL_INVALID_MEM_OBJECT, &result,
> +	               "Trigger CL_INVALID_MEM_OBJECT when buffer is not a valid
> buffer object"); +
> +	/*
> +	* CL_INVALID_VALUE if the region being read specified by
> +	* (buffer_origin, region) is out of bounds or if ptr is a NULL value.
> +	*/
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin + 1, host_origin, region, 9 * sizeof(float),0,

You are doing pointer arithmetic here, I guess it's not what you wanted

> +	                9 * sizeof(float), 0, full_matrix, 0, NULL, NULL, +	  
>              CL_INVALID_VALUE, &result,
> +	                "Trigger CL_INVALID_VALUE if the region being write
> specified by (buffer_origin, region) is out of bounds");
> +	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	               buffer_origin + 1,  host_new_origin, region, 9 *

same here and probably after

> sizeof(float), 0, +	               3 * sizeof(float), 0, result_matrix, 0,
> NULL, NULL, +	               CL_INVALID_VALUE, &result,
> +	               "Trigger CL_INVALID_VALUE if the region being read
> specified by (buffer_origin, region) is out of bounds");
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region + 1, 9 *
> sizeof(float), 0, +	                9 * sizeof(float), 0, full_matrix, 0,
> NULL, NULL, +	                CL_INVALID_VALUE, &result,
> +	                "Trigger CL_INVALID_VALUE if the region being write
> specified by (buffer_origin, region) is out of bounds");
> +	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	               buffer_origin ,  host_new_origin, region + 1, 9 *
> sizeof(float), 0, +	               3 * sizeof(float), 0, result_matrix, 0,
> NULL, NULL, +	               CL_INVALID_VALUE, &result,
> +	               "Trigger CL_INVALID_VALUE if the region being read
> specified by (buffer_origin, region) is out of bounds");
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region , 9 * sizeof(float),
> 0, +	                9 * sizeof(float), 0, NULL, 0, NULL, NULL,
> +	                CL_INVALID_VALUE, &result,
> +	                "Trigger CL_INVALID_VALUE if ptr is a NULL value");
> +	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	               buffer_origin ,  host_new_origin, region, 9 *
> sizeof(float), 0, +	               3 * sizeof(float), 0, NULL, 0, NULL,
> NULL,
> +	               CL_INVALID_VALUE, &result,
> +	               "Trigger CL_INVALID_VALUE if ptr is a NULL value");
> +
> +	/*
> +	* CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and
> +	* num_events_in_wait_list greater than 0,or event_wait_list
> +	* is not NULL and num_events_in_wait_list is 0, or if event
> +	* objects in event_wait_list are not valid events.
> +	*/
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
> +	                9 * sizeof(float), 0, full_matrix, 0, NULL, &valid_event,
> +	                CL_SUCCESS, &result,
> +	                "Create an event");
> +
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
> +	                9 * sizeof(float), 0, full_matrix, 1, NULL, NULL,
> +	                CL_INVALID_EVENT_WAIT_LIST, &result,
> +	                "Trigger CL_INVALID_EVENT_WAIT_LIST when event_wait_list
> is NULL and num_events_in_wait_list greater than 0");
> +	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	               buffer_origin ,  host_new_origin, region, 9 *
> sizeof(float), 0, +	               3 * sizeof(float), 0, result_matrix, 1,
> NULL, NULL, +	               CL_INVALID_EVENT_WAIT_LIST, &result,
> +	               "Trigger CL_INVALID_EVENT_WAIT_LIST when event_wait_list is
> NULL and num_events_in_wait_list greater than 0");
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
> +	                9 * sizeof(float), 0, full_matrix, 0, &valid_event, NULL,
> +	                CL_INVALID_EVENT_WAIT_LIST, &result,
> +	                "Trigger CL_INVALID_EVENT_WAIT_LIST when vent_wait_list is
> not NULL and num_events_in_wait_list is 0");
> +	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	               buffer_origin ,  host_new_origin, region, 9 *
> sizeof(float), 0, +	               3 * sizeof(float), 0, result_matrix, 0,
> &valid_event, NULL, +	               CL_INVALID_EVENT_WAIT_LIST, &result,
> +	               "Trigger CL_INVALID_EVENT_WAIT_LIST when vent_wait_list is
> not NULL and num_events_in_wait_list is 0");
> +	test_write_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	                buffer_origin, host_origin, region, 9 * sizeof(float), 0,
> +	                9 * sizeof(float), 0, full_matrix, 1, &invalid_event,
> NULL, +	                CL_INVALID_EVENT_WAIT_LIST, &result,
> +	                "Trigger CL_INVALID_EVENT_WAIT_LIST when event objects in
> event_wait_list are not valid events");
> +	test_read_rect(env->context->command_queues[0], matrix_buffer, CL_TRUE,
> +	               buffer_origin ,  host_new_origin, region, 9 *
> sizeof(float), 0, +	               3 * sizeof(float), 0, result_matrix, 0,
> &invalid_event, NULL, +	               CL_INVALID_EVENT_WAIT_LIST, 
&result,
> +	               "Trigger CL_INVALID_EVENT_WAIT_LIST when event objects in
> event_wait_list are not valid event"); +
> +	clReleaseEvent(valid_event);
> +
> +	/*
> +	* CL_MISALIGNED_SUB_BUFFER_OFFSET if buffer is a sub-buffer
> +	* object and offset specified when the sub-buffer object is
> +	* created is not aligned to CL_DEVICE_MEM_BASE_ADDR_ALIGN
> +	* value for device associated with queue.
> +	*/
> +
> +	/*
> +	* CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST if the read
> +	* and write operations are blocking and the execution status of any
> +	* of the events in event_wait_list is a negative integer value.
> +	*/
> +

clReleaseMemObject(matrix_buffer)

   EdB

> +	return result;
> +}