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

Merge branch 'main' into paulfradgley-semaphore_export_types

Browse Source
This commit is contained in:
Ben Ashbaugh
2023-06-12 23:28:09 -07:00
committed by GitHub
parent 0357ff485f 475a37abbf
commit 72bfaa4a6a
83 changed files with 3695 additions and 6875 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.h
View File

@@ -13,8 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef _CL_KHR_BASIC_COMMAND_BUFFER_H
#define _CL_KHR_BASIC_COMMAND_BUFFER_H
#ifndef CL_KHR_BASIC_COMMAND_BUFFER_H
#define CL_KHR_BASIC_COMMAND_BUFFER_H
#include "command_buffer_test_base.h"
#include "harness/typeWrappers.h"
@@ -28,7 +28,7 @@
{ \
if (reference != result) \
{ \
log_error("Expected %d was %d at index %u\n", reference, result, \
log_error("Expected %d was %d at index %zu\n", reference, result, \
index); \
return TEST_FAIL; \
} \
@@ -99,4 +99,4 @@ int MakeAndRunTest(cl_device_id device, cl_context context,
return TEST_PASS;
}
#endif // _CL_KHR_BASIC_COMMAND_BUFFER_H
#endif // CL_KHR_BASIC_COMMAND_BUFFER_H

6
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_basic.h
View File

@@ -13,8 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef _CL_KHR_MUTABLE_COMMAND_BASIC_H
#define _CL_KHR_MUTABLE_COMMAND_BASIC_H
#ifndef CL_KHR_MUTABLE_COMMAND_BASIC_H
#define CL_KHR_MUTABLE_COMMAND_BASIC_H
#include "../basic_command_buffer.h"
#include "../command_buffer_test_base.h"
@@ -104,4 +104,4 @@ struct BasicMutableCommandBufferTest : BasicCommandBufferTest
const size_t global_work_size = 4 * sizeof(cl_int);
};
#endif //_CL_KHR_MUTABLE_COMMAND_BASIC_H
#endif // CL_KHR_MUTABLE_COMMAND_BASIC_H

6
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/procs.h
View File

@@ -13,8 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef _CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H
#define _CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H
#ifndef CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H
#define CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H
#include <CL/cl.h>
@@ -59,4 +59,4 @@ extern int test_mutable_command_info_global_work_size(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
#endif /*_CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H*/
#endif // CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H

10
test_conformance/extensions/cl_khr_command_buffer/command_buffer_get_command_buffer_info.cpp
View File

@@ -240,9 +240,10 @@ struct CommandBufferGetCommandBufferInfo : public BasicCommandBufferTest
clEventWrapper trigger_event = clCreateUserEvent(context, &error);
test_error(error, "clCreateUserEvent failed");
clEventWrapper execute_event;
// enqueued command buffer blocked on user event
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 1,
&trigger_event, nullptr);
&trigger_event, &execute_event);
test_error(error, "clEnqueueCommandBufferKHR failed");
// verify pending state
@@ -255,6 +256,13 @@ struct CommandBufferGetCommandBufferInfo : public BasicCommandBufferTest
test_error(signal_error, "clSetUserEventStatus failed");
error = clWaitForEvents(1, &execute_event);
test_error(error, "Unable to wait for execute event");
// verify executable state
error = verify_state(CL_COMMAND_BUFFER_STATE_EXECUTABLE_KHR);
test_error(error, "verify_state failed");
return CL_SUCCESS;
}

6
test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_base.h
View File

@@ -13,8 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef _CL_KHR_COMMAND_BUFFER_TEST_BASE_H
#define _CL_KHR_COMMAND_BUFFER_TEST_BASE_H
#ifndef CL_KHR_COMMAND_BUFFER_TEST_BASE_H
#define CL_KHR_COMMAND_BUFFER_TEST_BASE_H
#include <CL/cl_ext.h>
#include "harness/deviceInfo.h"
@@ -174,4 +174,4 @@ public:
}
#endif // _CL_KHR_COMMAND_BUFFER_TEST_BASE_H
#endif // CL_KHR_COMMAND_BUFFER_TEST_BASE_H

6
test_conformance/extensions/cl_khr_command_buffer/procs.h
View File

@@ -13,8 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef _CL_KHR_COMMAND_BUFFER_PROCS_H
#define _CL_KHR_COMMAND_BUFFER_PROCS_H
#ifndef CL_KHR_COMMAND_BUFFER_PROCS_H
#define CL_KHR_COMMAND_BUFFER_PROCS_H
#include <CL/cl.h>
@@ -131,4 +131,4 @@ extern int test_event_info_reference_count(cl_device_id device,
cl_command_queue queue,
int num_elements);
#endif /*_CL_KHR_COMMAND_BUFFER_PROCS_H*/
#endif // CL_KHR_COMMAND_BUFFER_PROCS_H

6
test_conformance/extensions/cl_khr_external_semaphore/procs.h
View File

