Struct rust_cuda::utils::async::Async

pub struct Async<'a, 'stream, T: BorrowMut<C::Completed>, C: Completion<T> = NoCompletion> { /* private fields */ }

Available on crate feature host only.

Implementations

impl<'a, 'stream, T: BorrowMut<C::Completed>, C: Completion<T>> Async<'a, 'stream, T, C>

pub const fn ready(value: T, stream: Stream<'stream>) -> Self

Wraps a value which is ready on stream.

pub fn pending( value: T, stream: Stream<'stream>, completion: C ) -> CudaResult<Self>

Wraps a still-pending value which is being computed on stream such that its computation can be synchronised on.

Errors

Returns a rustacuda::error::CudaError iff an error occurs inside CUDA.

pub fn synchronize(self) -> CudaResult<T>

Synchronises on this computation to block until it has completed and the inner value can be safely returned and again be used in synchronous operations.

Calling synchronize after the computation has completed, e.g. after calling rustacuda::stream::Stream::synchronize, should be very cheap.

Errors

Returns a rustacuda::error::CudaError iff an error occurs inside CUDA.

pub fn move_to_stream<'stream_new>( self, stream: Stream<'stream_new> ) -> CudaResult<Async<'a, 'stream_new, T, C>>

Moves the asynchronous data move to a different Stream.

This method always adds a synchronisation barrier between the old and and the new Stream to ensure that any usages of this Async computations on the old Stream have completed before they can be used on the new one.

Errors

Returns a rustacuda::error::CudaError iff an error occurs inside CUDA.

pub unsafe fn unwrap_unchecked(self) -> CudaResult<(T, Option<C>)>

Safety

The returned inner value of type T may not yet have completed its asynchronous work and may thus be in an inconsistent state.

This method must only be used to construct a larger asynchronous computation out of smaller ones that have all been submitted to the same Stream.

pub const fn as_ref(&self) -> AsyncProj<'_, 'stream, &T>

pub fn as_mut(&mut self) -> AsyncProj<'_, 'stream, &mut T>

impl<'a, 'stream, T: PortableBitSemantics + TypeGraphLayout, C: Completion<HostAndDeviceConstRef<'a, T>>> Async<'a, 'stream, HostAndDeviceConstRef<'a, T>, C>

where HostAndDeviceConstRef<'a, T>: BorrowMut<C::Completed>,

pub const fn extract_ref( &self ) -> AsyncProj<'_, 'stream, HostAndDeviceConstRef<'_, T>>

impl<'a, 'stream, T: PortableBitSemantics + TypeGraphLayout, C: Completion<HostAndDeviceMutRef<'a, T>>> Async<'a, 'stream, HostAndDeviceMutRef<'a, T>, C>

where HostAndDeviceMutRef<'a, T>: BorrowMut<C::Completed>,

pub fn extract_ref( &self ) -> AsyncProj<'_, 'stream, HostAndDeviceConstRef<'_, T>>

pub fn extract_mut( &mut self ) -> AsyncProj<'_, 'stream, HostAndDeviceMutRef<'_, T>>

impl<'a, 'stream, T: RustToCudaAsync<CudaAllocationAsync: EmptyCudaAlloc, CudaAllocation: EmptyCudaAlloc>> Async<'a, 'stream, ExchangeWrapperOnDevice<T>, NoCompletion>

pub fn move_to_host_async( self, stream: Stream<'stream> ) -> CudaResult<Async<'static, 'stream, ExchangeWrapperOnHost<T>, CompletionFnMut<'static, ExchangeWrapperOnHost<T>>>>

Moves the data asynchronously back to the host CPU device.

Errors

Returns a rustacuda::error::CudaError iff an error occurs inside CUDA

pub fn as_ref_async( &self ) -> AsyncProj<'_, 'stream, HostAndDeviceConstRef<'_, DeviceAccessible<<T as RustToCuda>::CudaRepresentation>>>

pub fn as_mut_async( &mut self ) -> AsyncProj<'_, 'stream, HostAndDeviceMutRef<'_, DeviceAccessible<<T as RustToCuda>::CudaRepresentation>>>

where T: SafeMutableAliasing,

Trait Implementations

impl<'a, 'stream, T: BorrowMut<C::Completed>, C: Completion<T>> Drop for Async<'a, 'stream, T, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, 'stream, T: BorrowMut<C::Completed>, C: Completion<T>> IntoFuture for Async<'a, 'stream, T, C>

type Output = Result<T, CudaError>

The output that the future will produce on completion.

type IntoFuture = impl Future<Output = <Async<'a, 'stream, T, C> as IntoFuture>::Output>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.