ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Migrate events suite to the new test registration framework (#2324)

Browse Source 
Contributes to #2181.

Signed-off-by: Ahmed Hesham <ahmed.hesham@arm.com>
This commit is contained in:
Ahmed Hesham
2025-03-11 21:57:59 +00:00
committed by GitHub
parent bb331c2c92
commit c4fa48db05
9 changed files with 95 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
test_conformance/events/main.cpp
View File

@@ -13,57 +13,10 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
// //
#include "harness/compat.h"
#include <stdio.h>
#include <string.h>
#include "procs.h"
#include "harness/testHarness.h" #include "harness/testHarness.h"
#if !defined(_WIN32)
#include <unistd.h>
#endif
test_definition test_list[] = {
ADD_TEST(event_get_execute_status),
ADD_TEST(event_get_write_array_status),
ADD_TEST(event_get_read_array_status),
ADD_TEST(event_get_info),
ADD_TEST(event_wait_for_execute),
ADD_TEST(event_wait_for_array),
ADD_TEST(event_flush),
ADD_TEST(event_finish_execute),
ADD_TEST(event_finish_array),
ADD_TEST(event_release_before_done),
ADD_TEST(event_enqueue_marker),
#ifdef CL_VERSION_1_2
ADD_TEST(event_enqueue_marker_with_event_list),
ADD_TEST(event_enqueue_barrier_with_event_list),
#endif
ADD_TEST(out_of_order_event_waitlist_single_queue),
ADD_TEST(out_of_order_event_waitlist_multi_queue),
ADD_TEST(out_of_order_event_waitlist_multi_queue_multi_device),
ADD_TEST(out_of_order_event_enqueue_wait_for_events_single_queue),
ADD_TEST(out_of_order_event_enqueue_wait_for_events_multi_queue),
ADD_TEST(
out_of_order_event_enqueue_wait_for_events_multi_queue_multi_device),
ADD_TEST(out_of_order_event_enqueue_marker_single_queue),
ADD_TEST(out_of_order_event_enqueue_marker_multi_queue),
ADD_TEST(out_of_order_event_enqueue_marker_multi_queue_multi_device),
ADD_TEST(out_of_order_event_enqueue_barrier_single_queue),
ADD_TEST(waitlists),
ADD_TEST(userevents),
ADD_TEST(callbacks),
ADD_TEST(callbacks_simultaneous),
ADD_TEST(userevents_multithreaded),
ADD_TEST(callback_on_error_simple),
ADD_TEST(callback_on_error_enqueue_command)
};
const int test_num = ARRAY_SIZE(test_list);
int main(int argc, const char *argv[]) int main(int argc, const char *argv[])
{ {
return runTestHarness(argc, argv, test_num, test_list, false, 0); return runTestHarness(argc, argv, test_registry::getInstance().num_tests(),
test_registry::getInstance().definitions(), false, 0);
} }

126
test_conformance/events/procs.h
View File

@@ -1,126 +0,0 @@
//
// 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 "harness/errorHelpers.h"
#include "harness/kernelHelpers.h"
#include "harness/typeWrappers.h"
#include "harness/clImageHelper.h"
extern float random_float(float low, float high);
extern float calculate_ulperror(float a, float b);
extern int test_event_get_execute_status(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_get_write_array_status(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_get_read_array_status(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_get_info(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_event_wait_for_execute(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_wait_for_array(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_event_flush(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_event_finish_execute(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_event_finish_array(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_event_release_before_done(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_enqueue_marker(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
#ifdef CL_VERSION_1_2
extern int test_event_enqueue_marker_with_event_list(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_enqueue_barrier_with_event_list(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
#endif
extern int test_out_of_order_event_waitlist_single_queue(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_waitlist_multi_queue(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_waitlist_multi_queue_multi_device(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_enqueue_wait_for_events_single_queue(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_enqueue_wait_for_events_multi_queue(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_out_of_order_event_enqueue_wait_for_events_multi_queue_multi_device(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_enqueue_barrier_single_queue(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_enqueue_marker_single_queue(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_enqueue_marker_multi_queue(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_out_of_order_event_enqueue_marker_multi_queue_multi_device(
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_waitlists(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_userevents(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_callbacks(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_callbacks_simultaneous(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_userevents_multithreaded(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_callback_on_error_simple(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_callback_on_error_enqueue_command(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);

9
test_conformance/events/testBase.h
View File

@@ -17,12 +17,7 @@
#define _testBase_h #define _testBase_h
#include "harness/compat.h" #include "harness/compat.h"
#include "harness/testHarness.h"
#include <stdio.h> #include "harness/typeWrappers.h"
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "procs.h"
#endif // _testBase_h #endif // _testBase_h

33
test_conformance/events/test_callbacks.cpp
View File

@@ -82,8 +82,9 @@ void CL_CALLBACK combuf_event_callback_function(cl_event event,
*pdata = true; *pdata = true;
} }
int test_callback_event_single(cl_device_id device, cl_context context, static int test_callback_event_single(cl_device_id device, cl_context context,
cl_command_queue queue, Action *actionToTest) cl_command_queue queue,
Action *actionToTest)
{ {
// Note: we don't use the waiting feature here. We just want to verify that // Note: we don't use the waiting feature here. We just want to verify that
// we get a callback called when the given event finishes // we get a callback called when the given event finishes
@@ -163,15 +164,14 @@ int test_callback_event_single(cl_device_id device, cl_context context,
{ \ { \
name##Action action; \ name##Action action; \
log_info("-- Testing " #name "...\n"); \ log_info("-- Testing " #name "...\n"); \
if ((error = test_callback_event_single(deviceID, context, queue, \ if ((error = \
&action)) \ test_callback_event_single(device, context, queue, &action)) \
!= CL_SUCCESS) \ != CL_SUCCESS) \
retVal++; \ retVal++; \
clFinish(queue); \ clFinish(queue); \
} }
int test_callbacks(cl_device_id deviceID, cl_context context, REGISTER_TEST(callbacks)
cl_command_queue queue, int num_elements)
{ {
cl_int error; cl_int error;
int retVal = 0; int retVal = 0;
@@ -185,7 +185,7 @@ int test_callbacks(cl_device_id deviceID, cl_context context,
TEST_ACTION(MapBuffer) TEST_ACTION(MapBuffer)
TEST_ACTION(UnmapBuffer) TEST_ACTION(UnmapBuffer)
if (checkForImageSupport(deviceID) == CL_IMAGE_FORMAT_NOT_SUPPORTED) if (checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED)
{ {
log_info("\nNote: device does not support images. Skipping remainder " log_info("\nNote: device does not support images. Skipping remainder "
"of callback tests...\n"); "of callback tests...\n");
@@ -199,7 +199,7 @@ int test_callbacks(cl_device_id deviceID, cl_context context,
TEST_ACTION(CopyBufferTo2DImage) TEST_ACTION(CopyBufferTo2DImage)
TEST_ACTION(MapImage) TEST_ACTION(MapImage)
if (checkFor3DImageSupport(deviceID) == CL_IMAGE_FORMAT_NOT_SUPPORTED) if (checkFor3DImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED)
log_info("\nNote: device does not support 3D images. Skipping " log_info("\nNote: device does not support 3D images. Skipping "
"remainder of waitlist tests...\n"); "remainder of waitlist tests...\n");
else else
@@ -237,8 +237,7 @@ void CL_CALLBACK simultaneous_event_callback_function(cl_event event,
ThreadPool_AtomicAdd(&sSimultaneousCount, 1); ThreadPool_AtomicAdd(&sSimultaneousCount, 1);
} }
int test_callbacks_simultaneous(cl_device_id deviceID, cl_context context, REGISTER_TEST(callbacks_simultaneous)
cl_command_queue queue, int num_elements)
{ {
cl_int error; cl_int error;
@@ -255,7 +254,7 @@ int test_callbacks_simultaneous(cl_device_id deviceID, cl_context context,
actions[index++] = new MapBufferAction(); actions[index++] = new MapBufferAction();
actions[index++] = new UnmapBufferAction(); actions[index++] = new UnmapBufferAction();
if (checkForImageSupport(deviceID) != CL_IMAGE_FORMAT_NOT_SUPPORTED) if (checkForImageSupport(device) != CL_IMAGE_FORMAT_NOT_SUPPORTED)
{ {
actions[index++] = new ReadImage2DAction(); actions[index++] = new ReadImage2DAction();
actions[index++] = new WriteImage2DAction(); actions[index++] = new WriteImage2DAction();
@@ -264,7 +263,7 @@ int test_callbacks_simultaneous(cl_device_id deviceID, cl_context context,
actions[index++] = new CopyBufferTo2DImageAction(); actions[index++] = new CopyBufferTo2DImageAction();
actions[index++] = new MapImageAction(); actions[index++] = new MapImageAction();
if (checkFor3DImageSupport(deviceID) != CL_IMAGE_FORMAT_NOT_SUPPORTED) if (checkFor3DImageSupport(device) != CL_IMAGE_FORMAT_NOT_SUPPORTED)
{ {
actions[index++] = new ReadImage3DAction(); actions[index++] = new ReadImage3DAction();
actions[index++] = new WriteImage3DAction(); actions[index++] = new WriteImage3DAction();
@@ -282,7 +281,7 @@ int test_callbacks_simultaneous(cl_device_id deviceID, cl_context context,
log_info("\tSetting up test events...\n"); log_info("\tSetting up test events...\n");
for (index = 0; actions[index] != NULL; index++) for (index = 0; actions[index] != NULL; index++)
{ {
error = actions[index]->Setup(deviceID, context, queue); error = actions[index]->Setup(device, context, queue);
test_error(error, "Unable to set up test action"); test_error(error, "Unable to set up test action");
sSimultaneousFlags[index] = false; sSimultaneousFlags[index] = false;
} }
@@ -384,8 +383,7 @@ int test_callbacks_simultaneous(cl_device_id deviceID, cl_context context,
return -1; return -1;
} }
int test_callback_on_error_simple(cl_device_id deviceID, cl_context context, REGISTER_TEST(callback_on_error_simple)
cl_command_queue queue, int num_elements)
{ {
cl_int error = CL_SUCCESS; cl_int error = CL_SUCCESS;
clEventWrapper user_event = clCreateUserEvent(context, &error); clEventWrapper user_event = clCreateUserEvent(context, &error);
@@ -412,10 +410,7 @@ int test_callback_on_error_simple(cl_device_id deviceID, cl_context context,
return CL_SUCCESS; return CL_SUCCESS;
} }
int test_callback_on_error_enqueue_command(cl_device_id deviceID, REGISTER_TEST(callback_on_error_enqueue_command)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
cl_int error = CL_SUCCESS; cl_int error = CL_SUCCESS;
bool confirmation = false; bool confirmation = false;

116
test_conformance/events/test_event_dependencies.cpp
View File

@@ -44,7 +44,7 @@ const char *write_kernels[] = {
them (only for single queue). If neither are set, nothing is done to prevent them (only for single queue). If neither are set, nothing is done to prevent
them from executing in the wrong order. This can be used for verification. them from executing in the wrong order. This can be used for verification.
*/ */
int test_event_enqueue_wait_for_events_run_test( static int test_event_enqueue_wait_for_events_run_test(
cl_device_id deviceID, cl_context context, cl_command_queue queue, cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements, int two_queues, int two_devices, int num_elements, int two_queues, int two_devices,
int test_enqueue_wait_for_events, int test_barrier, int use_waitlist, int test_enqueue_wait_for_events, int test_barrier, int use_waitlist,
@@ -473,10 +473,10 @@ int test_event_enqueue_wait_for_events_run_test(
return failed; return failed;
} }
int test(cl_device_id deviceID, cl_context context, cl_command_queue queue, static int run_test(cl_device_id deviceID, cl_context context,
int num_elements, int two_queues, int two_devices, cl_command_queue queue, int num_elements, int two_queues,
int test_enqueue_wait_for_events, int test_barrier, int use_waitlists, int two_devices, int test_enqueue_wait_for_events,
int use_marker) int test_barrier, int use_waitlists, int use_marker)
{ {
if (!checkDeviceForQueueSupport(deviceID, if (!checkDeviceForQueueSupport(deviceID,
CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE)) CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE))
@@ -548,10 +548,7 @@ int test(cl_device_id deviceID, cl_context context, cl_command_queue queue,
} }
int test_out_of_order_event_waitlist_single_queue(cl_device_id deviceID, REGISTER_TEST(out_of_order_event_waitlist_single_queue)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
int two_queues = 0; int two_queues = 0;
int two_devices = 0; int two_devices = 0;
@@ -559,15 +556,12 @@ int test_out_of_order_event_waitlist_single_queue(cl_device_id deviceID,
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 1; int use_waitlists = 1;
int use_marker = 0; int use_marker = 0;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_waitlist_multi_queue(cl_device_id deviceID, REGISTER_TEST(out_of_order_event_waitlist_multi_queue)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
int two_queues = 1; int two_queues = 1;
int two_devices = 0; int two_devices = 0;
@@ -575,14 +569,12 @@ int test_out_of_order_event_waitlist_multi_queue(cl_device_id deviceID,
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 1; int use_waitlists = 1;
int use_marker = 0; int use_marker = 0;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_waitlist_multi_queue_multi_device( REGISTER_TEST(out_of_order_event_waitlist_multi_queue_multi_device)
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements)
{ {
int two_queues = 1; int two_queues = 1;
int two_devices = 1; int two_devices = 1;
@@ -590,15 +582,13 @@ int test_out_of_order_event_waitlist_multi_queue_multi_device(
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 1; int use_waitlists = 1;
int use_marker = 0; int use_marker = 0;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_enqueue_wait_for_events_single_queue( REGISTER_TEST(out_of_order_event_enqueue_wait_for_events_single_queue)
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements)
{ {
int two_queues = 0; int two_queues = 0;
int two_devices = 0; int two_devices = 0;
@@ -606,14 +596,12 @@ int test_out_of_order_event_enqueue_wait_for_events_single_queue(
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 0; int use_waitlists = 0;
int use_marker = 0; int use_marker = 0;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_enqueue_wait_for_events_multi_queue( REGISTER_TEST(out_of_order_event_enqueue_wait_for_events_multi_queue)
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements)
{ {
int two_queues = 1; int two_queues = 1;
int two_devices = 0; int two_devices = 0;
@@ -621,15 +609,14 @@ int test_out_of_order_event_enqueue_wait_for_events_multi_queue(
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 0; int use_waitlists = 0;
int use_marker = 0; int use_marker = 0;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_enqueue_wait_for_events_multi_queue_multi_device( REGISTER_TEST(
cl_device_id deviceID, cl_context context, cl_command_queue queue, out_of_order_event_enqueue_wait_for_events_multi_queue_multi_device)
int num_elements)
{ {
int two_queues = 1; int two_queues = 1;
int two_devices = 1; int two_devices = 1;
@@ -637,16 +624,13 @@ int test_out_of_order_event_enqueue_wait_for_events_multi_queue_multi_device(
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 0; int use_waitlists = 0;
int use_marker = 0; int use_marker = 0;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_enqueue_barrier_single_queue(cl_device_id deviceID, REGISTER_TEST(out_of_order_event_enqueue_barrier_single_queue)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
int two_queues = 0; int two_queues = 0;
int two_devices = 0; int two_devices = 0;
@@ -654,16 +638,13 @@ int test_out_of_order_event_enqueue_barrier_single_queue(cl_device_id deviceID,
int test_barrier = 1; int test_barrier = 1;
int use_waitlists = 0; int use_waitlists = 0;
int use_marker = 0; int use_marker = 0;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_enqueue_marker_single_queue(cl_device_id deviceID, REGISTER_TEST(out_of_order_event_enqueue_marker_single_queue)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
int two_queues = 0; int two_queues = 0;
int two_devices = 0; int two_devices = 0;
@@ -671,15 +652,12 @@ int test_out_of_order_event_enqueue_marker_single_queue(cl_device_id deviceID,
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 0; int use_waitlists = 0;
int use_marker = 1; int use_marker = 1;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_enqueue_marker_multi_queue(cl_device_id deviceID, REGISTER_TEST(out_of_order_event_enqueue_marker_multi_queue)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
int two_queues = 1; int two_queues = 1;
int two_devices = 0; int two_devices = 0;
@@ -687,15 +665,13 @@ int test_out_of_order_event_enqueue_marker_multi_queue(cl_device_id deviceID,
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 0; int use_waitlists = 0;
int use_marker = 1; int use_marker = 1;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }
int test_out_of_order_event_enqueue_marker_multi_queue_multi_device( REGISTER_TEST(out_of_order_event_enqueue_marker_multi_queue_multi_device)
cl_device_id deviceID, cl_context context, cl_command_queue queue,
int num_elements)
{ {
int two_queues = 1; int two_queues = 1;
int two_devices = 1; int two_devices = 1;
@@ -703,7 +679,7 @@ int test_out_of_order_event_enqueue_marker_multi_queue_multi_device(
int test_barrier = 0; int test_barrier = 0;
int use_waitlists = 0; int use_waitlists = 0;
int use_marker = 1; int use_marker = 1;
return test(deviceID, context, queue, num_elements, two_queues, two_devices, return run_test(device, context, queue, num_elements, two_queues,
test_enqueue_wait_for_events, test_barrier, use_waitlists, two_devices, test_enqueue_wait_for_events, test_barrier,
use_marker); use_waitlists, use_marker);
} }

43
test_conformance/events/test_events.cpp
View File

@@ -102,8 +102,7 @@ const char *IGetStatusString(cl_int status)
} }
/* Note: tests clGetEventStatus and clReleaseEvent (implicitly) */ /* Note: tests clGetEventStatus and clReleaseEvent (implicitly) */
int test_event_get_execute_status(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_get_execute_status)
cl_command_queue queue, int num_elements)
{ {
cl_int status; cl_int status;
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
@@ -128,8 +127,7 @@ int test_event_get_execute_status(cl_device_id deviceID, cl_context context,
return 0; return 0;
} }
int test_event_get_info(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_get_info)
cl_command_queue queue, int num_elements)
{ {
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
@@ -204,8 +202,7 @@ int test_event_get_info(cl_device_id deviceID, cl_context context,
return 0; return 0;
} }
int test_event_get_write_array_status(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_get_write_array_status)
cl_command_queue queue, int num_elements)
{ {
cl_mem stream; cl_mem stream;
cl_float testArray[1024 * 32]; cl_float testArray[1024 * 32];
@@ -246,8 +243,7 @@ int test_event_get_write_array_status(cl_device_id deviceID, cl_context context,
return 0; return 0;
} }
int test_event_get_read_array_status(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_get_read_array_status)
cl_command_queue queue, int num_elements)
{ {
cl_mem stream; cl_mem stream;
cl_float testArray[1024 * 32]; cl_float testArray[1024 * 32];
@@ -305,8 +301,7 @@ int test_event_get_read_array_status(cl_device_id deviceID, cl_context context,
/* clGetEventStatus not implemented yet */ /* clGetEventStatus not implemented yet */
int test_event_wait_for_execute(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_wait_for_execute)
cl_command_queue queue, int num_elements)
{ {
cl_int status; cl_int status;
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
@@ -331,8 +326,7 @@ int test_event_wait_for_execute(cl_device_id deviceID, cl_context context,
return 0; return 0;
} }
int test_event_wait_for_array(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_wait_for_array)
cl_command_queue queue, int num_elements)
{ {
cl_mem streams[2]; cl_mem streams[2];
cl_float readArray[1024 * 32]; cl_float readArray[1024 * 32];
@@ -419,8 +413,7 @@ int test_event_wait_for_array(cl_device_id deviceID, cl_context context,
return 0; return 0;
} }
int test_event_flush(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_flush)
cl_command_queue queue, int num_elements)
{ {
cl_int status; cl_int status;
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
@@ -472,8 +465,7 @@ int test_event_flush(cl_device_id deviceID, cl_context context,
} }
int test_event_finish_execute(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_finish_execute)
cl_command_queue queue, int num_elements)
{ {
cl_int status; cl_int status;
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
@@ -498,8 +490,7 @@ int test_event_finish_execute(cl_device_id deviceID, cl_context context,
return 0; return 0;
} }
int test_event_finish_array(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_finish_array)
cl_command_queue queue, int num_elements)
{ {
cl_mem streams[2]; cl_mem streams[2];
cl_float readArray[1024 * 32]; cl_float readArray[1024 * 32];
@@ -589,8 +580,7 @@ int test_event_finish_array(cl_device_id deviceID, cl_context context,
#define NUM_EVENT_RUNS 100 #define NUM_EVENT_RUNS 100
int test_event_release_before_done(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_release_before_done)
cl_command_queue queue, int num_elements)
{ {
// Create a kernel to run // Create a kernel to run
clProgramWrapper program; clProgramWrapper program;
@@ -680,8 +670,7 @@ int test_event_release_before_done(cl_device_id deviceID, cl_context context,
return 0; return 0;
} }
int test_event_enqueue_marker(cl_device_id deviceID, cl_context context, REGISTER_TEST(event_enqueue_marker)
cl_command_queue queue, int num_elements)
{ {
cl_int status; cl_int status;
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
@@ -718,10 +707,7 @@ int test_event_enqueue_marker(cl_device_id deviceID, cl_context context,
} }
#ifdef CL_VERSION_1_2 #ifdef CL_VERSION_1_2
int test_event_enqueue_marker_with_event_list(cl_device_id deviceID, REGISTER_TEST(event_enqueue_marker_with_event_list)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
cl_event event_list[3] = { NULL, NULL, NULL }; cl_event event_list[3] = { NULL, NULL, NULL };
@@ -771,10 +757,7 @@ int test_event_enqueue_marker_with_event_list(cl_device_id deviceID,
return 0; return 0;
} }
int test_event_enqueue_barrier_with_event_list(cl_device_id deviceID, REGISTER_TEST(event_enqueue_barrier_with_event_list)
cl_context context,
cl_command_queue queue,
int num_elements)
{ {
SETUP_EVENT(context, queue); SETUP_EVENT(context, queue);
cl_event event_list[3] = { NULL, NULL, NULL }; cl_event event_list[3] = { NULL, NULL, NULL };

3
test_conformance/events/test_userevents.cpp
View File

@@ -78,8 +78,7 @@ enum
MaxDevices = 8 MaxDevices = 8
}; };
int test_userevents(cl_device_id deviceID, cl_context context, REGISTER_TEST(userevents)
cl_command_queue queue, int num_elements)
{ {
cl_int err; cl_int err;

5
test_conformance/events/test_userevents_multithreaded.cpp
View File

@@ -30,8 +30,7 @@ void trigger_user_event(cl_event *event)
clSetUserEventStatus(*event, CL_COMPLETE); clSetUserEventStatus(*event, CL_COMPLETE);
} }
int test_userevents_multithreaded(cl_device_id deviceID, cl_context context, REGISTER_TEST(userevents_multithreaded)
cl_command_queue queue, int num_elements)
{ {
cl_int error; cl_int error;
@@ -50,7 +49,7 @@ int test_userevents_multithreaded(cl_device_id deviceID, cl_context context,
for (int i = 0; actions[i] != NULL; i++) for (int i = 0; actions[i] != NULL; i++)
{ {
error = actions[i]->Setup(deviceID, context, queue); error = actions[i]->Setup(device, context, queue);
test_error(error, "Unable to set up test action"); test_error(error, "Unable to set up test action");
error = actions[i]->Execute(queue, 1, &gateEvent, &actionEvents[i]); error = actions[i]->Execute(queue, 1, &gateEvent, &actionEvents[i]);

28
test_conformance/events/test_waitlists.cpp
View File

@@ -21,8 +21,9 @@ extern const char *IGetStatusString(cl_int status);
#define PRINT_OPS 0 #define PRINT_OPS 0
int test_waitlist(cl_device_id device, cl_context context, static int test_waitlist(cl_device_id device, cl_context context,
cl_command_queue queue, Action *actionToTest, bool multiple) cl_command_queue queue, Action *actionToTest,
bool multiple)
{ {
NDRangeKernelAction actions[2]; NDRangeKernelAction actions[2];
clEventWrapper events[3]; clEventWrapper events[3];
@@ -314,38 +315,39 @@ int test_waitlist(cl_device_id device, cl_context context,
{ \ { \
name##Action action; \ name##Action action; \
log_info("-- Testing " #name " (waiting on 1 event)...\n"); \ log_info("-- Testing " #name " (waiting on 1 event)...\n"); \
if ((error = test_waitlist(deviceID, context, queue, &action, false)) \ if ((error = \
test_waitlist(device, context, test_queue, &action, false)) \
!= CL_SUCCESS) \ != CL_SUCCESS) \
retVal++; \ retVal++; \
clFinish(queue); \ clFinish(test_queue); \
} \ } \
if (error \ if (error \
== CL_SUCCESS) /* Only run multiples test if single test passed */ \ == CL_SUCCESS) /* Only run multiples test if single test passed */ \
{ \ { \
name##Action action; \ name##Action action; \
log_info("-- Testing " #name " (waiting on 2 events)...\n"); \ log_info("-- Testing " #name " (waiting on 2 events)...\n"); \
if ((error = test_waitlist(deviceID, context, queue, &action, true)) \ if ((error = \
test_waitlist(device, context, test_queue, &action, true)) \
!= CL_SUCCESS) \ != CL_SUCCESS) \
retVal++; \ retVal++; \
clFinish(queue); \ clFinish(test_queue); \
} }
int test_waitlists(cl_device_id deviceID, cl_context context, REGISTER_TEST(waitlists)
cl_command_queue oldQueue, int num_elements)
{ {
cl_int error; cl_int error;
int retVal = 0; int retVal = 0;
cl_command_queue_properties props = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE; cl_command_queue_properties props = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
if (!checkDeviceForQueueSupport(deviceID, props)) if (!checkDeviceForQueueSupport(device, props))
{ {
log_info("WARNING: Device does not support out-of-order exec mode; " log_info("WARNING: Device does not support out-of-order exec mode; "
"skipping test.\n"); "skipping test.\n");
return 0; return 0;
} }
clCommandQueueWrapper queue = clCommandQueueWrapper test_queue =
clCreateCommandQueue(context, deviceID, props, &error); clCreateCommandQueue(context, device, props, &error);
test_error(error, "Unable to create out-of-order queue"); test_error(error, "Unable to create out-of-order queue");
log_info("\n"); log_info("\n");
@@ -357,7 +359,7 @@ int test_waitlists(cl_device_id deviceID, cl_context context,
TEST_ACTION(MapBuffer) TEST_ACTION(MapBuffer)
TEST_ACTION(UnmapBuffer) TEST_ACTION(UnmapBuffer)
if (checkForImageSupport(deviceID) == CL_IMAGE_FORMAT_NOT_SUPPORTED) if (checkForImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED)
{ {
log_info("\nNote: device does not support images. Skipping remainder " log_info("\nNote: device does not support images. Skipping remainder "
"of waitlist tests...\n"); "of waitlist tests...\n");
@@ -371,7 +373,7 @@ int test_waitlists(cl_device_id deviceID, cl_context context,
TEST_ACTION(CopyBufferTo2DImage) TEST_ACTION(CopyBufferTo2DImage)
TEST_ACTION(MapImage) TEST_ACTION(MapImage)
if (checkFor3DImageSupport(deviceID) == CL_IMAGE_FORMAT_NOT_SUPPORTED) if (checkFor3DImageSupport(device) == CL_IMAGE_FORMAT_NOT_SUPPORTED)
log_info("Device does not support 3D images. Skipping remainder of " log_info("Device does not support 3D images. Skipping remainder of "
"waitlist tests...\n"); "waitlist tests...\n");
else else