@@ -13,8 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef _CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H
#define _CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H
#ifndef CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H
#define CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H
#include <CL/cl.h>
@@ -79,4 +79,4 @@ extern int test_external_semaphores_invalid_command(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
#endif /* CL_KHR_EXTERNAL_SEMAPHORE */
#endif // CL_KHR_EXTERNAL_SEMAPHORE_PROCS_H

6
test_conformance/extensions/cl_khr_semaphore/main.cpp
View File

@@ -1,5 +1,5 @@
//
// Copyright (c) 2017 The Khronos Group Inc.
// Copyright (c) 2023 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.
@@ -34,11 +34,7 @@ test_definition test_list[] = {
ADD_TEST_VERSION(semaphores_multi_signal, Version(1, 2)),
ADD_TEST_VERSION(semaphores_multi_wait, Version(1, 2)),
ADD_TEST_VERSION(semaphores_queries, Version(1, 2)),
ADD_TEST_VERSION(semaphores_order_1, Version(1, 2)),
ADD_TEST_VERSION(semaphores_order_2, Version(1, 2)),
ADD_TEST_VERSION(semaphores_order_3, Version(1, 2)),
ADD_TEST_VERSION(semaphores_import_export_fd, Version(1, 2)),
ADD_TEST_VERSION(semaphores_invalid_command, Version(1, 2)),
};
const int test_num = ARRAY_SIZE(test_list);

12
test_conformance/extensions/cl_khr_semaphore/procs.h
View File

@@ -1,5 +1,5 @@
//
// Copyright (c) 2017 The Khronos Group Inc.
// Copyright (c) 2023 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.
@@ -41,17 +41,7 @@ extern int test_semaphores_multi_wait(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_semaphores_queries(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_semaphores_order_1(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_semaphores_order_2(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_semaphores_order_3(cl_device_id deviceID, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_semaphores_import_export_fd(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_semaphores_invalid_command(cl_device_id deviceID,
cl_context context,
cl_command_queue queue,
int num_elements);

299
test_conformance/extensions/cl_khr_semaphore/test_semaphores.cpp
View File

@@ -1,5 +1,5 @@
//
// Copyright (c) 2022 The Khronos Group Inc.
// Copyright (c) 2023 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.
@@ -646,303 +646,6 @@ int test_semaphores_queries(cl_device_id deviceID, cl_context context,
return TEST_PASS;
}
// Confirm that it is possible to enqueue a signal of wait and signal in any
// order as soon as the submission order (after deferred dependencies) is
// correct. Case: first one deferred wait, then one non deferred signal.
int test_semaphores_order_1(cl_device_id deviceID, cl_context context,
cl_command_queue defaultQueue, int num_elements)
{
cl_int err;
if (!is_extension_available(deviceID, "cl_khr_semaphore"))
{
log_info("cl_khr_semaphore is not supported on this platoform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
// Obtain pointers to semaphore's API
GET_PFN(deviceID, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR);
GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR);
GET_PFN(deviceID, clReleaseSemaphoreKHR);
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create semaphore
cl_semaphore_properties_khr sema_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_BINARY_KHR),
0
};
cl_semaphore_khr sema =
clCreateSemaphoreWithPropertiesKHR(context, sema_props, &err);
test_error(err, "Could not create semaphore");
// Create user event
clEventWrapper user_event = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Wait semaphore (dependency on user_event)
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema, nullptr, 1, &user_event,
&wait_event);
test_error(err, "Could not wait semaphore");
// Signal semaphore
clEventWrapper signal_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema, nullptr, 0, nullptr,
&signal_event);
test_error(err, "Could not signal semaphore");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure signal event is completed while wait event is not
test_assert_event_complete(signal_event);
test_assert_event_inprogress(wait_event);
// Complete user_event
err = clSetUserEventStatus(user_event, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(signal_event);
test_assert_event_complete(wait_event);
// Release semaphore
err = clReleaseSemaphoreKHR(sema);
test_error(err, "Could not release semaphore");
return TEST_PASS;
}
// Confirm that it is possible to enqueue a signal of wait and signal in any
// order as soon as the submission order (after deferred dependencies) is
// correct. Case: first two deferred signals, then one deferred wait. Unblock
// signal, then unblock wait. When wait completes, unblock the other signal.
int test_semaphores_order_2(cl_device_id deviceID, cl_context context,
cl_command_queue defaultQueue, int num_elements)
{
cl_int err;
if (!is_extension_available(deviceID, "cl_khr_semaphore"))
{
log_info("cl_khr_semaphore is not supported on this platoform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
// Obtain pointers to semaphore's API
GET_PFN(deviceID, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR);
GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR);
GET_PFN(deviceID, clReleaseSemaphoreKHR);
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create semaphore
cl_semaphore_properties_khr sema_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_BINARY_KHR),
0
};
cl_semaphore_khr sema =
clCreateSemaphoreWithPropertiesKHR(context, sema_props, &err);
test_error(err, "Could not create semaphore");
// Create user events
clEventWrapper user_event_1 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_2 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_3 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Signal semaphore (dependency on user_event_1)
clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema, nullptr, 1,
&user_event_1, &signal_1_event);
test_error(err, "Could not signal semaphore");
// Signal semaphore (dependency on user_event_2)
clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema, nullptr, 1,
&user_event_2, &signal_2_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore (dependency on user_event_3)
clEventWrapper wait_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema, nullptr, 1, &user_event_3,
&wait_event);
test_error(err, "Could not wait semaphore");
// Complete user_event_1
err = clSetUserEventStatus(user_event_1, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Complete user_event_3
err = clSetUserEventStatus(user_event_3, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure all events are completed except for second signal
test_assert_event_complete(signal_1_event);
test_assert_event_inprogress(signal_2_event);
test_assert_event_complete(wait_event);
// Complete user_event_2
err = clSetUserEventStatus(user_event_2, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(signal_1_event);
test_assert_event_complete(signal_2_event);
test_assert_event_complete(wait_event);
// Release semaphore
err = clReleaseSemaphoreKHR(sema);
test_error(err, "Could not release semaphore");
return TEST_PASS;
}
// Confirm that it is possible to enqueue a signal of wait and signal in any
// order as soon as the submission order (after deferred dependencies) is
// correct. Case: first two deferred signals, then two deferred waits. Unblock
// one signal and one wait (both blocked by the same user event). When wait
// completes, unblock the other signal. Then unblock the other wait.
int test_semaphores_order_3(cl_device_id deviceID, cl_context context,
cl_command_queue defaultQueue, int num_elements)
{
cl_int err;
if (!is_extension_available(deviceID, "cl_khr_semaphore"))
{
log_info("cl_khr_semaphore is not supported on this platoform. "
"Skipping test.\n");
return TEST_SKIPPED_ITSELF;
}
// Obtain pointers to semaphore's API
GET_PFN(deviceID, clCreateSemaphoreWithPropertiesKHR);
GET_PFN(deviceID, clEnqueueSignalSemaphoresKHR);
GET_PFN(deviceID, clEnqueueWaitSemaphoresKHR);
GET_PFN(deviceID, clReleaseSemaphoreKHR);
// Create ooo queue
clCommandQueueWrapper queue = clCreateCommandQueue(
context, deviceID, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
test_error(err, "Could not create command queue");
// Create semaphore
cl_semaphore_properties_khr sema_props[] = {
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_KHR),
static_cast<cl_semaphore_properties_khr>(CL_SEMAPHORE_TYPE_BINARY_KHR),
0
};
cl_semaphore_khr sema =
clCreateSemaphoreWithPropertiesKHR(context, sema_props, &err);
test_error(err, "Could not create semaphore");
// Create user events
clEventWrapper user_event_1 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_2 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
clEventWrapper user_event_3 = clCreateUserEvent(context, &err);
test_error(err, "Could not create user event");
// Signal semaphore (dependency on user_event_1)
clEventWrapper signal_1_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema, nullptr, 1,
&user_event_1, &signal_1_event);
test_error(err, "Could not signal semaphore");
// Signal semaphore (dependency on user_event_2)
clEventWrapper signal_2_event;
err = clEnqueueSignalSemaphoresKHR(queue, 1, &sema, nullptr, 1,
&user_event_2, &signal_2_event);
test_error(err, "Could not signal semaphore");
// Wait semaphore (dependency on user_event_3)
clEventWrapper wait_1_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema, nullptr, 1, &user_event_3,
&wait_1_event);
test_error(err, "Could not wait semaphore");
// Wait semaphore (dependency on user_event_2)
clEventWrapper wait_2_event;
err = clEnqueueWaitSemaphoresKHR(queue, 1, &sema, nullptr, 1, &user_event_2,
&wait_2_event);
test_error(err, "Could not wait semaphore");
// Complete user_event_2
err = clSetUserEventStatus(user_event_2, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Flush and delay
err = clFlush(queue);
test_error(err, "Could not flush queue");
std::this_thread::sleep_for(std::chrono::seconds(FLUSH_DELAY_S));
// Ensure only second signal and second wait completed
cl_event event_list[] = { signal_2_event, wait_2_event };
err = clWaitForEvents(2, event_list);
test_error(err, "Could not wait for events");
test_assert_event_inprogress(signal_1_event);
test_assert_event_inprogress(wait_1_event);
// Complete user_event_1
err = clSetUserEventStatus(user_event_1, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Complete user_event_3
err = clSetUserEventStatus(user_event_3, CL_COMPLETE);
test_error(err, "Could not set user event to CL_COMPLETE");
// Finish
err = clFinish(queue);
test_error(err, "Could not finish queue");
// Ensure all events are completed
test_assert_event_complete(signal_1_event);
test_assert_event_complete(signal_2_event);
test_assert_event_complete(wait_1_event);
test_assert_event_complete(wait_2_event);
// Release semaphore
err = clReleaseSemaphoreKHR(sema);
test_error(err, "Could not release semaphore");
return TEST_PASS;
}
// Test it is possible to export a semaphore to a sync fd and import the same
// sync fd to a new semaphore
int test_semaphores_import_export_fd(cl_device_id deviceID, cl_context context,