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

Migrate extensions suites to the new test registration framework (#2334)

Browse Source 
This covers:
* cl_ext_cxx_for_opencl
* cl_khr_command_buffer
* cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch
* cl_khr_dx9_media_sharing
* cl_khr_external_semaphore
* cl_khr_kernel_clock
* cl_khr_semaphore

Contributes to #2181.

---------

Signed-off-by: Ahmed Hesham <ahmed.hesham@arm.com>
This commit is contained in:
Ahmed Hesham
2025-04-16 11:14:34 +01:00
committed by GitHub
parent 33846e6673
commit 90524879e4
72 changed files with 754 additions and 2277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test_conformance/extensions/cl_khr_command_buffer/CMakeLists.txt
View File

@@ -3,6 +3,7 @@ set(MODULE_NAME CL_KHR_COMMAND_BUFFER)
set(${MODULE_NAME}_SOURCES
main.cpp
basic_command_buffer.cpp
basic_command_buffer_tests.cpp
svm_command_basic.cpp
command_buffer_printf.cpp
command_buffer_get_command_buffer_info.cpp

508
test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <algorithm>
#include <cstring>
@@ -186,324 +185,253 @@ cl_int BasicCommandBufferTest::SetUp(int elements)
return CL_SUCCESS;
}
namespace {
// Test that the CL_COMMAND_BUFFER_FLAGS_KHR bitfield is parsed correctly when
// multiple flags are set.
struct MultiFlagCreationTest : public BasicCommandBufferTest
cl_int MultiFlagCreationTest::Run()
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_command_buffer_properties_khr flags = 0;
cl_int error = CL_SUCCESS;
cl_int Run() override
// First try to find multiple flags that are supported by the driver and
// device.
if (simultaneous_use_support)
{
cl_command_buffer_properties_khr flags = 0;
cl_int error = CL_SUCCESS;
// First try to find multiple flags that are supported by the driver and
// device.
if (simultaneous_use_support)
{
flags |= CL_COMMAND_BUFFER_SIMULTANEOUS_USE_KHR;
}
if (is_extension_available(
device, CL_KHR_COMMAND_BUFFER_MULTI_DEVICE_EXTENSION_NAME))
{
flags |= CL_COMMAND_BUFFER_DEVICE_SIDE_SYNC_KHR;
}
if (is_extension_available(
device, CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME))
{
flags |= CL_COMMAND_BUFFER_MUTABLE_KHR;
}
cl_command_buffer_properties_khr props[] = {
CL_COMMAND_BUFFER_FLAGS_KHR, flags, 0
};
command_buffer = clCreateCommandBufferKHR(1, &queue, props, &error);
test_error(error, "clCreateCommandBufferKHR failed");
return CL_SUCCESS;
flags |= CL_COMMAND_BUFFER_SIMULTANEOUS_USE_KHR;
}
if (is_extension_available(
device, CL_KHR_COMMAND_BUFFER_MULTI_DEVICE_EXTENSION_NAME))
{
flags |= CL_COMMAND_BUFFER_DEVICE_SIDE_SYNC_KHR;
}
if (is_extension_available(
device, CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME))
{
flags |= CL_COMMAND_BUFFER_MUTABLE_KHR;
}
cl_command_buffer_properties_khr props[] = { CL_COMMAND_BUFFER_FLAGS_KHR,
flags, 0 };
command_buffer = clCreateCommandBufferKHR(1, &queue, props, &error);
test_error(error, "clCreateCommandBufferKHR failed");
return CL_SUCCESS;
};
// Test enqueuing a command-buffer containing a single NDRange command once
struct BasicEnqueueTest : public BasicCommandBufferTest
cl_int BasicEnqueueTest::Run()
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override
cl_int error = clCommandNDRangeKernelKHR(
command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements,
nullptr, 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandNDRangeKernelKHR failed");
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
const cl_int pattern = 42;
error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr,
nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> output_data_1(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
output_data_1.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < num_elements; i++)
{
cl_int error = clCommandNDRangeKernelKHR(
CHECK_VERIFICATION_ERROR(pattern, output_data_1[i], i);
}
const cl_int new_pattern = 12;
error = clEnqueueFillBuffer(queue, in_mem, &new_pattern, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr,
nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> output_data_2(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
output_data_2.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < num_elements; i++)
{
CHECK_VERIFICATION_ERROR(new_pattern, output_data_2[i], i);
}
return CL_SUCCESS;
};
cl_int MixedCommandsTest::Run()
{
cl_int error;
const size_t iterations = 4;
clMemWrapper result_mem =
clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(cl_int) * iterations,
nullptr, &error);
test_error(error, "clCreateBuffer failed");
const cl_int pattern_base = 42;
for (size_t i = 0; i < iterations; i++)
{
const cl_int pattern = pattern_base + i;
cl_int error = clCommandFillBufferKHR(
command_buffer, nullptr, nullptr, in_mem, &pattern, sizeof(cl_int),
0, data_size(), 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandFillBufferKHR failed");
error = clCommandNDRangeKernelKHR(
command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements,
nullptr, 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandNDRangeKernelKHR failed");
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
const cl_int pattern = 42;
error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
nullptr, nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> output_data_1(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
output_data_1.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < num_elements; i++)
{
CHECK_VERIFICATION_ERROR(pattern, output_data_1[i], i);
}
const cl_int new_pattern = 12;
error = clEnqueueFillBuffer(queue, in_mem, &new_pattern, sizeof(cl_int),
0, data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
nullptr, nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> output_data_2(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
output_data_2.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < num_elements; i++)
{
CHECK_VERIFICATION_ERROR(new_pattern, output_data_2[i], i);
}
return CL_SUCCESS;
const size_t result_offset = i * sizeof(cl_int);
error = clCommandCopyBufferKHR(
command_buffer, nullptr, nullptr, out_mem, result_mem, 0,
result_offset, sizeof(cl_int), 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandCopyBufferKHR failed");
}
};
// Test enqueuing a command-buffer containing multiple command, including
// operations other than NDRange kernel execution.
struct MixedCommandsTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
cl_int Run() override
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr,
nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> result_data(num_elements);
error = clEnqueueReadBuffer(queue, result_mem, CL_TRUE, 0,
iterations * sizeof(cl_int), result_data.data(),
0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < iterations; i++)
{
cl_int error;
const size_t iterations = 4;
clMemWrapper result_mem =
clCreateBuffer(context, CL_MEM_READ_WRITE,
sizeof(cl_int) * iterations, nullptr, &error);
test_error(error, "clCreateBuffer failed");
const cl_int pattern_base = 42;
for (size_t i = 0; i < iterations; i++)
{
const cl_int pattern = pattern_base + i;
cl_int error = clCommandFillBufferKHR(
command_buffer, nullptr, nullptr, in_mem, &pattern,
sizeof(cl_int), 0, data_size(), 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandFillBufferKHR failed");
error = clCommandNDRangeKernelKHR(
command_buffer, nullptr, nullptr, kernel, 1, nullptr,
&num_elements, nullptr, 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandNDRangeKernelKHR failed");
const size_t result_offset = i * sizeof(cl_int);
error = clCommandCopyBufferKHR(
command_buffer, nullptr, nullptr, out_mem, result_mem, 0,
result_offset, sizeof(cl_int), 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandCopyBufferKHR failed");
}
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
nullptr, nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> result_data(num_elements);
error = clEnqueueReadBuffer(queue, result_mem, CL_TRUE, 0,
iterations * sizeof(cl_int),
result_data.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < iterations; i++)
{
const cl_int ref = pattern_base + i;
CHECK_VERIFICATION_ERROR(ref, result_data[i], i);
}
return CL_SUCCESS;
}
};
// Test flushing the command-queue between command-buffer enqueues
struct ExplicitFlushTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override
{
cl_int error = clCommandNDRangeKernelKHR(
command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements,
nullptr, 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandNDRangeKernelKHR failed");
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
const cl_int pattern_A = 42;
error = clEnqueueFillBuffer(queue, in_mem, &pattern_A, sizeof(cl_int),
0, data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clFlush(queue);
test_error(error, "clFlush failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
nullptr, nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> output_data_A(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(),
output_data_A.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
const cl_int pattern_B = 0xA;
error = clEnqueueFillBuffer(queue, in_mem, &pattern_B, sizeof(cl_int),
0, data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clFlush(queue);
test_error(error, "clFlush failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
nullptr, nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
error = clFlush(queue);
test_error(error, "clFlush failed");
std::vector<cl_int> output_data_B(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(),
output_data_B.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
error = clFinish(queue);
test_error(error, "clFinish failed");
for (size_t i = 0; i < num_elements; i++)
{
CHECK_VERIFICATION_ERROR(pattern_A, output_data_A[i], i);
CHECK_VERIFICATION_ERROR(pattern_B, output_data_B[i], i);
}
return CL_SUCCESS;
const cl_int ref = pattern_base + i;
CHECK_VERIFICATION_ERROR(ref, result_data[i], i);
}
bool Skip() override
{
return BasicCommandBufferTest::Skip() || !simultaneous_use_support;
}
};
// Test enqueueing a command-buffer twice separated by another enqueue operation
struct InterleavedEnqueueTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override
{
cl_int error = clCommandNDRangeKernelKHR(
command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements,
nullptr, 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandNDRangeKernelKHR failed");
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
cl_int pattern = 42;
error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
nullptr, nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
pattern = 0xABCD;
error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0,
nullptr, nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
error = clEnqueueCopyBuffer(queue, in_mem, out_mem, 0, 0, data_size(),
0, nullptr, nullptr);
test_error(error, "clEnqueueCopyBuffer failed");
std::vector<cl_int> output_data(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
output_data.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < num_elements; i++)
{
CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
}
return CL_SUCCESS;
}
bool Skip() override
{
return BasicCommandBufferTest::Skip() || !simultaneous_use_support;
}
};
} // anonymous namespace
int test_multi_flag_creation(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
{
return MakeAndRunTest<MultiFlagCreationTest>(device, context, queue,
num_elements);
return CL_SUCCESS;
}
int test_single_ndrange(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
cl_int ExplicitFlushTest::Run()
{
return MakeAndRunTest<BasicEnqueueTest>(device, context, queue,
num_elements);
cl_int error = clCommandNDRangeKernelKHR(
command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements,
nullptr, 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandNDRangeKernelKHR failed");
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
const cl_int pattern_A = 42;
error = clEnqueueFillBuffer(queue, in_mem, &pattern_A, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clFlush(queue);
test_error(error, "clFlush failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr,
nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
std::vector<cl_int> output_data_A(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(),
output_data_A.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
const cl_int pattern_B = 0xA;
error = clEnqueueFillBuffer(queue, in_mem, &pattern_B, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clFlush(queue);
test_error(error, "clFlush failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr,
nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
error = clFlush(queue);
test_error(error, "clFlush failed");
std::vector<cl_int> output_data_B(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_FALSE, 0, data_size(),
output_data_B.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
error = clFinish(queue);
test_error(error, "clFinish failed");
for (size_t i = 0; i < num_elements; i++)
{
CHECK_VERIFICATION_ERROR(pattern_A, output_data_A[i], i);
CHECK_VERIFICATION_ERROR(pattern_B, output_data_B[i], i);
}
return CL_SUCCESS;
}
int test_interleaved_enqueue(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
bool ExplicitFlushTest::Skip()
{
return MakeAndRunTest<InterleavedEnqueueTest>(device, context, queue,
num_elements);
return BasicCommandBufferTest::Skip() || !simultaneous_use_support;
}
int test_mixed_commands(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
cl_int InterleavedEnqueueTest::Run()
{
return MakeAndRunTest<MixedCommandsTest>(device, context, queue,
num_elements);
cl_int error = clCommandNDRangeKernelKHR(
command_buffer, nullptr, nullptr, kernel, 1, nullptr, &num_elements,
nullptr, 0, nullptr, nullptr, nullptr);
test_error(error, "clCommandNDRangeKernelKHR failed");
error = clFinalizeCommandBufferKHR(command_buffer);
test_error(error, "clFinalizeCommandBufferKHR failed");
cl_int pattern = 42;
error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr,
nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
pattern = 0xABCD;
error = clEnqueueFillBuffer(queue, in_mem, &pattern, sizeof(cl_int), 0,
data_size(), 0, nullptr, nullptr);
test_error(error, "clEnqueueFillBuffer failed");
error = clEnqueueCommandBufferKHR(0, nullptr, command_buffer, 0, nullptr,
nullptr);
test_error(error, "clEnqueueCommandBufferKHR failed");
error = clEnqueueCopyBuffer(queue, in_mem, out_mem, 0, 0, data_size(), 0,
nullptr, nullptr);
test_error(error, "clEnqueueCopyBuffer failed");
std::vector<cl_int> output_data(num_elements);
error = clEnqueueReadBuffer(queue, out_mem, CL_TRUE, 0, data_size(),
output_data.data(), 0, nullptr, nullptr);
test_error(error, "clEnqueueReadBuffer failed");
for (size_t i = 0; i < num_elements; i++)
{
CHECK_VERIFICATION_ERROR(pattern, output_data[i], i);
}
return CL_SUCCESS;
}
int test_explicit_flush(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
bool InterleavedEnqueueTest::Skip()
{
return MakeAndRunTest<ExplicitFlushTest>(device, context, queue,
num_elements);
return BasicCommandBufferTest::Skip() || !simultaneous_use_support;
}

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

@@ -84,6 +84,49 @@ protected:
clCommandBufferWrapper command_buffer;
};
// Test that CL_COMMAND_BUFFER_FLAGS_KHR bitfield is parsed correctly when
// multiple flags are set.
struct MultiFlagCreationTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override;
};
// Test enqueuing a command-buffer containing a single NDRange command once
struct BasicEnqueueTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override;
};
// Test enqueuing a command-buffer containing multiple command, including
// operations other than NDRange kernel execution.
struct MixedCommandsTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override;
};
// Test flushing the command-queue between command-buffer enqueues
struct ExplicitFlushTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override;
bool Skip() override;
};
// Test enqueueing a command-buffer twice separated by another enqueue operation
struct InterleavedEnqueueTest : public BasicCommandBufferTest
{
using BasicCommandBufferTest::BasicCommandBufferTest;
cl_int Run() override;
bool Skip() override;
};
template <class T>
int MakeAndRunTest(cl_device_id device, cl_context context,

46
test_conformance/extensions/cl_khr_command_buffer/basic_command_buffer_tests.cpp Normal file
View File

@@ -0,0 +1,46 @@
//
// Copyright (c) 2025 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 "basic_command_buffer.h"
REGISTER_TEST(multi_flag_creation)
{
return MakeAndRunTest<MultiFlagCreationTest>(device, context, queue,
num_elements);
}
REGISTER_TEST(single_ndrange)
{
return MakeAndRunTest<BasicEnqueueTest>(device, context, queue,
num_elements);
}
REGISTER_TEST(interleaved_enqueue)
{
return MakeAndRunTest<InterleavedEnqueueTest>(device, context, queue,
num_elements);
}
REGISTER_TEST(mixed_commands)
{
return MakeAndRunTest<MixedCommandsTest>(device, context, queue,
num_elements);
}
REGISTER_TEST(explicit_flush)
{
return MakeAndRunTest<ExplicitFlushTest>(device, context, queue,
num_elements);
}

39
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/main.cpp
View File

@@ -12,43 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "procs.h"
#include "harness/testHarness.h"
test_definition test_list[] = {
ADD_TEST(mutable_command_info_device_query),
ADD_TEST(mutable_command_info_buffer),
ADD_TEST(mutable_command_properties_array),
ADD_TEST(mutable_command_kernel),
ADD_TEST(mutable_command_dimensions),
ADD_TEST(mutable_command_info_type),
ADD_TEST(mutable_command_info_queue),
ADD_TEST(mutable_command_info_global_work_offset),
ADD_TEST(mutable_command_info_local_work_size),
ADD_TEST(mutable_command_info_global_work_size),
ADD_TEST(mutable_command_full_dispatch),
ADD_TEST(mutable_command_overwrite_update),
ADD_TEST(mutable_command_multiple_dispatches),
ADD_TEST(mutable_command_iterative_arg_update),
ADD_TEST(mutable_dispatch_image_1d_arguments),
ADD_TEST(mutable_dispatch_image_2d_arguments),
ADD_TEST(mutable_dispatch_out_of_order),
ADD_TEST(mutable_dispatch_simultaneous_out_of_order),
ADD_TEST(mutable_dispatch_simultaneous_in_order),
ADD_TEST(mutable_dispatch_simultaneous_cross_queue),
ADD_TEST(mutable_dispatch_global_size),
ADD_TEST(mutable_dispatch_local_size),
ADD_TEST(mutable_dispatch_global_offset),
ADD_TEST(mutable_dispatch_svm_arguments),
ADD_TEST(mutable_dispatch_local_arguments),
ADD_TEST(mutable_dispatch_global_arguments),
ADD_TEST(mutable_dispatch_pod_arguments),
ADD_TEST(mutable_dispatch_null_arguments),
ADD_TEST(command_buffer_with_no_additional_work_groups),
ADD_TEST(ndrange_with_no_additional_work_groups),
ADD_TEST(ndrange_command_buffer_with_no_additional_work_groups),
};
int main(int argc, const char *argv[])
{
// A device may report the required properties of a queue that
@@ -57,7 +22,9 @@ int main(int argc, const char *argv[])
// for this in the tests themselves, rather than here, where we have a
// device to query.
const cl_command_queue_properties queue_properties = 0;
return runTestHarnessWithCheck(argc, argv, ARRAY_SIZE(test_list), test_list,
return runTestHarnessWithCheck(argc, argv,
test_registry::getInstance().num_tests(),
test_registry::getInstance().definitions(),
false, queue_properties, nullptr);
return 0;
}

23
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_arguments.cpp
View File

@@ -826,44 +826,31 @@ struct MutableDispatchSVMArguments : public MutableDispatchArgumentsTest
}
int test_mutable_dispatch_local_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_local_arguments)
{
return MakeAndRunTest<MutableDispatchLocalArguments>(device, context, queue,
num_elements);
}
int test_mutable_dispatch_global_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_global_arguments)
{
return MakeAndRunTest<MutableDispatchGlobalArguments>(device, context,
queue, num_elements);
}
int test_mutable_dispatch_pod_arguments(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_pod_arguments)
{
return MakeAndRunTest<MutableDispatchPODArguments>(device, context, queue,
num_elements);
}
int test_mutable_dispatch_null_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_null_arguments)
{
return MakeAndRunTest<MutableDispatchNullArguments>(device, context, queue,
num_elements);
}
int test_mutable_dispatch_svm_arguments(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_svm_arguments)
{
return MakeAndRunTest<MutableDispatchSVMArguments>(device, context, queue,
num_elements);

3
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_full_dispatch.cpp
View File

@@ -492,8 +492,7 @@ struct MutableCommandFullDispatch : InfoMutableCommandBufferTest
}
int test_mutable_command_full_dispatch(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_command_full_dispatch)
{
return MakeAndRunTest<MutableCommandFullDispatch>(device, context, queue,
num_elements);

4
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_offset.cpp
View File

@@ -160,9 +160,7 @@ struct MutableDispatchGlobalOffset : InfoMutableCommandBufferTest
cl_mutable_command_khr command = nullptr;
};
int test_mutable_dispatch_global_offset(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_global_offset)
{
return MakeAndRunTest<MutableDispatchGlobalOffset>(device, context, queue,

3
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_global_size.cpp
View File

@@ -159,8 +159,7 @@ struct MutableDispatchGlobalSize : public InfoMutableCommandBufferTest
cl_mutable_command_khr command = nullptr;
};
int test_mutable_dispatch_global_size(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_dispatch_global_size)
{
return MakeAndRunTest<MutableDispatchGlobalSize>(device, context, queue,
num_elements);

10
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_image_arguments.cpp
View File

@@ -412,19 +412,13 @@ struct MutableDispatchImage2DArguments : public BasicMutableCommandBufferTest
cl_mutable_command_khr command = nullptr;
};
int test_mutable_dispatch_image_1d_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_image_1d_arguments)
{
return MakeAndRunTest<MutableDispatchImage1DArguments>(device, context,
queue, num_elements);
}
int test_mutable_dispatch_image_2d_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_image_2d_arguments)
{
return MakeAndRunTest<MutableDispatchImage2DArguments>(device, context,
queue, num_elements);

41
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_info.cpp
View File

@@ -16,7 +16,6 @@
#include <extensionHelpers.h>
#include "typeWrappers.h"
#include "procs.h"
#include "testHarness.h"
#include <vector>
#include <iostream>
@@ -441,76 +440,56 @@ struct InfoLocalWorkSize : public InfoMutableCommandBufferTest
size_t test_local_work_size = 0;
};
int test_mutable_command_info_device_query(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_info_device_query)
{
return MakeAndRunTest<InfoDeviceQuery>(device, context, queue,
num_elements);
}
int test_mutable_command_info_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_command_info_buffer)
{
return MakeAndRunTest<InfoBuffer>(device, context, queue, num_elements);
}
int test_mutable_command_properties_array(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_properties_array)
{
return MakeAndRunTest<PropertiesArray>(device, context, queue,
num_elements);
}
int test_mutable_command_kernel(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_command_kernel)
{
return MakeAndRunTest<Kernel>(device, context, queue, num_elements);
}
int test_mutable_command_dimensions(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_command_dimensions)
{
return MakeAndRunTest<Dimensions>(device, context, queue, num_elements);
}
int test_mutable_command_info_type(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_command_info_type)
{
return MakeAndRunTest<InfoType>(device, context, queue, num_elements);
}
int test_mutable_command_info_queue(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_command_info_queue)
{
return MakeAndRunTest<InfoQueue>(device, context, queue, num_elements);
}
int test_mutable_command_info_global_work_offset(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_info_global_work_offset)
{
return MakeAndRunTest<InfoGlobalWorkOffset>(device, context, queue,
num_elements);
}
int test_mutable_command_info_global_work_size(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_info_global_work_size)
{
return MakeAndRunTest<InfoGlobalWorkSize>(device, context, queue,
num_elements);
}
int test_mutable_command_info_local_work_size(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_info_local_work_size)
{
return MakeAndRunTest<InfoLocalWorkSize>(device, context, queue,
num_elements);

5
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_iterative_arg_update.cpp
View File

@@ -212,10 +212,7 @@ struct IterativeArgUpdateDispatch : BasicMutableCommandBufferTest
}
int test_mutable_command_iterative_arg_update(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_iterative_arg_update)
{
return MakeAndRunTest<IterativeArgUpdateDispatch>(device, context, queue,
num_elements);

4
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_local_size.cpp
View File

@@ -16,7 +16,6 @@
#include <extensionHelpers.h>
#include "typeWrappers.h"
#include "procs.h"
#include "testHarness.h"
#include "mutable_command_basic.h"
#include <vector>
@@ -166,8 +165,7 @@ struct MutableDispatchLocalSize : public InfoMutableCommandBufferTest
cl_mutable_command_khr command = nullptr;
};
int test_mutable_dispatch_local_size(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_dispatch_local_size)
{
return MakeAndRunTest<MutableDispatchLocalSize>(device, context, queue,
num_elements);

5
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_multiple_dispatches.cpp
View File

@@ -207,10 +207,7 @@ struct MultipleCommandsDispatch : BasicMutableCommandBufferTest
}
int test_mutable_command_multiple_dispatches(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_multiple_dispatches)
{
return MakeAndRunTest<MultipleCommandsDispatch>(device, context, queue,
num_elements);

5
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_overwrite_update.cpp
View File

@@ -215,10 +215,7 @@ struct OverwriteUpdateDispatch : BasicMutableCommandBufferTest
}
int test_mutable_command_overwrite_update(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_command_overwrite_update)
{
return MakeAndRunTest<OverwriteUpdateDispatch>(device, context, queue,
num_elements);

18
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_simultaneous.cpp
View File

@@ -605,35 +605,25 @@ struct CrossQueueSimultaneousMutableDispatchTest
} // anonymous namespace
int test_mutable_dispatch_out_of_order(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(mutable_dispatch_out_of_order)
{
return MakeAndRunTest<SimultaneousMutableDispatchTest<false, true>>(
device, context, queue, num_elements);
}
int test_mutable_dispatch_simultaneous_out_of_order(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_simultaneous_out_of_order)
{
return MakeAndRunTest<SimultaneousMutableDispatchTest<true, true>>(
device, context, queue, num_elements);
}
int test_mutable_dispatch_simultaneous_in_order(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_simultaneous_in_order)
{
return MakeAndRunTest<SimultaneousMutableDispatchTest<true, false>>(
device, context, queue, num_elements);
}
int test_mutable_dispatch_simultaneous_cross_queue(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(mutable_dispatch_simultaneous_cross_queue)
{
return MakeAndRunTest<CrossQueueSimultaneousMutableDispatchTest>(
device, context, queue, num_elements);

14
test_conformance/extensions/cl_khr_command_buffer/cl_khr_command_buffer_mutable_dispatch/mutable_command_work_groups.cpp
View File

@@ -284,29 +284,21 @@ struct MutableDispatchWorkGroups : public BasicMutableCommandBufferTest
const size_t sizeToAllocate = 64 * sizeof(cl_int);
};
int test_command_buffer_with_no_additional_work_groups(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(command_buffer_with_no_additional_work_groups)
{
return MakeAndRunTest<MutableDispatchWorkGroups<0>>(device, context, queue,
num_elements);
}
int test_ndrange_with_no_additional_work_groups(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(ndrange_with_no_additional_work_groups)
{
return MakeAndRunTest<MutableDispatchWorkGroups<1>>(device, context, queue,
num_elements);
}
int test_ndrange_command_buffer_with_no_additional_work_groups(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(ndrange_command_buffer_with_no_additional_work_groups)
{
return MakeAndRunTest<MutableDispatchWorkGroups<2>>(device, context, queue,

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

@@ -1,143 +0,0 @@
//
// 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.
// 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.
//
#ifndef CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H
#define CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H
#include <CL/cl.h>
// Basic mutable dispatch tests
extern int test_mutable_command_info_device_query(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_info_buffer(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_info_type(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_info_queue(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_properties_array(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_kernel(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_dimensions(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_info_global_work_offset(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_info_local_work_size(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_info_global_work_size(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_image_1d_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_image_2d_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_global_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_local_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_pod_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_null_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_svm_arguments(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_out_of_order(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_simultaneous_out_of_order(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_simultaneous_in_order(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_simultaneous_cross_queue(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_global_size(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_local_size(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_dispatch_global_offset(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_full_dispatch(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_overwrite_update(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_multiple_dispatches(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_mutable_command_iterative_arg_update(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_command_buffer_with_no_additional_work_groups(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_ndrange_with_no_additional_work_groups(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_ndrange_command_buffer_with_no_additional_work_groups(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
#endif /*_CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_PROCS_H*/

42
test_conformance/extensions/cl_khr_command_buffer/command_buffer_event_sync.cpp
View File

@@ -15,7 +15,6 @@
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
#include <thread>
@@ -823,10 +822,7 @@ struct CommandBufferEventSync : public BasicCommandBufferTest
//--------------------------------------------------------------------------
// return-events test cases for regular queue
int test_regular_wait_for_command_buffer(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(regular_wait_for_command_buffer)
{
int status = TEST_PASS;
// The approach here is that test scenario which involves out-of-order
@@ -848,10 +844,7 @@ int test_regular_wait_for_command_buffer(cl_device_id device,
return status;
}
int test_command_buffer_wait_for_command_buffer(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(command_buffer_wait_for_command_buffer)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -871,10 +864,7 @@ int test_command_buffer_wait_for_command_buffer(cl_device_id device,
return status;
}
int test_command_buffer_wait_for_sec_command_buffer(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(command_buffer_wait_for_sec_command_buffer)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -894,8 +884,7 @@ int test_command_buffer_wait_for_sec_command_buffer(cl_device_id device,
return status;
}
int test_return_event_callback(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(return_event_callback)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -913,8 +902,7 @@ int test_return_event_callback(cl_device_id device, cl_context context,
return status;
}
int test_clwaitforevents_single(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(clwaitforevents_single)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -934,8 +922,7 @@ int test_clwaitforevents_single(cl_device_id device, cl_context context,
return status;
}
int test_clwaitforevents(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(clwaitforevents)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -953,10 +940,7 @@ int test_clwaitforevents(cl_device_id device, cl_context context,
return status;
}
int test_command_buffer_wait_for_regular(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(command_buffer_wait_for_regular)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -976,8 +960,7 @@ int test_command_buffer_wait_for_regular(cl_device_id device,
return status;
}
int test_wait_for_sec_queue_event(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(wait_for_sec_queue_event)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -1000,8 +983,7 @@ int test_wait_for_sec_queue_event(cl_device_id device, cl_context context,
//--------------------------------------------------------------------------
// user-events test cases
int test_user_event_wait(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(user_event_wait)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -1019,8 +1001,7 @@ int test_user_event_wait(cl_device_id device, cl_context context,
return status;
}
int test_user_events_wait(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(user_events_wait)
{
int status = TEST_PASS;
// out-of-order command queue test
@@ -1038,8 +1019,7 @@ int test_user_events_wait(cl_device_id device, cl_context context,
return status;
}
int test_user_event_callback(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(user_event_callback)
{
int status = TEST_PASS;
// out-of-order command queue test

7
test_conformance/extensions/cl_khr_command_buffer/command_buffer_finalize.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
#include "basic_command_buffer.h"
#include "procs.h"
namespace {
@@ -71,15 +70,13 @@ struct FinalizeEmpty : public BasicCommandBufferTest
};
} // anonymous namespace
int test_finalize_invalid(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(finalize_invalid)
{
return MakeAndRunTest<FinalizeInvalid>(device, context, queue,
num_elements);
}
int test_finalize_empty(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(finalize_empty)
{
return MakeAndRunTest<FinalizeEmpty>(device, context, queue, num_elements);
}

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

@@ -15,7 +15,6 @@
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
@@ -374,40 +373,35 @@ struct CommandBufferGetCommandBufferInfo : public BasicCommandBufferTest
} // anonymous namespace
int test_info_queues(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(info_queues)
{
return MakeAndRunTest<
CommandBufferGetCommandBufferInfo<CombufInfoTestMode::CITM_QUEUES>>(
device, context, queue, num_elements);
}
int test_info_ref_count(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(info_ref_count)
{
return MakeAndRunTest<
CommandBufferGetCommandBufferInfo<CombufInfoTestMode::CITM_REF_COUNT>>(
device, context, queue, num_elements);
}
int test_info_state(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(info_state)
{
return MakeAndRunTest<
CommandBufferGetCommandBufferInfo<CombufInfoTestMode::CITM_STATE>>(
device, context, queue, num_elements);
}
int test_info_prop_array(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(info_prop_array)
{
return MakeAndRunTest<
CommandBufferGetCommandBufferInfo<CombufInfoTestMode::CITM_PROP_ARRAY>>(
device, context, queue, num_elements);
}
int test_info_context(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(info_context)
{
return MakeAndRunTest<
CommandBufferGetCommandBufferInfo<CombufInfoTestMode::CITM_CONTEXT>>(

7
test_conformance/extensions/cl_khr_command_buffer/command_buffer_out_of_order.cpp
View File

@@ -15,7 +15,6 @@
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
@@ -337,15 +336,13 @@ struct OutOfOrderTest : public BasicCommandBufferTest
} // anonymous namespace
int test_out_of_order(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(out_of_order)
{
return MakeAndRunTest<OutOfOrderTest<false>>(device, context, queue,
num_elements);
}
int test_simultaneous_out_of_order(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(simultaneous_out_of_order)
{
return MakeAndRunTest<OutOfOrderTest<true>>(device, context, queue,
num_elements);

7
test_conformance/extensions/cl_khr_command_buffer/command_buffer_printf.cpp
View File

@@ -17,7 +17,6 @@
#include <harness/os_helpers.h>
#include "basic_command_buffer.h"
#include "procs.h"
#if !defined(_WIN32)
#if defined(__APPLE__)
@@ -524,15 +523,13 @@ struct CommandBufferPrintfTest : public BasicCommandBufferTest
} // anonymous namespace
int test_basic_printf(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(basic_printf)
{
return MakeAndRunTest<CommandBufferPrintfTest<false>>(device, context,
queue, num_elements);
}
int test_simultaneous_printf(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(simultaneous_printf)
{
return MakeAndRunTest<CommandBufferPrintfTest<true>>(device, context, queue,
num_elements);

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

@@ -15,7 +15,6 @@
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
@@ -357,22 +356,19 @@ struct CommandBufferSubstituteQueueProfiling : public BasicCommandBufferTest
};
} // anonymous namespace
int test_basic_profiling(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(basic_profiling)
{
return MakeAndRunTest<CommandBufferProfiling<false>>(device, context, queue,
num_elements);
}
int test_simultaneous_profiling(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(simultaneous_profiling)
{
return MakeAndRunTest<CommandBufferProfiling<true>>(device, context, queue,
num_elements);
}
int test_substitute_queue_profiling(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(substitute_queue_profiling)
{
return MakeAndRunTest<CommandBufferSubstituteQueueProfiling>(
device, context, queue, num_elements);

18
test_conformance/extensions/cl_khr_command_buffer/command_buffer_queue_substitution.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
@@ -396,38 +395,31 @@ struct QueueOrderTest : public BasicCommandBufferTest
};
} // anonymous namespace
int test_queue_substitution(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(queue_substitution)
{
return MakeAndRunTest<SubstituteQueueTest<false, false>>(
device, context, queue, num_elements);
}
int test_properties_queue_substitution(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(properties_queue_substitution)
{
return MakeAndRunTest<SubstituteQueueTest<true, false>>(
device, context, queue, num_elements);
}
int test_simultaneous_queue_substitution(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(simultaneous_queue_substitution)
{
return MakeAndRunTest<SubstituteQueueTest<false, true>>(
device, context, queue, num_elements);
}
int test_queue_substitute_in_order(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(queue_substitute_in_order)
{
return MakeAndRunTest<QueueOrderTest<false>>(device, context, queue,
num_elements);
}
int test_queue_substitute_out_of_order(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(queue_substitute_out_of_order)
{
return MakeAndRunTest<QueueOrderTest<true>>(device, context, queue,
num_elements);

7
test_conformance/extensions/cl_khr_command_buffer/command_buffer_set_kernel_arg.cpp
View File

@@ -15,7 +15,6 @@
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
@@ -306,15 +305,13 @@ struct CommandBufferSetKernelArg : public BasicCommandBufferTest
} // anonymous namespace
int test_basic_set_kernel_arg(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(basic_set_kernel_arg)
{
return MakeAndRunTest<CommandBufferSetKernelArg<false>>(
device, context, queue, num_elements);
}
int test_pending_set_kernel_arg(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(pending_set_kernel_arg)
{
return MakeAndRunTest<CommandBufferSetKernelArg<true>>(device, context,
queue, num_elements);

4
test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_barrier.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
@@ -146,8 +145,7 @@ struct BarrierWithWaitListKHR : public BasicCommandBufferTest
};
int test_barrier_wait_list(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(barrier_wait_list)
{
return MakeAndRunTest<BarrierWithWaitListKHR>(device, context, queue,
num_elements);

19
test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_copy.cpp
View File

@@ -16,7 +16,6 @@
#include "basic_command_buffer.h"
#include "svm_command_basic.h"
#include "harness/typeWrappers.h"
#include "procs.h"
#include <vector>
@@ -563,42 +562,36 @@ struct CopyBufferRectKHR : public BasicCommandBufferTest
};
};
int test_copy_image(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(copy_image)
{
return MakeAndRunTest<CopyImageKHR>(device, context, queue, num_elements);
}
int test_copy_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(copy_buffer)
{
return MakeAndRunTest<CopyBufferKHR>(device, context, queue, num_elements);
}
int test_copy_svm_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(copy_svm_buffer)
{
return MakeAndRunTest<CopySVMBufferKHR>(device, context, queue,
num_elements);
}
int test_copy_buffer_to_image(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(copy_buffer_to_image)
{
return MakeAndRunTest<CopyBufferToImageKHR>(device, context, queue,
num_elements);
}
int test_copy_image_to_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(copy_image_to_buffer)
{
return MakeAndRunTest<CopyImageToBufferKHR>(device, context, queue,
num_elements);
}
int test_copy_buffer_rect(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(copy_buffer_rect)
{
return MakeAndRunTest<CopyBufferRectKHR>(device, context, queue,
num_elements);

16
test_conformance/extensions/cl_khr_command_buffer/command_buffer_test_event_info.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
namespace {
@@ -222,33 +221,28 @@ struct ReferenceCount : public BasicCommandBufferTest
};
};
int test_event_info_command_type(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(event_info_command_type)
{
return MakeAndRunTest<CommandType>(device, context, queue, num_elements);
}
int test_event_info_command_queue(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(event_info_command_queue)
{
return MakeAndRunTest<CommandQueue>(device, context, queue, num_elements);
}
int test_event_info_context(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(event_info_context)
{
return MakeAndRunTest<Context>(device, context, queue, num_elements);
}
int test_event_info_execution_status(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(event_info_execution_status)
{
return MakeAndRunTest<ExecutionStatus>(device, context, queue,
num_elements);
}
int test_event_info_reference_count(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(event_info_reference_count)
{
return MakeAndRunTest<ReferenceCount>(device, context, queue, num_elements);
}

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

@@ -16,7 +16,6 @@
#include "basic_command_buffer.h"
#include "svm_command_basic.h"
#include "harness/typeWrappers.h"
#include "procs.h"
#include <vector>
@@ -230,22 +229,19 @@ struct FillSVMBufferKHR : public BasicSVMCommandBufferTest
};
};
int test_fill_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(fill_buffer)
{
return MakeAndRunTest<FillBufferKHR>(device, context, queue, num_elements);
}
int test_fill_svm_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(fill_svm_buffer)
{
return MakeAndRunTest<FillSVMBufferKHR>(device, context, queue,
num_elements);
}
int test_fill_image(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements)
REGISTER_TEST(fill_image)
{
return MakeAndRunTest<FillImageKHR>(device, context, queue, num_elements);
}

153
test_conformance/extensions/cl_khr_command_buffer/main.cpp
View File

@@ -12,157 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "procs.h"
#include "harness/testHarness.h"
test_definition test_list[] = {
ADD_TEST(multi_flag_creation),
ADD_TEST(single_ndrange),
ADD_TEST(interleaved_enqueue),
ADD_TEST(mixed_commands),
ADD_TEST(explicit_flush),
ADD_TEST(out_of_order),
ADD_TEST(simultaneous_out_of_order),
ADD_TEST(info_queues),
ADD_TEST(info_ref_count),
ADD_TEST(info_state),
ADD_TEST(info_prop_array),
ADD_TEST(info_context),
ADD_TEST(basic_profiling),
ADD_TEST(simultaneous_profiling),
ADD_TEST(substitute_queue_profiling),
ADD_TEST(regular_wait_for_command_buffer),
ADD_TEST(command_buffer_wait_for_command_buffer),
ADD_TEST(command_buffer_wait_for_sec_command_buffer),
ADD_TEST(return_event_callback),
ADD_TEST(clwaitforevents_single),
ADD_TEST(clwaitforevents),
ADD_TEST(command_buffer_wait_for_regular),
ADD_TEST(wait_for_sec_queue_event),
ADD_TEST(user_event_wait),
ADD_TEST(user_events_wait),
ADD_TEST(user_event_callback),
ADD_TEST(queue_substitution),
ADD_TEST(properties_queue_substitution),
ADD_TEST(simultaneous_queue_substitution),
ADD_TEST(queue_substitute_in_order),
ADD_TEST(queue_substitute_out_of_order),
ADD_TEST(fill_image),
ADD_TEST(fill_buffer),
ADD_TEST(fill_svm_buffer),
ADD_TEST(copy_image),
ADD_TEST(copy_buffer),
ADD_TEST(copy_svm_buffer),
ADD_TEST(copy_buffer_to_image),
ADD_TEST(copy_image_to_buffer),
ADD_TEST(copy_buffer_rect),
ADD_TEST(barrier_wait_list),
ADD_TEST(basic_printf),
ADD_TEST(simultaneous_printf),
ADD_TEST(basic_set_kernel_arg),
ADD_TEST(pending_set_kernel_arg),
ADD_TEST(event_info_command_type),
ADD_TEST(event_info_command_queue),
ADD_TEST(event_info_execution_status),
ADD_TEST(event_info_context),
ADD_TEST(event_info_reference_count),
ADD_TEST(finalize_invalid),
ADD_TEST(finalize_empty),
// Command-buffer negative tests
ADD_TEST(negative_retain_command_buffer_invalid_command_buffer),
ADD_TEST(negative_release_command_buffer_invalid_command_buffer),
ADD_TEST(negative_finalize_command_buffer_invalid_command_buffer),
ADD_TEST(negative_finalize_command_buffer_not_recording_state),
ADD_TEST(negative_command_buffer_command_fill_buffer_queue_not_null),
ADD_TEST(negative_command_buffer_command_fill_buffer_context_not_same),
ADD_TEST(
negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero),
ADD_TEST(
negative_command_buffer_command_fill_buffer_invalid_command_buffer),
ADD_TEST(
negative_command_buffer_command_fill_buffer_finalized_command_buffer),
ADD_TEST(
negative_command_buffer_command_fill_buffer_mutable_handle_not_null),
ADD_TEST(negative_command_buffer_command_fill_image_queue_not_null),
ADD_TEST(negative_command_buffer_command_fill_image_context_not_same),
ADD_TEST(
negative_command_buffer_command_fill_image_sync_points_null_or_num_zero),
ADD_TEST(negative_command_buffer_command_fill_image_invalid_command_buffer),
ADD_TEST(
negative_command_buffer_command_fill_image_finalized_command_buffer),
ADD_TEST(
negative_command_buffer_command_fill_image_mutable_handle_not_null),
ADD_TEST(negative_create_command_buffer_num_queues),
ADD_TEST(negative_create_command_buffer_null_queues),
ADD_TEST(negative_create_command_buffer_repeated_properties),
ADD_TEST(negative_create_command_buffer_not_supported_properties),
ADD_TEST(negative_command_ndrange_queue_not_null),
ADD_TEST(negative_command_ndrange_kernel_with_different_context),
ADD_TEST(negative_command_ndrange_kernel_sync_points_null_or_num_zero),
ADD_TEST(negative_command_ndrange_kernel_invalid_command_buffer),
ADD_TEST(negative_command_ndrange_kernel_invalid_properties),
ADD_TEST(negative_command_ndrange_kernel_command_buffer_finalized),
ADD_TEST(negative_command_ndrange_kernel_mutable_handle_not_null),
ADD_TEST(negative_command_ndrange_kernel_not_support_printf),
ADD_TEST(negative_command_ndrange_kernel_with_enqueue_call),
ADD_TEST(negative_command_buffer_command_copy_buffer_queue_not_null),
ADD_TEST(negative_command_buffer_command_copy_buffer_different_contexts),
ADD_TEST(
negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero),
ADD_TEST(
negative_command_buffer_command_copy_buffer_invalid_command_buffer),
ADD_TEST(
negative_command_buffer_command_copy_buffer_finalized_command_buffer),
ADD_TEST(
negative_command_buffer_command_copy_buffer_mutable_handle_not_null),
ADD_TEST(negative_command_buffer_command_copy_image_queue_not_null),
ADD_TEST(negative_command_buffer_command_copy_image_different_contexts),
ADD_TEST(
negative_command_buffer_command_copy_image_sync_points_null_or_num_zero),
ADD_TEST(negative_command_buffer_command_copy_image_invalid_command_buffer),
ADD_TEST(
negative_command_buffer_command_copy_image_finalized_command_buffer),
ADD_TEST(
negative_command_buffer_command_copy_image_mutable_handle_not_null),
ADD_TEST(negative_get_command_buffer_info_invalid_command_buffer),
ADD_TEST(negative_get_command_buffer_info_not_supported_param_name),
ADD_TEST(negative_get_command_buffer_info_queues),
ADD_TEST(negative_get_command_buffer_info_ref_count),
ADD_TEST(negative_get_command_buffer_info_state),
ADD_TEST(negative_get_command_buffer_info_prop_array),
ADD_TEST(negative_get_command_buffer_info_context),
ADD_TEST(negative_command_buffer_command_svm_queue_not_null),
ADD_TEST(negative_command_buffer_command_svm_sync_points_null_or_num_zero),
ADD_TEST(negative_command_buffer_command_svm_invalid_command_buffer),
ADD_TEST(negative_command_buffer_command_svm_finalized_command_buffer),
ADD_TEST(negative_command_buffer_command_svm_mutable_handle_not_null),
ADD_TEST(negative_command_buffer_copy_image_queue_not_null),
ADD_TEST(negative_command_buffer_copy_image_context_not_same),
ADD_TEST(negative_command_buffer_copy_image_sync_points_null_or_num_zero),
ADD_TEST(negative_command_buffer_copy_image_invalid_command_buffer),
ADD_TEST(negative_command_buffer_copy_image_finalized_command_buffer),
ADD_TEST(negative_command_buffer_copy_image_mutable_handle_not_null),
ADD_TEST(negative_command_buffer_barrier_not_null_queue),
ADD_TEST(negative_command_buffer_barrier_invalid_command_buffer),
ADD_TEST(negative_command_buffer_barrier_buffer_finalized),
ADD_TEST(negative_command_buffer_barrier_mutable_handle_not_null),
ADD_TEST(negative_command_buffer_barrier_sync_points_null_or_num_zero),
ADD_TEST(negative_enqueue_command_buffer_invalid_command_buffer),
ADD_TEST(negative_enqueue_command_buffer_not_finalized),
ADD_TEST(
negative_enqueue_command_buffer_without_simultaneous_no_pending_state),
ADD_TEST(negative_enqueue_command_buffer_null_queues_num_queues),
ADD_TEST(
negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation),
ADD_TEST(negative_enqueue_command_buffer_not_valid_queue_in_queues),
ADD_TEST(negative_enqueue_queue_with_different_context),
ADD_TEST(negative_enqueue_command_buffer_different_context_than_event),
ADD_TEST(negative_enqueue_event_wait_list_null_or_events_null),
ADD_TEST(negative_enqueue_queue_without_reqd_properties),
ADD_TEST(negative_enqueue_with_unsupported_queue_property),
ADD_TEST(negative_enqueue_inconsistent_device),
};
int main(int argc, const char *argv[])
{
// A device may report the required properties of a queue that
@@ -171,6 +22,8 @@ int main(int argc, const char *argv[])
// for this in the tests themselves, rather than here, where we have a
// device to query.
const cl_command_queue_properties queue_properties = 0;
return runTestHarnessWithCheck(argc, argv, ARRAY_SIZE(test_list), test_list,
return runTestHarnessWithCheck(argc, argv,
test_registry::getInstance().num_tests(),
test_registry::getInstance().definitions(),
false, queue_properties, nullptr);
}

22
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_barrier.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
//--------------------------------------------------------------------------
@@ -159,42 +158,31 @@ struct CommandBufferBarrierSyncPointsNullOrNumZero
};
};
int test_negative_command_buffer_barrier_not_null_queue(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_barrier_not_null_queue)
{
return MakeAndRunTest<CommandBufferBarrierNotNullQueue>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_barrier_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_barrier_invalid_command_buffer)
{
return MakeAndRunTest<CommandBufferBarrierInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_barrier_buffer_finalized(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_barrier_buffer_finalized)
{
return MakeAndRunTest<CommandBufferBarrierBufferFinalized>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_barrier_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_barrier_mutable_handle_not_null)
{
return MakeAndRunTest<CommandBufferBarrierMutableHandleNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_barrier_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_barrier_sync_points_null_or_num_zero)
{
return MakeAndRunTest<CommandBufferBarrierSyncPointsNullOrNumZero>(
device, context, queue, num_elements);

56
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
//--------------------------------------------------------------------------
template <bool check_image_support>
@@ -580,97 +579,80 @@ struct CommandBufferCopyImageMutableHandleNotNull
};
}
int test_negative_command_buffer_command_copy_buffer_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_copy_buffer_queue_not_null)
{
return MakeAndRunTest<CommandBufferCopyBufferQueueNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_image_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_copy_image_queue_not_null)
{
return MakeAndRunTest<CommandBufferCopyImageQueueNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_buffer_different_contexts(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_copy_buffer_different_contexts)
{
return MakeAndRunTest<CommandBufferCopyBufferDifferentContexts>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_image_different_contexts(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_copy_image_different_contexts)
{
return MakeAndRunTest<CommandBufferCopyImageDifferentContexts>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero)
{
return MakeAndRunTest<CommandBufferCopyBufferSyncPointsNullOrNumZero>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_image_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_copy_image_sync_points_null_or_num_zero)
{
return MakeAndRunTest<CommandBufferCopyImageSyncPointsNullOrNumZero>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_copy_buffer_invalid_command_buffer)
{
return MakeAndRunTest<CommandBufferCopyBufferInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_image_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_copy_image_invalid_command_buffer)
{
return MakeAndRunTest<CommandBufferCopyImageInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_buffer_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_copy_buffer_finalized_command_buffer)
{
return MakeAndRunTest<CommandBufferCopyBufferFinalizedCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_image_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_copy_image_finalized_command_buffer)
{
return MakeAndRunTest<CommandBufferCopyImageFinalizedCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_buffer_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_copy_buffer_mutable_handle_not_null)
{
return MakeAndRunTest<CommandBufferCopyBufferMutableHandleNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_copy_image_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_copy_image_mutable_handle_not_null)
{
return MakeAndRunTest<CommandBufferCopyImageMutableHandleNotNull>(
device, context, queue, num_elements);

25
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_copy_image.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
//--------------------------------------------------------------------------
@@ -384,49 +383,37 @@ struct CommandBufferCopyImageMutableHandleNotNull : public CommandCopyBaseTest
};
}
int test_negative_command_buffer_copy_image_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_copy_image_queue_not_null)
{
return MakeAndRunTest<CommandBufferCopyImageQueueNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_copy_image_context_not_same(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_copy_image_context_not_same)
{
return MakeAndRunTest<CommandBufferCopyImageContextNotSame>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_copy_image_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_copy_image_sync_points_null_or_num_zero)
{
return MakeAndRunTest<CommandBufferCopySyncPointsNullOrNumZero>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_copy_image_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_copy_image_invalid_command_buffer)
{
return MakeAndRunTest<CommandBufferCopyImageInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_copy_image_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_copy_image_finalized_command_buffer)
{
return MakeAndRunTest<CommandBufferCopyImageFinalizedCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_copy_image_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_copy_image_mutable_handle_not_null)
{
return MakeAndRunTest<CommandBufferCopyImageMutableHandleNotNull>(
device, context, queue, num_elements);

19
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_create.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
//--------------------------------------------------------------------------
@@ -199,35 +198,25 @@ struct CreateCommandBufferNotSupportedProperties : public BasicCommandBufferTest
};
};
int test_negative_create_command_buffer_num_queues(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_create_command_buffer_num_queues)
{
return MakeAndRunTest<CreateCommandBufferNumQueues>(device, context, queue,
num_elements);
}
int test_negative_create_command_buffer_null_queues(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_create_command_buffer_null_queues)
{
return MakeAndRunTest<CreateCommandBufferNullQueues>(device, context, queue,
num_elements);
}
int test_negative_create_command_buffer_repeated_properties(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_create_command_buffer_repeated_properties)
{
return MakeAndRunTest<CreateCommandBufferRepeatedProperties>(
device, context, queue, num_elements);
}
int test_negative_create_command_buffer_not_supported_properties(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_create_command_buffer_not_supported_properties)
{
return MakeAndRunTest<CreateCommandBufferNotSupportedProperties>(
device, context, queue, num_elements);

55
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_enqueue.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
//--------------------------------------------------------------------------
namespace {
@@ -614,103 +613,77 @@ struct EnqueueCommandBufferInconsistentDevice : public BasicCommandBufferTest
};
};
int test_negative_enqueue_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_command_buffer_invalid_command_buffer)
{
return MakeAndRunTest<EnqueueCommandBufferInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_enqueue_command_buffer_not_finalized(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_command_buffer_not_finalized)
{
return MakeAndRunTest<EnqueueCommandBufferNotFinalized>(
device, context, queue, num_elements);
}
int test_negative_enqueue_command_buffer_without_simultaneous_no_pending_state(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_enqueue_command_buffer_without_simultaneous_no_pending_state)
{
return MakeAndRunTest<
EnqueueCommandBufferWithoutSimultaneousUseNotInPendingState>(
device, context, queue, num_elements);
}
int test_negative_enqueue_command_buffer_null_queues_num_queues(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_command_buffer_null_queues_num_queues)
{
return MakeAndRunTest<EnqueueCommandBufferNullQueuesNumQueues>(
device, context, queue, num_elements);
}
int test_negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation)
{
return MakeAndRunTest<
EnqueueCommandBufferNumQueuesNotZeroAndDifferentThanWhileBufferCreation>(
device, context, queue, num_elements);
}
int test_negative_enqueue_command_buffer_not_valid_queue_in_queues(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_command_buffer_not_valid_queue_in_queues)
{
return MakeAndRunTest<EnqueueCommandBufferNotValidQueueInQueues>(
device, context, queue, num_elements);
}
int test_negative_enqueue_queue_with_different_context(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_queue_with_different_context)
{
return MakeAndRunTest<EnqueueCommandBufferQueueWithDifferentContext>(
device, context, queue, num_elements);
}
int test_negative_enqueue_command_buffer_different_context_than_event(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_command_buffer_different_context_than_event)
{
return MakeAndRunTest<EnqueueCommandBufferWithDiferentContextThanEvent>(
device, context, queue, num_elements);
}
int test_negative_enqueue_event_wait_list_null_or_events_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_event_wait_list_null_or_events_null)
{
return MakeAndRunTest<EnqueueCommandBufferEventWaitListNullOrEventsNull>(
device, context, queue, num_elements);
}
int test_negative_enqueue_queue_without_reqd_properties(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_queue_without_reqd_properties)
{
return MakeAndRunTest<EnqueueCommandBufferQueueWithoutReqdProperties>(
device, context, queue, num_elements);
}
int test_negative_enqueue_with_unsupported_queue_property(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_with_unsupported_queue_property)
{
return MakeAndRunTest<EnqueueCommandBufferWithUnsupportedQueueProperty>(
device, context, queue, num_elements);
}
int test_negative_enqueue_inconsistent_device(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_enqueue_inconsistent_device)
{
return MakeAndRunTest<EnqueueCommandBufferInconsistentDevice>(
device, context, queue, num_elements);

56
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_fill.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
//--------------------------------------------------------------------------
@@ -459,98 +458,81 @@ struct CommandBufferCommandFillImageMutableHandleNotNull
}
int test_negative_command_buffer_command_fill_buffer_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_fill_buffer_queue_not_null)
{
return MakeAndRunTest<CommandBufferCommandFillBufferQueueNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_image_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_fill_image_queue_not_null)
{
return MakeAndRunTest<CommandBufferCommandFillImageQueueNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_buffer_context_not_same(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_fill_buffer_context_not_same)
{
return MakeAndRunTest<CommandBufferCommandFillBufferContextNotSame>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_image_context_not_same(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_fill_image_context_not_same)
{
return MakeAndRunTest<CommandBufferCommandFillImageContextNotSame>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero)
{
return MakeAndRunTest<
CommandBufferCommandFillBufferSyncPointsNullOrNumZero>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_image_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_fill_image_sync_points_null_or_num_zero)
{
return MakeAndRunTest<CommandBufferCommandFillImageSyncPointsNullOrNumZero>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_fill_buffer_invalid_command_buffer)
{
return MakeAndRunTest<CommandBufferCommandFillBufferInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_image_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_fill_image_invalid_command_buffer)
{
return MakeAndRunTest<CommandBufferCommandFillImageInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_buffer_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_fill_buffer_finalized_command_buffer)
{
return MakeAndRunTest<CommandBufferCommandFillBufferFinalizedCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_image_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_fill_image_finalized_command_buffer)
{
return MakeAndRunTest<CommandBufferCommandFillImageFinalizedCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_buffer_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_fill_buffer_mutable_handle_not_null)
{
return MakeAndRunTest<CommandBufferCommandFillBufferMutableHandleNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_fill_image_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(
negative_command_buffer_command_fill_image_mutable_handle_not_null)
{
return MakeAndRunTest<CommandBufferCommandFillImageMutableHandleNotNull>(
device, context, queue, num_elements);

9
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_finalize.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
//--------------------------------------------------------------------------
@@ -136,17 +135,13 @@ struct FinalizeCommandBufferNotRecordingState : public BasicCommandBufferTest
};
};
int test_negative_finalize_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_finalize_command_buffer_invalid_command_buffer)
{
return MakeAndRunTest<FinalizeCommandBufferInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_finalize_command_buffer_not_recording_state(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_finalize_command_buffer_not_recording_state)
{
return MakeAndRunTest<FinalizeCommandBufferNotRecordingState>(
device, context, queue, num_elements);

34
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_get_info.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include <vector>
//--------------------------------------------------------------------------
@@ -259,66 +258,47 @@ struct GetCommandBufferInfo : public BasicCommandBufferTest
};
};
int test_negative_get_command_buffer_info_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_get_command_buffer_info_invalid_command_buffer)
{
return MakeAndRunTest<GetCommandBufferInfoInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_get_command_buffer_info_not_supported_param_name(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_get_command_buffer_info_not_supported_param_name)
{
return MakeAndRunTest<
GetCommandBufferInfo<CombufInfoTestMode::CITM_PARAM_NAME>>(
device, context, queue, num_elements);
}
int test_negative_get_command_buffer_info_queues(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_get_command_buffer_info_queues)
{
return MakeAndRunTest<
GetCommandBufferInfo<CombufInfoTestMode::CITM_QUEUES>>(
device, context, queue, num_elements);
}
int test_negative_get_command_buffer_info_ref_count(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_get_command_buffer_info_ref_count)
{
return MakeAndRunTest<
GetCommandBufferInfo<CombufInfoTestMode::CITM_REF_COUNT>>(
device, context, queue, num_elements);
}
int test_negative_get_command_buffer_info_state(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_get_command_buffer_info_state)
{
return MakeAndRunTest<GetCommandBufferInfo<CombufInfoTestMode::CITM_STATE>>(
device, context, queue, num_elements);
}
int test_negative_get_command_buffer_info_prop_array(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_get_command_buffer_info_prop_array)
{
return MakeAndRunTest<
GetCommandBufferInfo<CombufInfoTestMode::CITM_PROP_ARRAY>>(
device, context, queue, num_elements);
}
int test_negative_get_command_buffer_info_context(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_get_command_buffer_info_context)
{
return MakeAndRunTest<
GetCommandBufferInfo<CombufInfoTestMode::CITM_CONTEXT>>(

9
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_retain_release.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
//--------------------------------------------------------------------------
@@ -59,17 +58,13 @@ struct ReleaseCommandBufferInvalidCommandBuffer : public BasicCommandBufferTest
};
};
int test_negative_retain_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_retain_command_buffer_invalid_command_buffer)
{
return MakeAndRunTest<RetainCommandBufferInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_release_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_release_command_buffer_invalid_command_buffer)
{
return MakeAndRunTest<ReleaseCommandBufferInvalidCommandBuffer>(
device, context, queue, num_elements);

21
test_conformance/extensions/cl_khr_command_buffer/negative_command_buffer_svm_mem.cpp
View File

@@ -15,7 +15,6 @@
//
#include "basic_command_buffer.h"
#include "svm_command_basic.h"
#include "procs.h"
//--------------------------------------------------------------------------
@@ -234,41 +233,31 @@ struct CommandBufferCommandSVMMutableHandleNotNull
};
}
int test_negative_command_buffer_command_svm_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_svm_queue_not_null)
{
return MakeAndRunTest<CommandBufferCommandSVMQueueNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_svm_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_svm_sync_points_null_or_num_zero)
{
return MakeAndRunTest<CommandBufferCommandSVMSyncPointsNullOrNumZero>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_svm_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_svm_invalid_command_buffer)
{
return MakeAndRunTest<CommandBufferCommandSVMInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_svm_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_svm_finalized_command_buffer)
{
return MakeAndRunTest<CommandBufferCommandSVMFinalizedCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_buffer_command_svm_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_buffer_command_svm_mutable_handle_not_null)
{
return MakeAndRunTest<CommandBufferCommandSVMMutableHandleNotNull>(
device, context, queue, num_elements);

38
test_conformance/extensions/cl_khr_command_buffer/negative_command_nd_range_kernel.cpp
View File

@@ -14,7 +14,6 @@
// limitations under the License.
//
#include "basic_command_buffer.h"
#include "procs.h"
#include "harness/featureHelpers.h"
//--------------------------------------------------------------------------
@@ -459,74 +458,55 @@ enqueue_kernel(def_q, CLK_ENQUEUE_FLAGS_WAIT_KERNEL, ndrange,
};
};
int test_negative_command_ndrange_queue_not_null(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_queue_not_null)
{
return MakeAndRunTest<CommandNDRangeKernelQueueNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_with_different_context(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_with_different_context)
{
return MakeAndRunTest<CommandNDRangeKernelKernelWithDifferentContext>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_sync_points_null_or_num_zero)
{
return MakeAndRunTest<CommandNDRangeKerneSyncPointsNullOrNumZero>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_invalid_command_buffer)
{
return MakeAndRunTest<CommandNDRangeKernelInvalidCommandBuffer>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_invalid_properties(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_invalid_properties)
{
return MakeAndRunTest<CommandNDRangeKernelInvalidProperties>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_command_buffer_finalized(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_command_buffer_finalized)
{
return MakeAndRunTest<CommandNDRangeKernelCommandBufferFinalized>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_mutable_handle_not_null)
{
return MakeAndRunTest<CommandNDRangeKernelMutableHandleNotNull>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_not_support_printf(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_not_support_printf)
{
return MakeAndRunTest<CommandNDRangeKernelNotSupportPrintf>(
device, context, queue, num_elements);
}
int test_negative_command_ndrange_kernel_with_enqueue_call(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements)
REGISTER_TEST(negative_command_ndrange_kernel_with_enqueue_call)
{
return MakeAndRunTest<CommandNDRangeKernelWithKernelEnqueueCall>(
device, context, queue, num_elements);

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

@@ -1,410 +0,0 @@
//
// Copyright (c) 2022 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.
//
#ifndef CL_KHR_COMMAND_BUFFER_PROCS_H
#define CL_KHR_COMMAND_BUFFER_PROCS_H
#include <CL/cl.h>
// Basic command-buffer tests
extern int test_multi_flag_creation(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_single_ndrange(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_interleaved_enqueue(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_mixed_commands(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_explicit_flush(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_out_of_order(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_basic_printf(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_simultaneous_printf(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_info_queues(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_info_ref_count(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_info_state(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_info_prop_array(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_info_context(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_basic_set_kernel_arg(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_pending_set_kernel_arg(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_regular_wait_for_command_buffer(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_command_buffer_wait_for_command_buffer(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_command_buffer_wait_for_sec_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_return_event_callback(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_clwaitforevents_single(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_clwaitforevents(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_command_buffer_wait_for_regular(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_wait_for_sec_queue_event(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_user_event_wait(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_user_events_wait(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_user_event_callback(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_simultaneous_out_of_order(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_basic_profiling(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_simultaneous_profiling(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_substitute_queue_profiling(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_queue_substitution(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_properties_queue_substitution(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_simultaneous_queue_substitution(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_queue_substitute_in_order(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_queue_substitute_out_of_order(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_fill_image(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_fill_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_fill_svm_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_copy_image(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_copy_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_copy_svm_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_copy_buffer_to_image(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_copy_image_to_buffer(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_copy_buffer_rect(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_barrier_wait_list(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_event_info_command_type(cl_device_id device, cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_info_command_queue(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_info_context(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_event_info_execution_status(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_event_info_reference_count(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_finalize_invalid(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
extern int test_finalize_empty(cl_device_id device, cl_context context,
cl_command_queue queue, int num_elements);
// Command-buffer negative tests
extern int test_negative_retain_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_release_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_finalize_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_finalize_command_buffer_not_recording_state(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_fill_buffer_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_fill_buffer_context_not_same(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_buffer_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_buffer_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_fill_image_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_buffer_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_fill_image_context_not_same(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_image_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_image_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_image_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_fill_image_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_create_command_buffer_num_queues(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_create_command_buffer_null_queues(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_create_command_buffer_repeated_properties(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_create_command_buffer_not_supported_properties(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_queue_not_null(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_with_different_context(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_invalid_properties(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_command_buffer_finalized(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_not_support_printf(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_ndrange_kernel_with_enqueue_call(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_copy_buffer_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_copy_buffer_different_contexts(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_buffer_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_buffer_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_buffer_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_copy_image_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_copy_image_different_contexts(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_image_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_image_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_image_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_copy_image_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_get_command_buffer_info_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_get_command_buffer_info_not_supported_param_name(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_get_command_buffer_info_queues(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_negative_get_command_buffer_info_ref_count(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_get_command_buffer_info_state(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_negative_get_command_buffer_info_prop_array(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_get_command_buffer_info_context(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_svm_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_command_buffer_command_svm_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_svm_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_svm_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_command_svm_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_barrier_not_null_queue(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_barrier_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_barrier_buffer_finalized(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_barrier_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_barrier_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_command_buffer_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_command_buffer_not_finalized(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_enqueue_command_buffer_without_simultaneous_no_pending_state(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_command_buffer_null_queues_num_queues(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int
test_negative_enqueue_command_buffer_num_queues_not_zero_different_while_buffer_creation(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_copy_image_queue_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_copy_image_context_not_same(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_copy_image_sync_points_null_or_num_zero(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_copy_image_invalid_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_copy_image_finalized_command_buffer(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_command_buffer_copy_image_mutable_handle_not_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_command_buffer_not_valid_queue_in_queues(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_queue_with_different_context(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_command_buffer_different_context_than_event(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_event_wait_list_null_or_events_null(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_queue_without_reqd_properties(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_with_unsupported_queue_property(
cl_device_id device, cl_context context, cl_command_queue queue,
int num_elements);
extern int test_negative_enqueue_inconsistent_device(cl_device_id device,
cl_context context,
cl_command_queue queue,
int num_elements);
#endif // CL_KHR_COMMAND_BUFFER_PROCS_H