Add conformance tests

scripts/core/EXP-COMMAND-BUFFER.rst

@@ -178,11 +178,12 @@ kernels ND-Range and parameters.
  nullptr,
  true
  };
- ${x}_exp_command_buffer_command_handle_t handle;
+ ${x}_exp_command_buffer_handle_t hCommandBuffer;
  ${x}CommandBufferCreateExp(hContext, hDevice, &desc, &handle);
 
  // Append a kernel command which has two buffer parameters, an input
  // and an output.
+ ${x}_exp_command_buffer_command_handle_t handle;
  ${x}CommandBufferAppendKernelLaunchExp(hCommandBuffer, hKernel, workDim,
  pGlobalWorkOffset, pGlobalWorkSize,
  pLocalWorkSize, 0, nullptr,

source/adapters/cuda/device.cpp

@@ -1030,6 +1030,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
  case UR_DEVICE_INFO_GPU_HW_THREADS_PER_EU:
  return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
 
+ case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP:
+ case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_SUPPORT_EXP:
+ return ReturnValue(true);
+
  default:
  break;
  }

source/adapters/hip/device.cpp

@@ -837,6 +837,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
  case UR_DEVICE_INFO_ASYNC_BARRIER:
  return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
 
+ case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP:
+ case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_SUPPORT_EXP:
+ return ReturnValue(false);
+
  default:
  break;
  }

source/adapters/level_zero/device.cpp

@@ -823,6 +823,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(
  return ReturnValue(result);
  }
 
+ case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP:
+ return ReturnValue(true);
+ case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_SUPPORT_EXP:
+ return ReturnValue(false);
+
  default:
  urPrint("Unsupported ParamName in urGetDeviceInfo\n");
  urPrint("ParamName=%d(0x%x)\n", ParamName, ParamName);

source/adapters/native_cpu/device.cpp

@@ -304,6 +304,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
  CASE_UR_UNSUPPORTED(UR_DEVICE_INFO_MAX_MEMORY_BANDWIDTH);
  case UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT:
  return ReturnValue(false);
+
+ case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP:
+ case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_SUPPORT_EXP:
+ return ReturnValue(false);
+
  default:
  DIE_NO_IMPLEMENTATION;
  }

source/adapters/opencl/device.cpp

@@ -947,6 +947,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
  case UR_DEVICE_INFO_ASYNC_BARRIER: {
  return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
  }
+
+ case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP:
+ return ReturnValue(true);
+ case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_SUPPORT_EXP:
+ return ReturnValue(false);
+
  default: {
  return UR_RESULT_ERROR_INVALID_ENUMERATION;
  }

test/conformance/CMakeLists.txt

@@ -94,6 +94,7 @@ add_subdirectory(event)
 add_subdirectory(queue)
 add_subdirectory(sampler)
 add_subdirectory(virtual_memory)
+add_subdirectory(exp_command_buffer)
 
 if(UR_DPCXX)
  add_custom_target(generate_device_binaries)

test/conformance/exp_command_buffer/CMakeLists.txt

@@ -0,0 +1,8 @@
+# Copyright (C) 2023 Intel Corporation
+# Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+# See LICENSE.TXT
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+add_conformance_test_with_kernels_environment(exp_command_buffer
+ urCommandBufferAppendKernelLaunchExp.cpp
+)

test/conformance/exp_command_buffer/urCommandBufferAppendKernelLaunchExp.cpp

@@ -0,0 +1,36 @@
+// Copyright (C) 2023 Intel Corporation
+// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+// See LICENSE.TXT
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <uur/fixtures.h>
+
+
+struct urAppendKernelLaunchTest : uur::urExpUpdatableCommandBufferTests {
+ void SetUp() override {
+ program_name = "fill";
+ UUR_RETURN_ON_FATAL_FAILURE(urKernelExecutionTest::SetUp());
+ }
+
+ uint32_t val = 42;
+ size_t local_size = 4;
+ size_t global_size = 32;
+ size_t global_offset = 0;
+ size_t n_dimensions = 1;
+};
+
+
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urAppendKernelLaunchTest);
+
+TEST_P(urAppendKernelLaunchTest, Success) {
+ ur_mem_handle_t buffer = nullptr;
+ AddBuffer1DArg(sizeof(val) * global_size, &buffer);
+ AddPodArg(val);
+
+ ur_exp_command_buffer_command_handle_t command_handle;
+ EXPECT_SUCCESS(urCommandBufferAppendKernelLaunchExp(updatable_cmd_buf_handle,
+ kernel, n_dimensions,
+ &global_offset, &global_size,
+ &local_size, 0, nullptr,
+ nullptr, &command_handle));
+}

