fix: prevent double-close of IPC memory handle in MemoryIPCDevice

create_ipc_from_usm_pointer_size_qref(): Wrap the MemoryIPCDevice
construction in try/except. On failure, null base._memory_ptr to
signal that __dealloc__ already closed the handle. On success, null
base._memory_ptr to prevent base's own dealloc from touching it.
Also null _memory_ptr in the SyclQueueCreationError path so the caller
knows it still owns the handle.

IPCMemoryHandle.open(): Split the single try/except into two:
- SyclQueue creation failure: handle not yet transferred, close it.
- create_ipc_from_usm_pointer_size_qref raises ValueError: failed
  before construction (queue copy), handle not closed, close it.
- Any other exception from construction: __dealloc__ already closed
  the handle, do NOT close again.

Signed-off-by: Zhan Xue <zhan.xue@intel.com>

Author: zxue2

dpctl/memory/_memory.pyx

@@ -903,7 +903,7 @@ cdef class MemoryUSMDevice(_Memory):
 
 cdef class MemoryIPCDevice(MemoryUSMDevice):
     """
-    Class representing emory object backed by an IPC-mapped USM device pointer.
+    Class representing memory object backed by an IPC-mapped USM device pointer.
 
     This class is not intended to be instantiated directly.
     """
@@ -947,12 +947,22 @@ cdef class MemoryIPCDevice(MemoryUSMDevice):
         try:
             base.queue = SyclQueue._create(QRef_copy)
         except dpctl.SyclQueueCreationError as sqce:
+            base._memory_ptr = NULL  # caller retains ownership of USMRef
             raise ValueError(
                 "SyclQueue object could not be created from "
                 "copy of referenced queue"
             ) from sqce
 
-        return MemoryIPCDevice(<object>base)
+        try:
+            result = MemoryIPCDevice(<object>base)
+        except Exception:
+            # If MemoryIPCDevice.__cinit__ failed after _cinit_other copied
+            # _memory_ptr, the partial object's __dealloc__ already closed
+            # the IPC handle.  Null base to prevent any further action.
+            base._memory_ptr = NULL
+            raise
+        base._memory_ptr = NULL  # ownership fully transferred to result
+        return result
 
 
 def as_usm_memory(obj):
@@ -1208,11 +1218,23 @@ cdef class IPCMemoryHandle:
         cdef SyclQueue q
         try:
             q = dpctl.SyclQueue(context, device)
+        except Exception:
+            DPCTLIPCMem_CloseHandle(mapped_ptr, ctx_ref)
+            raise
+
+        try:
             mem = MemoryIPCDevice.create_ipc_from_usm_pointer_size_qref(
                 mapped_ptr, nbytes, q.get_queue_ref())
-        except Exception:
+        except ValueError:
+            # Failed before MemoryIPCDevice construction (queue copy, etc).
+            # Handle was NOT closed — we still own it.
             DPCTLIPCMem_CloseHandle(mapped_ptr, ctx_ref)
             raise
+        except Exception:
+            # Failed during MemoryIPCDevice construction.
+            # MemoryIPCDevice.__dealloc__ already closed the IPC handle.
+            # Do NOT close again to avoid double-close (undefined behavior).
+            raise
 
         return mem
 

libsyclinterface/include/syclinterface/dpctl_sycl_ipc_memory_interface.h

@@ -42,8 +42,7 @@ DPCTL_C_EXTERN_C_BEGIN
  * @brief Get an IPC memory handle for a USM device pointer.
  *
  * Wraps ``sycl::ext::oneapi::experimental::ipc::memory::get()``.
- * The returned handle bytes are copied out and the driver-side handle
- * resource is released (via ``put``) before returning.
+ * The returned handle bytes are copied out.
  *
  * @param    Ptr         USM device pointer to export.
  * @param    CRef        Sycl context associated with the pointer.