[UR] Improve testing for gfx1100 on OpenCL

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;
   {

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++) {

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));

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));

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);

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));
 

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);

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;

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;

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) {

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));
   }
 

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 */

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(

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

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);
 

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 {

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