[UR] Improve testing for gfx1100 on OpenCL

RossBrunton · RossBrunton · commit 068534625d99 · 2025-04-04T11:46:01.000+01:00
The driver I have at least has a number of issues, the largest of which
is that it lacks an IR compiler. Amongst other tests, this also
blacklists gfx1100 on OpenCL from any test that requires the compiler.
diff --git a/unified-runtime/test/conformance/context/urContextSetExtendedDeleter.cpp b/unified-runtime/test/conformance/context/urContextSetExtendedDeleter.cpp
@@ -14,6 +14,8 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE(urContextSetExtendedDeleterTest);
 
 TEST_P(urContextSetExtendedDeleterTest, Success) {
   UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}, uur::NativeCPU{});
+  // Segfault
+  UUR_KNOWN_FAILURE_ON(uur::OpenCL{"gfx1100"});
 
   bool called = false;
   {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueEventsWaitMultiDevice.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueEventsWaitMultiDevice.cpp
@@ -20,6 +20,7 @@ void checkDevicesSupportSharedUSM(
         uur::GetDeviceUSMSingleSharedSupport(device, shared_usm_single));
     if (!shared_usm_single) {
       GTEST_SKIP() << "Shared USM is not supported by the device.";
+      return;
     }
   }
 }
@@ -31,7 +32,7 @@ struct urEnqueueEventsWaitMultiDeviceTest
 
     UUR_RETURN_ON_FATAL_FAILURE(uur::urMultiQueueMultiDeviceTest<2>::SetUp());
 
-    checkDevicesSupportSharedUSM(devices);
+    UUR_RETURN_ON_FATAL_FAILURE(checkDevicesSupportSharedUSM(devices));
 
     ptrs.resize(devices.size());
     for (size_t i = 0; i < devices.size(); i++) {
@@ -129,7 +130,7 @@ struct urEnqueueEventsWaitMultiDeviceMTTest
     UUR_RETURN_ON_FATAL_FAILURE(
         uur::urMultiQueueMultiDeviceTestWithParam<8,
                                                   uur::BoolTestParam>::SetUp());
-    checkDevicesSupportSharedUSM(devices);
+    UUR_RETURN_ON_FATAL_FAILURE(checkDevicesSupportSharedUSM(devices));
 
     ptrs.resize(devices.size());
     for (size_t i = 0; i < devices.size(); i++) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunch.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunch.cpp
@@ -529,8 +529,9 @@ struct urEnqueueKernelLaunchMultiDeviceTest
 
     uur::KernelsEnvironment::instance->LoadSource("foo", platform, il_binary);
 
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        platform, context, devices[0], *il_binary, nullptr, &program));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            platform, context, devices[0], *il_binary, nullptr, &program));
 
     ASSERT_SUCCESS(urProgramBuild(context, program, nullptr));
     ASSERT_SUCCESS(urKernelCreate(program, kernelName.data(), &kernel));
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunchAndMemcpyInOrder.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunchAndMemcpyInOrder.cpp
@@ -65,9 +65,10 @@ struct urMultiQueueLaunchMemcpyTest
           metadatas.empty() ? nullptr : metadatas.data()};
 
       uur::raii::Program program;
-      ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-          platform, context, devices[i], *il_binary, &properties,
-          &programs[i]));
+      UUR_RETURN_ON_FATAL_FAILURE(
+          uur::KernelsEnvironment::instance->CreateProgram(
+              platform, context, devices[i], *il_binary, &properties,
+              &programs[i]));
 
       UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
           urProgramBuild(context, programs[i], nullptr));
diff --git a/unified-runtime/test/conformance/exp_command_buffer/fixtures.h b/unified-runtime/test/conformance/exp_command_buffer/fixtures.h
@@ -246,8 +246,9 @@ struct TestKernel {
         UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr,
         static_cast<uint32_t>(Metadatas.size()),
         Metadatas.empty() ? nullptr : Metadatas.data()};
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        Platform, Context, Device, *ILBinary, &Properties, &Program));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            Platform, Context, Device, *ILBinary, &Properties, &Program));
 
     auto KernelNames =
         uur::KernelsEnvironment::instance->GetEntryPointNames(Name);
