Enable program conformace test for L0

Author: againull

.github/workflows/multi_device.yml

@@ -63,4 +63,4 @@ jobs:
 
     - name: Test adapters
       working-directory: ${{github.workspace}}/build
-      run: env UR_CTS_ADAPTER_PLATFORM="${{matrix.adapter.platform}}" ctest -C ${{matrix.build_type}} --output-on-failure -L "conformance" -E "enqueue|kernel|program|integration|exp_command_buffer|exp_enqueue_native|exp_launch_properties|exp_usm_p2p" --timeout 180
+      run: env UR_CTS_ADAPTER_PLATFORM="${{matrix.adapter.platform}}" ctest -C ${{matrix.build_type}} --output-on-failure -L "conformance" -E "enqueue|kernel|integration|exp_command_buffer|exp_enqueue_native|exp_launch_properties|exp_usm_p2p" --timeout 180

source/adapters/level_zero/program.cpp

@@ -905,8 +905,15 @@ ur_result_t urProgramGetNativeHandle(
 
   std::shared_lock<ur_shared_mutex> Guard(Program->Mutex);
   assert(Program->AssociatedDevices.size() > 0);
-  auto Module =
-      Program->getZeModuleHandle(Program->AssociatedDevices[0]->ZeDevice);
+  // Current API doesn't allow to specify device for which we want to get the
+  // native handle. So, find the first device with a valid module handle.
+  ze_module_handle_t Module = nullptr;
+  for (const auto &Device : Program->AssociatedDevices) {
+    Module = Program->getZeModuleHandle(Device->ZeDevice);
+    if (Module) {
+      break;
+    }
+  }
   if (!Module)
     return UR_RESULT_ERROR_INVALID_OPERATION;
 
@@ -924,7 +931,6 @@ ur_result_t urProgramCreateWithNativeHandle(
     ur_program_handle_t *Program ///< [out] pointer to the handle of the
                                  ///< program object created.
 ) {
-  std::ignore = Properties;
   UR_ASSERT(Context && NativeProgram, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
   UR_ASSERT(Program, UR_RESULT_ERROR_INVALID_NULL_POINTER);
   auto ZeModule = ur_cast<ze_module_handle_t>(NativeProgram);
@@ -934,9 +940,9 @@ ur_result_t urProgramCreateWithNativeHandle(
   // executable (state Object).
 
   try {
-    ur_program_handle_t_ *UrProgram =
-        new ur_program_handle_t_(ur_program_handle_t_::Exe, Context, ZeModule,
-                                 Properties->isNativeHandleOwned);
+    ur_program_handle_t_ *UrProgram = new ur_program_handle_t_(
+        ur_program_handle_t_::Exe, Context, ZeModule,
+        Properties ? Properties->isNativeHandleOwned : false);
     *Program = reinterpret_cast<ur_program_handle_t>(UrProgram);
   } catch (const std::bad_alloc &) {
     return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;

test/conformance/program/urProgramCreateWithNativeHandle.cpp

@@ -9,6 +9,14 @@ struct urProgramCreateWithNativeHandleTest : uur::urProgramTest {
     void SetUp() override {
         UUR_RETURN_ON_FATAL_FAILURE(urProgramTest::SetUp());
         {
+            ur_platform_backend_t backend;
+            ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND,
+                                             sizeof(backend), &backend,
+                                             nullptr));
+            // For Level Zero we have to build the program to have the native handle.
+            if (backend == UR_PLATFORM_BACKEND_LEVEL_ZERO) {
+                ASSERT_SUCCESS(urProgramBuild(context, program, nullptr));
+            }
             UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
                 urProgramGetNativeHandle(program, &native_program_handle));
         }

test/conformance/program/urProgramGetBuildInfo.cpp

@@ -33,8 +33,19 @@ TEST_P(urProgramGetBuildInfoTest, Success) {
     auto property_name = getParam();
     size_t property_size = 0;
     std::vector<char> property_value;
-    ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name, 0,
-                                         nullptr, &property_size));
+    ur_platform_backend_t backend;
+    ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND,
+                                     sizeof(backend), &backend, nullptr));
+    auto result = urProgramGetBuildInfo(program, device, property_name, 0,
+                                        nullptr, &property_size);
+
+    if (property_name == UR_PROGRAM_BUILD_INFO_STATUS &&
+        backend == UR_PLATFORM_BACKEND_LEVEL_ZERO) {
+        ASSERT_EQ(UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION, result);
+        return;
+    }
+
+    ASSERT_SUCCESS(result);
     property_value.resize(property_size);
     ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name,
                                          property_size, property_value.data(),

test/conformance/program/urProgramGetFunctionPointer.cpp

@@ -29,10 +29,18 @@ TEST_P(urProgramGetFunctionPointerTest, Success) {
 TEST_P(urProgramGetFunctionPointerTest, InvalidKernelName) {
     void *function_pointer = nullptr;
     std::string missing_function = "aFakeFunctionName";
-    ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_KERNEL_NAME,
-                     urProgramGetFunctionPointer(device, program,
-                                                 missing_function.data(),
-                                                 &function_pointer));
+    auto result = urProgramGetFunctionPointer(
+        device, program, missing_function.data(), &function_pointer);
+    ur_platform_backend_t backend;
+    ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND,
+                                     sizeof(backend), &backend, nullptr));
+    // TODO: level zero backend incorrectly returns UR_RESULT_ERROR_UNSUPPORTED_FEATURE
+    if (backend == UR_PLATFORM_BACKEND_LEVEL_ZERO) {
+        ASSERT_EQ(UR_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
+    } else {
+        ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_KERNEL_NAME, result);
+    }
+
     ASSERT_EQ(function_pointer, nullptr);
 }
 

test/conformance/program/urProgramGetNativeHandle.cpp

@@ -9,6 +9,13 @@ using urProgramGetNativeHandleTest = uur::urProgramTest;
 UUR_INSTANTIATE_KERNEL_TEST_SUITE_P(urProgramGetNativeHandleTest);
 
 TEST_P(urProgramGetNativeHandleTest, Success) {
+    ur_platform_backend_t backend;
+    ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND,
+                                     sizeof(backend), &backend, nullptr));
+    // For Level Zero we have to build the program to have the native handle.
+    if (backend == UR_PLATFORM_BACKEND_LEVEL_ZERO) {
+        ASSERT_SUCCESS(urProgramBuild(context, program, nullptr));
+    }
     ur_native_handle_t native_program_handle = 0;
     if (auto error =
             urProgramGetNativeHandle(program, &native_program_handle)) {