[Piglit] [PATCH] cl: check value returned from clGetMemObjectInfo

Serge Martin (EdB) edb+piglit at sigluy.net
Sun Sep 6 15:42:56 PDT 2015


From: Serge Martin <edb+piglit at sigluy.net>

---
 tests/cl/api/get-mem-object-info.c | 253 +++++++++++++++++++++++++++++++------
 1 file changed, 213 insertions(+), 40 deletions(-)

diff --git a/tests/cl/api/get-mem-object-info.c b/tests/cl/api/get-mem-object-info.c
index c24b51d..b68262c 100644
--- a/tests/cl/api/get-mem-object-info.c
+++ b/tests/cl/api/get-mem-object-info.c
@@ -46,6 +46,127 @@ PIGLIT_CL_API_TEST_CONFIG_BEGIN
 
 PIGLIT_CL_API_TEST_CONFIG_END
 
+#define BUFFER_SIZE 512
+
+static bool
+test(int n,
+     cl_mem memobj,
+     cl_mem_info param_name,
+     cl_mem_object_type mem_type,
+     cl_mem_flags mem_flags,
+     size_t mem_size,
+     void *mem_ptr,
+     const struct piglit_cl_api_test_env* env,
+     cl_mem mem_parent,
+     size_t mem_offset,
+     enum piglit_result* result) {
+	cl_int errNo;
+	size_t param_value_size;
+	void* param_value;
+
+	errNo = clGetMemObjectInfo(memobj,
+	                           param_name,
+	                           0,
+	                           NULL,
+	                           &param_value_size);
+	if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
+		fprintf(stderr,
+		        "Buffer %d, failed (error code: %s): Get size of %s.\n",
+		        n,
+		        piglit_cl_get_error_name(errNo),
+		        piglit_cl_get_enum_name(param_name));
+		piglit_merge_result(result, PIGLIT_FAIL);
+		return false;
+	}
+
+	param_value = malloc(param_value_size);
+	errNo = clGetMemObjectInfo(memobj,
+	                           param_name,
+	                           param_value_size,
+	                           param_value,
+	                           NULL);
+	if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
+		fprintf(stderr,
+		        "Buffer %d, failed (error code: %s): Get value of %s.\n",
+		        n,
+		        piglit_cl_get_error_name(errNo),
+		        piglit_cl_get_enum_name(param_name));
+		piglit_merge_result(result, PIGLIT_FAIL);
+		free(param_value);
+		return false;
+	}
+
+#define CHECK_SIZE(_type_) \
+	if (param_value_size != sizeof(_type_)) { \
+		fprintf(stderr, \
+		        "Buffer %d, failed: the returned size doesn't matches. Expected %lu, got %lu\n", \
+		        n, sizeof(_type_), param_value_size); \
+		piglit_merge_result(result, PIGLIT_FAIL); \
+	}
+
+#define CHECK_VALUE(_type_, _value_) \
+	if (*(_type_*)param_value != _value_) { \
+		fprintf(stderr, \
+		        "Buffer %d, failed: the returned value doesn't matches.\n", \
+		        n); \
+		piglit_merge_result(result, PIGLIT_FAIL); \
+	}
+
+	switch (param_name) {
+		case CL_MEM_TYPE:
+			CHECK_SIZE(cl_mem_object_type)
+			CHECK_VALUE(cl_mem_object_type, mem_type)
+			break;
+		case CL_MEM_FLAGS:
+			CHECK_SIZE(cl_mem_flags)
+			CHECK_VALUE(cl_mem_flags, mem_flags)
+			break;
+		case CL_MEM_SIZE:
+			CHECK_SIZE(size_t)
+			CHECK_VALUE(size_t, mem_size)
+			break;
+		case CL_MEM_HOST_PTR:
+			CHECK_SIZE(void *)
+			CHECK_VALUE(void *, mem_ptr)
+			break;
+		case CL_MEM_MAP_COUNT:
+			CHECK_SIZE(cl_uint)
+			//stale
+			break;
+		case CL_MEM_REFERENCE_COUNT:
+			CHECK_SIZE(cl_uint)
+			//stale
+			break;
+		case CL_MEM_CONTEXT:
+			CHECK_SIZE(cl_context)
+			CHECK_VALUE(cl_context, env->context->cl_ctx)
+			break;
+#if defined(CL_VERSION_1_1)
+		case CL_MEM_ASSOCIATED_MEMOBJECT:
+			if (env->version >= 11) {
+				CHECK_SIZE(cl_mem)
+				CHECK_VALUE(cl_mem, mem_parent)
+			}
+			break;
+		case CL_MEM_OFFSET:
+			if (env->version >= 11) {
+				CHECK_SIZE(size_t)
+				CHECK_VALUE(size_t, mem_offset)
+			}
+			break;
+#endif
+		default:
+			fprintf(stderr, "Warn: untested parameter %s\n",
+			        piglit_cl_get_enum_name(param_name));
+			piglit_merge_result(result, PIGLIT_WARN);
+	}
+
+#undef CHECK_SIZE
+#undef CHECK_VALUE
+
+	free(param_value);
+	return true;
+}
 
 enum piglit_result
 piglit_cl_test(const int argc,
@@ -57,61 +178,108 @@ piglit_cl_test(const int argc,
 
 	int i;
 	cl_int errNo;
-	cl_mem memobj;
+	cl_mem memobj[3];
+	char host_mem[BUFFER_SIZE] = {0};
 
 	size_t param_value_size;
 	void* param_value;
-	
+
 	int num_mem_infos = PIGLIT_CL_ENUM_NUM(cl_mem_info, env->version);
 	const cl_mem_info* mem_infos = PIGLIT_CL_ENUM_ARRAY(cl_mem_info);
 	
-	memobj = clCreateBuffer(env->context->cl_ctx,
-	                        CL_MEM_READ_WRITE,
-	                        512,
-	                        NULL,
-	                        &errNo);
+	memobj[0] = clCreateBuffer(env->context->cl_ctx,
+	                           CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,
+	                           BUFFER_SIZE,
+	                           host_mem,
+	                           &errNo);
 	if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
 		fprintf(stderr,
-		        "Failed (error code: %s): Create an event by enqueueing a buffer read.\n",
+		        "Failed (error code: %s): Create buffer 0.\n",
 		        piglit_cl_get_error_name(errNo));
 		return PIGLIT_FAIL;
 	}
 
-	/*** Normal usage ***/
-	for(i = 0; i < num_mem_infos; i++) {
-		printf("%s ", piglit_cl_get_enum_name(mem_infos[i]));
+	memobj[1] = clCreateBuffer(env->context->cl_ctx,
+	                           CL_MEM_READ_WRITE|CL_MEM_USE_HOST_PTR,
+	                           BUFFER_SIZE,
+	                           host_mem,
+	                           &errNo);
+	if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
+		fprintf(stderr,
+		        "Failed (error code: %s): Create buffer 1.\n",
+		        piglit_cl_get_error_name(errNo));
+		return PIGLIT_FAIL;
+	}
 
-		errNo = clGetMemObjectInfo(memobj,
-		                           mem_infos[i],
-		                           0,
-		                           NULL,
-		                           &param_value_size);
-		if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
-			fprintf(stderr,
-			        "Failed (error code: %s): Get size of %s.\n",
-			        piglit_cl_get_error_name(errNo),
-			        piglit_cl_get_enum_name(mem_infos[i]));
-			piglit_merge_result(&result, PIGLIT_FAIL);
-			continue;
-		}
+#if defined(CL_VERSION_1_1)
+	if (env->version >= 11) {
+		cl_buffer_region region;
+		region.origin = BUFFER_SIZE/2;
+		region.size = BUFFER_SIZE/2;
 
-		param_value = malloc(param_value_size);
-		errNo = clGetMemObjectInfo(memobj,
-		                           mem_infos[i],
-		                           param_value_size,
-		                           param_value,
-		                           NULL);
+		memobj[2] = clCreateSubBuffer(memobj[1],
+		                              0,
+		                              CL_BUFFER_CREATE_TYPE_REGION,
+		                              &region,
+		                              &errNo);
 		if(!piglit_cl_check_error(errNo, CL_SUCCESS)) {
 			fprintf(stderr,
-			        "Failed (error code: %s): Get value of %s.\n",
-			        piglit_cl_get_error_name(errNo),
-			        piglit_cl_get_enum_name(mem_infos[i]));
-			piglit_merge_result(&result, PIGLIT_FAIL);
+			        "Failed (error code: %s): Create buffer 2.\n",
+			        piglit_cl_get_error_name(errNo));
+			return PIGLIT_FAIL;
 		}
