ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-26 08:49:02 +00:00
Code Packages Projects Releases Wiki Activity

add a test for clSetContextDestructorCallback (#861)

Browse Source 
* add a test for clSetContextDestructorCallback

* add a 10 second timeout for mem object and context destructor callbacks

* clang-format fixes

* address review comments
This commit is contained in:
Ben Ashbaugh
2020-08-10 14:21:37 -07:00
committed by GitHub
parent 93001e99a4
commit fb2119eb87
5 changed files with 250 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test_conformance/api/CMakeLists.txt
View File

@@ -27,6 +27,7 @@ set(${MODULE_NAME}_SOURCES
test_sub_group_dispatch.cpp
test_clone_kernel.cpp
test_zero_sized_enqueue.cpp
test_context_destructor_callback.cpp
)
include(../CMakeCommon.txt)

6
test_conformance/api/main.cpp
View File

@@ -26,8 +26,8 @@
#endif
// FIXME: To use certain functions in harness/imageHelpers.h
// (for example, generate_random_image_data()), the tests are required to declare
// the following variables (<rdar://problem/11111245>):
// (for example, generate_random_image_data()), the tests are required to
// declare the following variables (<rdar://problem/11111245>):
test_definition test_list[] = {
ADD_TEST(get_platform_info),
@@ -108,6 +108,7 @@ test_definition test_list[] = {
ADD_TEST(retain_mem_object_set_kernel_arg),
ADD_TEST(min_data_type_align_size_alignment),
ADD_TEST_VERSION(context_destructor_callback, Version(3, 0)),
ADD_TEST(mem_object_destructor_callback),
ADD_TEST(null_buffer_arg),
ADD_TEST(get_buffer_info),
@@ -129,4 +130,3 @@ int main(int argc, const char *argv[])
{
return runTestHarness(argc, argv, test_num, test_list, false, false, 0);
}

9
test_conformance/api/procs.h
View File

@@ -98,7 +98,14 @@ extern int test_retain_mem_object_multiple(cl_device_id deviceID, cl_cont
extern int test_retain_mem_object_set_kernel_arg(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
extern int test_min_data_type_align_size_alignment(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems );
extern int test_mem_object_destructor_callback(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements);
extern int test_context_destructor_callback(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mem_object_destructor_callback(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_null_buffer_arg( cl_device_id device_id, cl_context context, cl_command_queue queue, int num_elements );
extern int test_get_buffer_info( cl_device_id deviceID, cl_context context, cl_command_queue ignoreQueue, int num_elements );

93
test_conformance/api/test_context_destructor_callback.cpp Normal file
View File

@@ -0,0 +1,93 @@
//
// Copyright (c) 2020 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 "testBase.h"
static volatile cl_int sDestructorIndex;
void CL_CALLBACK context_destructor_callback(cl_context context, void *userData)
{
int *userPtr = (int *)userData;
// ordering of callbacks is guaranteed, meaning we don't need to do atomic
// operation here
*userPtr = ++sDestructorIndex;
}
int test_context_destructor_callback(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements)
{
cl_int error;
clContextWrapper localContext =
clCreateContext(NULL, 1, &deviceID, NULL, NULL, &error);
test_error(error, "Unable to create local context");
// Set up some variables to catch the order in which callbacks are called
volatile int callbackOrders[3] = { 0, 0, 0 };
sDestructorIndex = 0;
// Set up the callbacks
error = clSetContextDestructorCallback(
localContext, context_destructor_callback, (void *)&callbackOrders[0]);
test_error(error, "Unable to set destructor callback");
error = clSetContextDestructorCallback(
localContext, context_destructor_callback, (void *)&callbackOrders[1]);
test_error(error, "Unable to set destructor callback");
error = clSetContextDestructorCallback(
localContext, context_destructor_callback, (void *)&callbackOrders[2]);
test_error(error, "Unable to set destructor callback");
// Now release the context, which SHOULD call the callbacks
error = clReleaseContext(localContext);
test_error(error, "Unable to release local context");
// Note: since we manually released the context, we need to set it to NULL
// to prevent a double-release
localContext = NULL;
// At this point, all three callbacks should have already been called
int numErrors = 0;
for (int i = 0; i < 3; i++)
{
// Spin waiting for the release to finish. If you don't call the
// context_destructor_callback, you will not pass the test.
log_info("\tWaiting for callback %d...\n", i);
int wait = 0;
while (0 == callbackOrders[i])
{
usleep(100000); // 1/10th second
if (++wait >= 10 * 10)
{
log_error("\tERROR: Callback %d was not called within 10 "
"seconds! Assuming failure.\n",
i + 1);
numErrors++;
break;
}
}
if (callbackOrders[i] != 3 - i)
{
log_error("\tERROR: Callback %d was called in the wrong order! "
"(Was called order %d, should have been order %d)\n",
i + 1, callbackOrders[i], 3 - i);
numErrors++;
}
}
return (numErrors > 0) ? TEST_FAIL : TEST_PASS;
}

71
test_conformance/api/test_mem_objects.cpp
View File

@@ -1,5 +1,5 @@
//
// Copyright (c) 2017 The Khronos Group Inc.
// Copyright (c) 2020 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.
@@ -21,61 +21,77 @@ void CL_CALLBACK mem_destructor_callback( cl_mem memObject, void * userData )
{
int *userPtr = (int *)userData;
// ordering of callbacks is guaranteed, meaning we don't need to do atomic operation here
// ordering of callbacks is guaranteed, meaning we don't need to do atomic
// operation here
*userPtr = ++sDestructorIndex;
}
#ifndef ABS
#define ABS( x ) ( ( x < 0 ) ? -x : x )
#endif
int test_mem_object_destructor_callback_single(clMemWrapper &memObject)
{
cl_int error;
int i;
// Set up some variables to catch the order in which callbacks are called
volatile int callbackOrders[3] = { 0, 0, 0 };
sDestructorIndex = 0;
// Set up the callbacks
error = clSetMemObjectDestructorCallback( memObject, mem_destructor_callback, (void*) &callbackOrders[ 0 ] );
error = clSetMemObjectDestructorCallback(memObject, mem_destructor_callback,
(void *)&callbackOrders[0]);
test_error(error, "Unable to set destructor callback");
error = clSetMemObjectDestructorCallback( memObject, mem_destructor_callback, (void*) &callbackOrders[ 1 ] );
error = clSetMemObjectDestructorCallback(memObject, mem_destructor_callback,
(void *)&callbackOrders[1]);
test_error(error, "Unable to set destructor callback");
error = clSetMemObjectDestructorCallback( memObject, mem_destructor_callback, (void*) &callbackOrders[ 2 ] );
error = clSetMemObjectDestructorCallback(memObject, mem_destructor_callback,
(void *)&callbackOrders[2]);
test_error(error, "Unable to set destructor callback");
// Now release the buffer, which SHOULD call the callbacks
error = clReleaseMemObject(memObject);
test_error(error, "Unable to release test buffer");
// Note: since we manually released the mem wrapper, we need to set it to NULL to prevent a double-release
// Note: since we manually released the mem wrapper, we need to set it to
// NULL to prevent a double-release
memObject = NULL;
// At this point, all three callbacks should have already been called
int numErrors = 0;
for( i = 0; i < 3; i++ )
for (int i = 0; i < 3; i++)
{
// Spin waiting for the release to finish. If you don't call the mem_destructor_callback, you will not
// pass the test. bugzilla 6316
// Spin waiting for the release to finish. If you don't call the
// mem_destructor_callback, you will not pass the test. bugzilla 6316
log_info("\tWaiting for callback %d...\n", i);
int wait = 0;
while (0 == callbackOrders[i])
{}
if( ABS( callbackOrders[ i ] ) != 3-i )
{
log_error( "\tERROR: Callback %d was called in the wrong order! (Was called order %d, should have been order %d)\n",
i+1, ABS( callbackOrders[ i ] ), i );
usleep(100000); // 1/10th second
if (++wait >= 10 * 10)
{
log_error("\tERROR: Callback %d was not called within 10 "
"seconds! Assuming failure.\n",
i + 1);
numErrors++;
break;
}
}
if (callbackOrders[i] != 3 - i)
{
log_error("\tERROR: Callback %d was called in the wrong order! "
"(Was called order %d, should have been order %d)\n",
i + 1, callbackOrders[i], 3 - i);
numErrors++;
}
}
return ( numErrors > 0 ) ? -1 : 0;
return (numErrors > 0) ? TEST_FAIL : TEST_PASS;
}
int test_mem_object_destructor_callback(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements)
int test_mem_object_destructor_callback(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements)
{
clMemWrapper testBuffer, testImage;
cl_int error;
@@ -85,24 +101,25 @@ int test_mem_object_destructor_callback(cl_device_id deviceID, cl_context contex
testBuffer = clCreateBuffer(context, CL_MEM_READ_WRITE, 1024, NULL, &error);
test_error(error, "Unable to create testing buffer");
if( test_mem_object_destructor_callback_single( testBuffer ) != 0 )
if (test_mem_object_destructor_callback_single(testBuffer) != TEST_PASS)
{
log_error("ERROR: Destructor callbacks for buffer object FAILED\n");
return -1;
return TEST_FAIL;
}
if (checkForImageSupport(deviceID) == 0)
{
cl_image_format imageFormat = { CL_RGBA, CL_SIGNED_INT8 };
testImage = create_image_2d( context, CL_MEM_READ_ONLY, &imageFormat, 16, 16, 0, NULL, &error );
testImage = create_image_2d(context, CL_MEM_READ_ONLY, &imageFormat, 16,
16, 0, NULL, &error);
test_error(error, "Unable to create testing image");
if( test_mem_object_destructor_callback_single( testImage ) != 0 )
if (test_mem_object_destructor_callback_single(testImage) != TEST_PASS)
{
log_error("ERROR: Destructor callbacks for image object FAILED\n");
return -1;
return TEST_FAIL;
}
}
return 0;
return TEST_PASS;
}