diff --git a/unified-runtime/test/conformance/kernel/urKernelCreate.cpp b/unified-runtime/test/conformance/kernel/urKernelCreate.cpp
@@ -74,8 +74,10 @@ TEST_P(urMultiDeviceKernelCreateTest, WithProgramBuild) {
 
     const ur_program_properties_t properties = {
         UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr, 0, nullptr};
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        platform, context, devices[i], *il_binary, &properties, program.ptr()));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            platform, context, devices[i], *il_binary, &properties,
+            program.ptr()));
 
     ASSERT_SUCCESS(urProgramBuild(context, program.get(), nullptr));
     ASSERT_SUCCESS(
@@ -107,8 +109,10 @@ TEST_P(urMultiDeviceKernelCreateTest, WithProgramCompileAndLink) {
 
     const ur_program_properties_t properties = {
         UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr, 0, nullptr};
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        platform, context, devices[i], *il_binary, &properties, program.ptr()));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            platform, context, devices[i], *il_binary, &properties,
+            program.ptr()));
 
     ASSERT_SUCCESS(urProgramCompile(context, program.get(), nullptr));
 
diff --git a/unified-runtime/test/conformance/memory-migrate/urMemBufferMigrateAcrossDevices.cpp b/unified-runtime/test/conformance/memory-migrate/urMemBufferMigrateAcrossDevices.cpp
@@ -71,9 +71,10 @@ struct urMultiDeviceContextMemBufferTest : urMultiDeviceContextTest {
         static_cast<uint32_t>(metadatas.size()),
         metadatas.empty() ? nullptr : metadatas.data()};
     for (auto i = 0u; i < num_devices; ++i) {
-      ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-          platform, context, devices[i], *il_binary, &properties,
-          &programs[i]));
+      UUR_RETURN_ON_FATAL_FAILURE(
+          uur::KernelsEnvironment::instance->CreateProgram(
+              platform, context, devices[i], *il_binary, &properties,
+              &programs[i]));
       ASSERT_SUCCESS(urProgramBuild(context, programs[i], nullptr));
       auto kernel_names =
           uur::KernelsEnvironment::instance->GetEntryPointNames(program_name);
