Fix CTS tests.

Author: aarongreig

scripts/core/PROG.rst

@@ -287,17 +287,6 @@ ${x}QueueRetain. An application must call ${x}QueueRelease
 when a queue object is no longer needed. When a queue object's reference count becomes
 zero, it is deleted by the runtime.
 
-Native Driver Access
-----------------------------------
-
-The runtime API provides accessors for native handles.
-For example, given a ${x}_program_handle_t, we can
-call ${x}ProgramGetNativeHandle to retrieve a ${x}_native_handle_t.
-We can then leverage a platform extension to convert the
-native handle to a driver handle. For example, OpenCL platform
-may expose an extension ${x}ProgramCreateWithNativeHandle to retrieve
-a cl_program.
-
 Memory
 ======
 
@@ -361,10 +350,9 @@ Native Handle Ownership
 -----------------------
 
 By default a ${X} object constructed from a native handle doesn't own the
-native handle, it is guaranteed not to modify the native handle's reference
-count or otherwise cause its resources to be released. A ${X} object that
-doesn't own its associated native handle **must** be destroyed before the
-native handle is.
+native handle, it is guaranteed not to retain a reference to the native handle,
+or cause its resources to be released. A ${X} object that doesn't own its
+associated native handle **must** be destroyed before the native handle is.
 
 Ownership of the native handle can be tranferred to the ${X} object by passing
 ``isNativeHandleOwned = true`` in the native properties struct when calling the

source/adapters/cuda/queue.cpp

@@ -284,17 +284,19 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   std::vector<CUstream> ComputeCuStreams(1, CuStream);
   std::vector<CUstream> TransferCuStreams(0);
 
+  auto isNativeHandleOwned =
+      pProperties ? pProperties->isNativeHandleOwned : false;
+
   // Create queue and set num_compute_streams to 1, as computeCuStreams has
   // valid stream
-  *phQueue =
-      new ur_queue_handle_t_{std::move(ComputeCuStreams),
-                             std::move(TransferCuStreams),
-                             hContext,
-                             hDevice,
-                             CuFlags,
-                             Flags,
-                             /*priority*/ 0,
-                             /*backend_owns*/ pProperties->isNativeHandleOwned};
+  *phQueue = new ur_queue_handle_t_{std::move(ComputeCuStreams),
+                                    std::move(TransferCuStreams),
+                                    hContext,
+                                    hDevice,
+                                    CuFlags,
+                                    Flags,
+                                    /*priority*/ 0,
+                                    /*backend_owns*/ isNativeHandleOwned};
   (*phQueue)->NumComputeStreams = 1;
 
   return UR_RESULT_SUCCESS;

source/adapters/hip/memory.cpp

@@ -302,6 +302,9 @@ UR_APIEXPORT ur_result_t UR_APICALL
 urMemGetNativeHandle(ur_mem_handle_t hMem, ur_device_handle_t Device,
                      ur_native_handle_t *phNativeMem) {
   UR_ASSERT(Device != nullptr, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
+  if (hMem->isImage()) {
+    return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  }
 #if defined(__HIP_PLATFORM_NVIDIA__)
   if (sizeof(BufferMem::native_type) > sizeof(ur_native_handle_t)) {
     // Check that all the upper bits that cannot be represented by

source/adapters/hip/queue.cpp

@@ -318,17 +318,19 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   std::vector<hipStream_t> ComputeHIPStreams(1, HIPStream);
   std::vector<hipStream_t> TransferHIPStreams(0);
 
+  auto isNativeHandleOwned =
+      pProperties ? pProperties->isNativeHandleOwned : false;
+
   // Create queue and set num_compute_streams to 1, as computeHIPStreams has
   // valid stream
-  *phQueue =
-      new ur_queue_handle_t_{std::move(ComputeHIPStreams),
-                             std::move(TransferHIPStreams),
-                             hContext,
-                             hDevice,
-                             HIPFlags,
-                             Flags,
-                             /*priority*/ 0,
-                             /*backend_owns*/ pProperties->isNativeHandleOwned};
+  *phQueue = new ur_queue_handle_t_{std::move(ComputeHIPStreams),
+                                    std::move(TransferHIPStreams),
+                                    hContext,
+                                    hDevice,
+                                    HIPFlags,
+                                    Flags,
+                                    /*priority*/ 0,
+                                    /*backend_owns*/ isNativeHandleOwned};
   (*phQueue)->NumComputeStreams = 1;
 
   return UR_RESULT_SUCCESS;

source/adapters/level_zero/kernel.cpp

@@ -1118,9 +1118,9 @@ ur_result_t urKernelCreateWithNativeHandle(
   ze_kernel_handle_t ZeKernel = ur_cast<ze_kernel_handle_t>(NativeKernel);
   ur_kernel_handle_t_ *Kernel = nullptr;
   try {
-    Kernel = new ur_kernel_handle_t_(ZeKernel, Properties->isNativeHandleOwned,
-                                     Context);
-    if (Properties->isNativeHandleOwned) {
+    auto OwnNativeHandle = Properties ? Properties->isNativeHandleOwned : false;
+    Kernel = new ur_kernel_handle_t_(ZeKernel, OwnNativeHandle, Context);
+    if (OwnNativeHandle) {
       // If ownership is passed to the adapter we need to pass the kernel
       // to this vector which is then used during ZeKernelRelease.
       Kernel->ZeKernels.push_back(ZeKernel);

source/adapters/level_zero/program.cpp

@@ -937,7 +937,8 @@ ur_result_t urProgramGetNativeHandle(
     }
   }
   if (!Module)
-    return UR_RESULT_ERROR_INVALID_OPERATION;
+    // L0 only supprts returning native handle from built programs.
+    return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 
   *ZeModule = Module;
   return UR_RESULT_SUCCESS;

source/adapters/opencl/ur_interface_loader.cpp

@@ -159,6 +159,7 @@ urGetMemProcAddrTable(ur_api_version_t Version, ur_mem_dditable_t *pDdiTable) {
   pDdiTable->pfnGetNativeHandle = urMemGetNativeHandle;
   pDdiTable->pfnImageCreate = urMemImageCreate;
   pDdiTable->pfnImageGetInfo = urMemImageGetInfo;
+  pDdiTable->pfnImageCreateWithNativeHandle = urMemImageCreateWithNativeHandle;
   pDdiTable->pfnRelease = urMemRelease;
   pDdiTable->pfnRetain = urMemRetain;
   return UR_RESULT_SUCCESS;

test/conformance/memory/urMemImageCreateWithNativeHandle.cpp

@@ -16,14 +16,7 @@ struct urMemImageCreateWithNativeHandleTest : uur::urMemImageTest {
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemImageCreateWithNativeHandleTest);
 
 TEST_P(urMemImageCreateWithNativeHandleTest, Success) {
-<<<<<<< HEAD
   UUR_KNOWN_FAILURE_ON(uur::HIP{}, uur::LevelZero{});
-=======
-  ur_native_handle_t native_handle = 0;
-  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
-      urMemGetNativeHandle(image, device, &native_handle));
->>>>>>> a2dab68a (Update cts tests.)
-
   ur_native_handle_t native_handle = 0;
   UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
       urMemGetNativeHandle(image, device, &native_handle));