[−][src]Struct rustacuda::stream::Stream
A stream of work for the device to perform.
See the module-level documentation for more information.
Implementations
impl Stream
[src]
pub fn new(flags: StreamFlags, priority: Option<i32>) -> CudaResult<Self>
[src]
Create a new stream with the given flags and optional priority.
By convention, priority
follows a convention where lower numbers represent greater
priorities. That is, work in a stream with a lower priority number may pre-empt work in
a stream with a higher priority number. Context::get_stream_priority_range
can be used
to get the range of valid priority values; if priority is set outside that range, it will
be automatically clamped to the lowest or highest number in the range.
Examples
use rustacuda::stream::{Stream, StreamFlags}; // With default priority let stream = Stream::new(StreamFlags::NON_BLOCKING, None)?; // With specific priority let priority = Stream::new(StreamFlags::NON_BLOCKING, 1i32.into())?;
pub fn get_flags(&self) -> CudaResult<StreamFlags>
[src]
Return the flags which were used to create this stream.
Examples
use rustacuda::stream::{Stream, StreamFlags}; let stream = Stream::new(StreamFlags::NON_BLOCKING, None)?; assert_eq!(StreamFlags::NON_BLOCKING, stream.get_flags().unwrap());
pub fn get_priority(&self) -> CudaResult<i32>
[src]
Return the priority of this stream.
If this stream was created without a priority, returns the default priority. If the stream was created with a priority outside the valid range, returns the clamped priority.
Examples
use rustacuda::stream::{Stream, StreamFlags}; let stream = Stream::new(StreamFlags::NON_BLOCKING, 1i32.into())?; println!("{}", stream.get_priority()?);
pub fn add_callback<T>(&self, callback: Box<T>) -> CudaResult<()> where
T: FnOnce(CudaResult<()>) + Send,
[src]
T: FnOnce(CudaResult<()>) + Send,
Add a callback to a stream.
The callback will be executed after all previously queued items in the stream have been completed. Subsequently queued items will not execute until the callback is finished.
Callbacks must not make any CUDA API calls.
The callback will be passed a CudaResult<()>
indicating the
current state of the device with Ok(())
denoting normal operation.
Examples
use rustacuda::stream::{Stream, StreamFlags}; let stream = Stream::new(StreamFlags::NON_BLOCKING, 1i32.into())?; // ... queue up some work on the stream stream.add_callback(Box::new(|status| { println!("Device status is {:?}", status); })); // ... queue up some more work on the stream
pub fn synchronize(&self) -> CudaResult<()>
[src]
Wait until a stream's tasks are completed.
Waits until the device has completed all operations scheduled for this stream.
Examples
use rustacuda::stream::{Stream, StreamFlags}; let stream = Stream::new(StreamFlags::NON_BLOCKING, 1i32.into())?; // ... queue up some work on the stream // Wait for the work to be completed. stream.synchronize()?;
pub fn wait_event(
&self,
event: Event,
flags: StreamWaitEventFlags
) -> CudaResult<()>
[src]
&self,
event: Event,
flags: StreamWaitEventFlags
) -> CudaResult<()>
Make the stream wait on an event.
All future work submitted to the stream will wait for the event to complete. Synchronization is performed on the device, if possible. The event may originate from different context or device than the stream.
Example
use rustacuda::stream::{Stream, StreamFlags, StreamWaitEventFlags}; use rustacuda::event::{Event, EventFlags}; let stream_0 = Stream::new(StreamFlags::NON_BLOCKING, None)?; let stream_1 = Stream::new(StreamFlags::NON_BLOCKING, None)?; let event = Event::new(EventFlags::DEFAULT)?; // do some work on stream_0 ... // record an event event.record(&stream_0)?; // wait until the work on stream_0 is finished before continuing stream_1 stream_1.wait_event(event, StreamWaitEventFlags::DEFAULT)?; }
pub fn drop(stream: Stream) -> DropResult<Stream>
[src]
Destroy a Stream
, returning an error.
Destroying a stream can return errors from previous asynchronous work. This function destroys the given stream and returns the error and the un-destroyed stream on failure.
Example
use rustacuda::stream::{Stream, StreamFlags}; let stream = Stream::new(StreamFlags::NON_BLOCKING, 1i32.into())?; match Stream::drop(stream) { Ok(()) => println!("Successfully destroyed"), Err((e, stream)) => { println!("Failed to destroy stream: {:?}", e); // Do something with stream }, }
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Stream
impl !Send for Stream
impl !Sync for Stream
impl Unpin for Stream
impl UnwindSafe for Stream
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,