+	}
+#endif
 
-		//TODO: output returned values
-		printf("\n");
-		free(param_value);
+	/*** Normal usage ***/
+	for(i = 0; i < num_mem_infos; i++) {
+		void *copy_ptr = host_mem;
+
+#if defined(CL_VERSION_1_2)
+		if (env->version >= 12)
+			copy_ptr = NULL;
+#endif
+		printf("%s\n", piglit_cl_get_enum_name(mem_infos[i]));
+
+		test(0,
+		     memobj[0],
+		     mem_infos[i],
+		     CL_MEM_OBJECT_BUFFER,
+		     CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,
+		     BUFFER_SIZE,
+		     copy_ptr,
+		     env,
+		     NULL,
+		     0,
+		     &result);
+
+		test(1,
+		     memobj[1],
+		     mem_infos[i],
+		     CL_MEM_OBJECT_BUFFER,
+		     CL_MEM_READ_WRITE|CL_MEM_USE_HOST_PTR,
+		     BUFFER_SIZE,
+		     host_mem,
+		     env,
+		     NULL,
+		     0,
+		     &result);
+
+#if defined(CL_VERSION_1_1)
+		if (env->version >= 11) {
+			test(2,
+			     memobj[2],
+			     mem_infos[i],
+			     CL_MEM_OBJECT_BUFFER,
+			     CL_MEM_READ_WRITE|CL_MEM_USE_HOST_PTR,
+			     BUFFER_SIZE/2,
+			     host_mem + BUFFER_SIZE/2,
+			     env,
+			     memobj[1],
+			     BUFFER_SIZE/2,
+			     &result);
+		}
+#endif
 	}
 
 	/*** Errors ***/