test/conformance/testing/include/uur/fixtures.h

@@ -1003,6 +1003,8 @@ struct urUSMDeviceAllocTestWithParam : urQueueTestWithParam<T> {
  ur_usm_pool_handle_t pool = nullptr;
 };
 
+
+
 // Generates a random byte pattern for MemFill type entry-points.
 inline void generateMemFillPattern(std::vector<uint8_t> &pattern) {
  const size_t seed = 1;
@@ -1255,7 +1257,7 @@ struct urBaseKernelExecutionTest : urBaseKernelTest {
 };
 
 struct urKernelExecutionTest : urBaseKernelExecutionTest {
- void SetUp() {
+ void SetUp() override {
  UUR_RETURN_ON_FATAL_FAILURE(urBaseKernelExecutionTest::SetUp());
  Build();
  }
@@ -1276,6 +1278,79 @@ struct urGlobalVariableTest : uur::urKernelExecutionTest {
  GlobalVar<int> global_var;
 };
 
+struct urExpCommandBufferTest : urKernelExecutionTest {
+ void SetUp() override {
+ UUR_RETURN_ON_FATAL_FAILURE(urKernelExecutionTest::SetUp());
+
+ size_t returned_size;
+ ASSERT_SUCCESS(urDeviceGetInfo(device, UR_DEVICE_INFO_EXTENSIONS, 0, nullptr,
+ &returned_size));
+
+ std::unique_ptr<char[]> returned_extensions(new char[returned_size]);
+
+ ASSERT_SUCCESS(urDeviceGetInfo(device, UR_DEVICE_INFO_EXTENSIONS, returned_size,
+ returned_extensions.get(), nullptr));
+
+ std::string_view extensions_string(returned_extensions.get());
+ bool command_buffer_support =
+ extensions_string.find(UR_COMMAND_BUFFER_EXTENSION_STRING_EXP)
+ != std::string::npos;
+
+ if (!command_buffer_support) {
+ GTEST_SKIP() << "EXP command-buffer feature is not supported.";
+ }
+
+ ASSERT_SUCCESS(urDeviceGetInfo(
+ device, UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_SUPPORT_EXP, sizeof(ur_bool_t),
+ &updatable_command_buffer_support , nullptr));
+
+ // Create a command-buffer
+ ASSERT_SUCCESS(urCommandBufferCreateExp(context, device, nullptr, &cmd_buf_handle));
+ ASSERT_NE(cmd_buf_handle, nullptr);
+ }
+
+ void TearDown() override {
+ if (cmd_buf_handle) {
+ EXPECT_SUCCESS(urCommandBufferReleaseExp(cmd_buf_handle));
+ }
+ UUR_RETURN_ON_FATAL_FAILURE(urKernelExecutionTest::TearDown());
+ }
+
+ ur_exp_command_buffer_handle_t cmd_buf_handle = nullptr;
+ ur_bool_t updatable_command_buffer_support = false;
+};
+
+struct urExpUpdatableCommandBufferTests: urExpCommandBufferTest {
+ void SetUp() override {
+ UUR_RETURN_ON_FATAL_FAILURE(urExpCommandBufferTest ::SetUp());
+
+ if (!updatable_command_buffer_support) {
+ GTEST_SKIP() << "Updating EXP command-buffers is not supported.";
+ }
+
+ // Create a command-buffer with update enabled.
+ ur_exp_command_buffer_desc_t desc {
+ UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC,
+ nullptr,
+ true
+ };
+
+ ASSERT_SUCCESS(urCommandBufferCreateExp(context, device, &desc, &updatable_cmd_buf_handle));
+ ASSERT_NE(updatable_cmd_buf_handle, nullptr);
+ }
+
+ void TearDown() override {
+ if (updatable_cmd_buf_handle) {
+ EXPECT_SUCCESS(urCommandBufferReleaseExp(updatable_cmd_buf_handle));
+ }
+ UUR_RETURN_ON_FATAL_FAILURE(urExpCommandBufferTest::TearDown());
+ }
+
+ ur_exp_command_buffer_handle_t updatable_cmd_buf_handle = nullptr;
+};
+
+
+
 } // namespace uur
 
 #endif // UR_CONFORMANCE_INCLUDE_FIXTURES_H_INCLUDED