diff --git a/unified-runtime/test/conformance/memory/urMemBufferPartition.cpp b/unified-runtime/test/conformance/memory/urMemBufferPartition.cpp
@@ -100,6 +100,8 @@ TEST_P(urMemBufferPartitionTest, InvalidBufferSize) {
 
 TEST_P(urMemBufferPartitionTest, InvalidValueCreateType) {
   UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::NativeCPU{});
+  // Seems to report "success"
+  UUR_KNOWN_FAILURE_ON(uur::OpenCL{"gfx1100"});
 
   // create a read only buffer
   uur::raii::Mem ro_buffer = nullptr;
diff --git a/unified-runtime/test/conformance/memory/urMemImageCreateWithImageFormatParam.cpp b/unified-runtime/test/conformance/memory/urMemImageCreateWithImageFormatParam.cpp
@@ -100,6 +100,9 @@ TEST_P(urMemImageCreateTestWithImageFormatParam, Success) {
   UUR_KNOWN_FAILURE_ON(uur::NativeCPU{});
   // See https://github.com/oneapi-src/unified-runtime/issues/2638
   UUR_KNOWN_FAILURE_ON(uur::OpenCL{"Intel(R) UHD Graphics 770"});
+  // Reports INVALID_IMAGE_FORMAT_DESCRIPTOR rather than
+  // UNSUPPORTED_IMAGE_FORMAT
+  UUR_KNOWN_FAILURE_ON(uur::OpenCL{"gfx1100"});
 
   ur_image_channel_order_t channel_order = std::get<1>(GetParam()).channelOrder;
   ur_image_channel_type_t channel_type = std::get<1>(GetParam()).channelType;
diff --git a/unified-runtime/test/conformance/program/urProgramCreateWithIL.cpp b/unified-runtime/test/conformance/program/urProgramCreateWithIL.cpp
@@ -34,17 +34,17 @@ struct urProgramCreateWithILTest : uur::urContextTest {
 UUR_INSTANTIATE_DEVICE_TEST_SUITE(urProgramCreateWithILTest);
 
 TEST_P(urProgramCreateWithILTest, Success) {
-  UUR_KNOWN_FAILURE_ON(uur::CUDA{});
+  UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::OpenCL{"gfx1100"});
 
   ur_program_handle_t program = nullptr;
-  ASSERT_SUCCESS(urProgramCreateWithIL(context, il_binary->data(),
-                                       il_binary->size(), nullptr, &program));
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(urProgramCreateWithIL(
+      context, il_binary->data(), il_binary->size(), nullptr, &program));
   ASSERT_NE(nullptr, program);
   ASSERT_SUCCESS(urProgramRelease(program));
 }
 
 TEST_P(urProgramCreateWithILTest, SuccessWithProperties) {
-  UUR_KNOWN_FAILURE_ON(uur::CUDA{});
+  UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::OpenCL{"gfx1100"});
 
   std::string string = "test metadata";
   ur_program_metadata_value_t md_value_string;
@@ -80,7 +80,7 @@ TEST_P(urProgramCreateWithILTest, SuccessWithProperties) {
       static_cast<uint32_t>(metadatas.size()), metadatas.data()};
 
   ur_program_handle_t program = nullptr;
-  ASSERT_SUCCESS(urProgramCreateWithIL(
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(urProgramCreateWithIL(
       context, il_binary->data(), il_binary->size(), &properties, &program));
   ASSERT_NE(nullptr, program);
   ASSERT_SUCCESS(urProgramRelease(program));
@@ -140,7 +140,8 @@ TEST_P(urProgramCreateWithILTest, InvalidBinary) {
   auto result = urProgramCreateWithIL(context, &binary, 5, nullptr, &program);
   // The driver is not required to reject the binary
   ASSERT_TRUE(result == UR_RESULT_ERROR_INVALID_BINARY ||
-              result == UR_RESULT_SUCCESS);
+              result == UR_RESULT_SUCCESS ||
+              result == UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE);
 }
 
 TEST_P(urProgramCreateWithILTest, CompilerNotAvailable) {
diff --git a/unified-runtime/test/conformance/program/urProgramLink.cpp b/unified-runtime/test/conformance/program/urProgramLink.cpp
@@ -103,8 +103,9 @@ struct urProgramLinkErrorTest : uur::urQueueTest {
     std::shared_ptr<std::vector<char>> il_binary{};
     UUR_RETURN_ON_FATAL_FAILURE(uur::KernelsEnvironment::instance->LoadSource(
         linker_error_program_name, platform, il_binary));
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        platform, context, device, *il_binary, nullptr, &program));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            platform, context, device, *il_binary, nullptr, &program));
     ASSERT_SUCCESS(urProgramCompile(context, program, nullptr));
   }
 