@@ -122,7 +290,7 @@ piglit_cl_test(const int argc,
 	 * less than size of return type and param_value is not a NULL
 	 * value.
 	 */
-	errNo = clGetMemObjectInfo(memobj,
+	errNo = clGetMemObjectInfo(memobj[0],
 	                           CL_DEVICE_NAME,
 	                           0,
 	                           NULL,
@@ -134,11 +302,13 @@ piglit_cl_test(const int argc,
 		piglit_merge_result(&result, PIGLIT_FAIL);
 	}
 
-	errNo = clGetMemObjectInfo(memobj,
+	param_value = malloc(sizeof(cl_mem_object_type));
+	errNo = clGetMemObjectInfo(memobj[0],
 	                           CL_MEM_TYPE,
 	                           1,
 	                           param_value,
 	                           NULL);
+	free(param_value);
 	if(!piglit_cl_check_error(errNo, CL_INVALID_VALUE)) {
 		fprintf(stderr,
 		        "Failed (error code: %s): Trigger CL_INVALID_VALUE if size in bytes specified by param_value is less than size of return type and param_value is not a NULL value.\n",
@@ -161,7 +331,10 @@ piglit_cl_test(const int argc,
 		piglit_merge_result(&result, PIGLIT_FAIL);
 	}
 
-	clReleaseMemObject(memobj);
+	clReleaseMemObject(memobj[0]);
+	clReleaseMemObject(memobj[1]);
+	if (env->version >= 11)
+		clReleaseMemObject(memobj[2]);
 
 	return result;
 }
-- 
2.5.0



More information about the Piglit mailing list