diff --git a/CHANGELOG.md b/CHANGELOG.md index 446be5c..d53b4d2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,6 +24,8 @@ can be found at: - Initial Rust API for discovering SYCL platforms and devices. - Queues, events, contexts, USM allocations, and host/device memory operations. +- Dropping a `UsmBox` waits for the copies and fills that use it, so its + memory is not freed while a device may still use it. - Runtime kernel bundle compilation and one-, two-, and three-dimensional kernel launch support. - Derive support for typed kernel argument lists. diff --git a/sycl/sycl-rs/src/lib.rs b/sycl/sycl-rs/src/lib.rs index 0073685..bffcd59 100644 --- a/sycl/sycl-rs/src/lib.rs +++ b/sycl/sycl-rs/src/lib.rs @@ -90,9 +90,10 @@ //! ``` //! //! # Safety model -//! - USM allocations are represented by a zero-cost [`UsmBox`](crate::usmbox::UsmBox) type managed -//! through RAII. +//! - USM allocations are represented by a [`UsmBox`](crate::usmbox::UsmBox) type managed through +//! RAII. //! - Note: `UsmBox` arrays do not rely on accessors, unlike SYCL buffers. +//! - Dropping a `UsmBox` waits for the copies and fills that use it to complete. //! - `UsmBox`es are zero-initialized by default. //! - `UsmBox`es can only store types that implement [`bytemuck::Pod`]. //! - Kernel launch is inherently unsafe. In particular, the caller must ensure that every argument diff --git a/sycl/sycl-rs/src/queue.rs b/sycl/sycl-rs/src/queue.rs index d0814e4..2ff6f07 100644 --- a/sycl/sycl-rs/src/queue.rs +++ b/sycl/sycl-rs/src/queue.rs @@ -140,7 +140,10 @@ impl Queue { ptr: (*e).clone().0, }) .collect::>(); - unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes, dep_events) }.map(Into::into) + let event: Event = + unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes, dep_events) }?.into(); + array.add_pending(&event); + Ok(event) } /// Submits a barrier to the queue. @@ -228,7 +231,7 @@ impl Queue { .collect::>(); let num_bytes = src.get_len() * size_of::(); - unsafe { + let event: Event = unsafe { ffi::memcpy( &mut self.0, dst.get_byte_ptr(), @@ -236,8 +239,11 @@ impl Queue { num_bytes, dep_events, ) - } - .map(Into::into) + }? + .into(); + src.add_pending(&event); + dst.add_pending(&event); + Ok(event) } } diff --git a/sycl/sycl-rs/src/usmbox.rs b/sycl/sycl-rs/src/usmbox.rs index b9ba1ab..b41a792 100644 --- a/sycl/sycl-rs/src/usmbox.rs +++ b/sycl/sycl-rs/src/usmbox.rs @@ -8,6 +8,7 @@ use std::{ alloc::{Layout, handle_alloc_error}, + cell::RefCell, ops::{Deref, DerefMut}, pin::Pin, ptr::NonNull, @@ -21,6 +22,7 @@ use pin_project::pin_project; use crate::{ Result, event::{Event, EventFuture}, + info::{self, InfoTarget}, kernel::KernelArgument, usm::{ DeviceAllocator, HostAccessible, HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator, @@ -39,11 +41,16 @@ use crate::{ /// The `UsmBox` struct takes a generic parameter [`UsmAlloc`](`crate::usm::UsmAlloc`) for /// specifying an allocator which is used by the SYCL runtime when allocating temporary memory on /// the host. +/// +/// A `UsmBox` keeps track of the copies and fills that use it, and dropping it waits for them to +/// complete, so its memory is not freed while a device may still use it. pub struct UsmBox { data: NonNull, len: usize, layout: Layout, allocator: A, + /// Events of the enqueued commands that may still use the memory. + pending: RefCell>, } impl UsmBox { @@ -61,7 +68,25 @@ impl UsmBox { len, layout, allocator, + pending: RefCell::default(), + } + } + + /// Records an enqueued command that uses the memory, so that dropping the box waits for it. + pub(crate) fn add_pending(&self, event: &Event) { + let mut pending = self.pending.borrow_mut(); + // Forget the completed commands only once the list is full, and leave room for as many + // new ones as are still pending, so that recording a command takes amortized constant + // time even when many are in flight. + if pending.len() == pending.capacity() { + pending.retain(|command| { + command.get_info::() + != info::EventCommandStatus::Complete + }); + let still_pending = pending.len(); + pending.reserve(still_pending); } + pending.push(event.clone()); } pub(crate) fn get_byte_ptr(&self) -> *mut u8 { @@ -96,10 +121,15 @@ impl DerefMut for UsmBox { } } +/// Waits for the copies and fills that use the `UsmBox`, then frees its memory. If waiting fails, +/// the memory is leaked, since a command may still be using it. impl Drop for UsmBox { fn drop(&mut self) { - unsafe { - self.allocator.deallocate(self.data.cast(), self.layout); + let waited = self.pending.get_mut().iter_mut().try_for_each(Event::wait); + if waited.is_ok() { + unsafe { + self.allocator.deallocate(self.data.cast(), self.layout); + } } } } @@ -124,7 +154,7 @@ impl EnqueuedUsmBox { /// Performs a blocking wait for the [`UsmBox`] initialization to complete. Returns an error if /// a synchronous SYCL exception occurs. /// - /// Dropping an enqueued array does not wait for its completion. + /// Dropping an enqueued array waits for its initialization to complete, then frees it. pub fn wait(mut self) -> Result> { self.event.wait().map(|_| self.array) }