diff --git a/unified-runtime/test/conformance/sampler/urSamplerCreate.cpp b/unified-runtime/test/conformance/sampler/urSamplerCreate.cpp
@@ -63,6 +63,13 @@ TEST_P(urSamplerCreateTestWithParam, Success) {
   const auto addr_mode = std::get<1>(param);
   const auto filter_mode = std::get<2>(param);
 
+  if (normalized == false &&
+      (addr_mode == UR_SAMPLER_ADDRESSING_MODE_REPEAT ||
+       addr_mode == UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT)) {
+    // Invalid value
+    UUR_KNOWN_FAILURE_ON(uur::OpenCL{"gfx1100"});
+  }
+
   ur_sampler_desc_t sampler_desc{
       UR_STRUCTURE_TYPE_SAMPLER_DESC, /* stype */
       nullptr,                        /* pNext */
diff --git a/unified-runtime/test/conformance/source/environment.cpp b/unified-runtime/test/conformance/source/environment.cpp
@@ -12,6 +12,7 @@
 #include "ur_api.h"
 #include "ur_filesystem_resolved.hpp"
 #include "uur/checks.h"
+#include "uur/known_failure.h"
 
 #ifdef KERNELS_ENVIRONMENT
 #include "kernel_entry_points.h"
@@ -279,34 +280,32 @@ void KernelsEnvironment::LoadSource(
   binary_out = std::move(binary_ptr);
 }
 
-ur_result_t KernelsEnvironment::CreateProgram(
+void KernelsEnvironment::CreateProgram(
     ur_platform_handle_t hPlatform, ur_context_handle_t hContext,
     ur_device_handle_t hDevice, const std::vector<char> &binary,
     const ur_program_properties_t *properties, ur_program_handle_t *phProgram) {
+  // Seems to not support an IR compiler
+  std::tuple<ur_platform_handle_t, ur_device_handle_t> tuple{hPlatform,
+                                                             hDevice};
+  UUR_KNOWN_FAILURE_ON_PARAM(tuple, uur::OpenCL{"gfx1100"});
+
   ur_platform_backend_t backend;
-  if (auto error =
-          urPlatformGetInfo(hPlatform, UR_PLATFORM_INFO_BACKEND,
-                            sizeof(ur_platform_backend_t), &backend, nullptr)) {
-    return error;
-  }
+  ASSERT_SUCCESS(urPlatformGetInfo(hPlatform, UR_PLATFORM_INFO_BACKEND,
+                                   sizeof(ur_platform_backend_t), &backend,
+                                   nullptr));
   if (backend == UR_PLATFORM_BACKEND_HIP ||
       backend == UR_PLATFORM_BACKEND_CUDA) {
     // The CUDA and HIP adapters do not support urProgramCreateWithIL so we
     // need to use urProgramCreateWithBinary instead.
     auto size = binary.size();
     auto data = binary.data();
-    if (auto error = urProgramCreateWithBinary(
-            hContext, 1, &hDevice, &size,
-            reinterpret_cast<const uint8_t **>(&data), properties, phProgram)) {
-      return error;
-    }
+    ASSERT_SUCCESS(urProgramCreateWithBinary(
+        hContext, 1, &hDevice, &size, reinterpret_cast<const uint8_t **>(&data),
+        properties, phProgram));
   } else {
-    if (auto error = urProgramCreateWithIL(
-            hContext, binary.data(), binary.size(), properties, phProgram)) {
-      return error;
-    }
+    ASSERT_SUCCESS(urProgramCreateWithIL(hContext, binary.data(), binary.size(),
+                                         properties, phProgram));
   }
-  return UR_RESULT_SUCCESS;
 }
 
 std::vector<std::string> KernelsEnvironment::GetEntryPointNames(
diff --git a/unified-runtime/test/conformance/testing/include/uur/checks.h b/unified-runtime/test/conformance/testing/include/uur/checks.h
@@ -32,7 +32,7 @@ inline std::ostream &operator<<(std::ostream &out, const Result &result) {
 
 #define UUR_RETURN_ON_FATAL_FAILURE(...)                                       \
   __VA_ARGS__;                                                                 \
-  if (this->HasFatalFailure() || this->IsSkipped()) {                          \
+  if (::testing::Test::HasFatalFailure() || ::testing::Test::IsSkipped()) {    \
     return;                                                                    \
   }                                                                            \
   (void)0
diff --git a/unified-runtime/test/conformance/testing/include/uur/environment.h b/unified-runtime/test/conformance/testing/include/uur/environment.h
@@ -71,12 +71,11 @@ struct KernelsEnvironment : DevicesEnvironment {
   void LoadSource(const std::string &kernel_name, ur_platform_handle_t platform,
                   std::shared_ptr<std::vector<char>> &binary_out);
 
-  ur_result_t CreateProgram(ur_platform_handle_t hPlatform,
-                            ur_context_handle_t hContext,
-                            ur_device_handle_t hDevice,
-                            const std::vector<char> &binary,
-                            const ur_program_properties_t *properties,
-                            ur_program_handle_t *phProgram);
+  void CreateProgram(ur_platform_handle_t hPlatform,
+                     ur_context_handle_t hContext, ur_device_handle_t hDevice,
+                     const std::vector<char> &binary,
+                     const ur_program_properties_t *properties,
+                     ur_program_handle_t *phProgram);
 
   std::vector<std::string> GetEntryPointNames(std::string program);
 
diff --git a/unified-runtime/test/conformance/testing/include/uur/fixtures.h b/unified-runtime/test/conformance/testing/include/uur/fixtures.h
@@ -396,8 +396,9 @@ struct urHostPipeTest : urQueueTest {
 
     UUR_RETURN_ON_FATAL_FAILURE(uur::KernelsEnvironment::instance->LoadSource(
         "foo", platform, il_binary));
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        platform, context, device, *il_binary, nullptr, &program));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            platform, context, device, *il_binary, nullptr, &program));
   }
 
   void TearDown() override {
@@ -1233,8 +1234,9 @@ struct urProgramTest : urQueueTest {
         UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr,
         static_cast<uint32_t>(metadatas.size()),
         metadatas.empty() ? nullptr : metadatas.data()};
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        platform, context, device, *il_binary, &properties, &program));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            platform, context, device, *il_binary, &properties, &program));
   }
 
   void TearDown() override {
@@ -1273,9 +1275,10 @@ template <class T> struct urProgramTestWithParam : urQueueTestWithParam<T> {
         static_cast<uint32_t>(metadatas.size()),
         metadatas.empty() ? nullptr : metadatas.data()};
 
-    ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
-        this->platform, this->context, this->device, *il_binary, &properties,
-        &program));
+    UUR_RETURN_ON_FATAL_FAILURE(
+        uur::KernelsEnvironment::instance->CreateProgram(
+            this->platform, this->context, this->device, *il_binary,
+            &properties, &program));
   }
 
   void TearDown() override {
diff --git a/unified-runtime/test/conformance/testing/include/uur/known_failure.h b/unified-runtime/test/conformance/testing/include/uur/known_failure.h
@@ -140,6 +140,24 @@ inline bool isKnownFailureOn(const DeviceTuple &param,
   return false;
 }
 
+inline bool
+isKnownFailureOn(std::tuple<ur_platform_handle_t, ur_device_handle_t> param,
+                 const std::vector<Matcher> &matchers) {
+  ur_adapter_handle_t adapter = nullptr;
+  uur::GetPlatformInfo<ur_adapter_handle_t>(std::get<0>(param),
+                                            UR_PLATFORM_INFO_ADAPTER, adapter);
+  auto adapterInfo = detail::getAdapterInfo(adapter);
+  std::string name;
+  uur::GetDeviceInfo<std::string>(std::get<1>(param), UR_DEVICE_INFO_NAME,
+                                  name);
+  for (const auto &matcher : matchers) {
+    if (matcher.matches(adapterInfo, name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 template <class Param>
 inline bool isKnownFailureOn(const std::tuple<DeviceTuple, Param> &param,
                              const std::vector<Matcher> &matchers) {
@@ -197,9 +215,9 @@ inline bool alsoRunKnownFailures() {
 }
 } // namespace uur
 
-#define UUR_KNOWN_FAILURE_ON(...)                                              \
-  if (uur::isKnownFailureOn(this->GetParam(), {__VA_ARGS__})) {                \
-    auto message = uur::knownFailureMessage(this->GetParam());                 \
+#define UUR_KNOWN_FAILURE_ON_PARAM(param, ...)                                 \
+  if (uur::isKnownFailureOn(param, {__VA_ARGS__})) {                           \
+    auto message = uur::knownFailureMessage(param);                            \
     if (uur::alsoRunKnownFailures()) {                                         \
       std::cerr << message << "\n";                                            \
     } else {                                                                   \
@@ -208,4 +226,7 @@ inline bool alsoRunKnownFailures() {
   }                                                                            \
   (void)0
 
+#define UUR_KNOWN_FAILURE_ON(...)                                              \
+  UUR_KNOWN_FAILURE_ON_PARAM(this->GetParam(), __VA_ARGS__)
+
 #endif // UR_CONFORMANCE_INCLUDE_KNOWN_FAILURE_H_INCLUDED

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE(urContextSetExtendedDeleterTest);`
`14`	`14`
`15`	`15`	`TEST_P(urContextSetExtendedDeleterTest, Success) {`
`16`	`16`	`UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}, uur::NativeCPU{});`
	`17`	`+ // Segfault`
	`18`	`+ UUR_KNOWN_FAILURE_ON(uur::OpenCL{"gfx1100"});`
`17`	`19`
`18`	`20`	`bool called = false;`
`19`	`21`	`{`