Struct BufferReadEvent

pub struct BufferReadEvent<T: ClNumber> { /* private fields */ }

Implementations

impl<T: ClNumber> BufferReadEvent<T>

pub fn new(event: ClEvent, host_buffer: Option<Vec<T>>) -> BufferReadEvent<T>

pub fn wait(&mut self) -> Output<Option<Vec<T>>>

Examples found in repository

examples/ll_simple_add/main.rs (line 155)

fn run_with_session() {
    let src = include_str!("simple_add.ocl");
    unsafe {
        let mut session = SessionBuilder::new().with_program_src(src).build().unwrap();

        let vec_a = vec![1i64, 2, 3];
        let vec_b = vec![0i64, -1, -2];

        let mut mem_a = session.create_mem(&vec_a[..]).unwrap();
        let mut mem_b = session.create_mem(&vec_b[..]).unwrap();
        let mut mem_c: ClMem = session.create_mem::<i64, usize>(vec_a.len()).unwrap();

        let mut simple_add = session.create_kernel("simple_add").unwrap();

        simple_add.set_arg(0, &mut mem_a).unwrap();
        simple_add.set_arg(1, &mut mem_b).unwrap();
        simple_add.set_arg(2, &mut mem_c).unwrap();
        let work: Work = Work::new(vec_a.len());

        let mut vec_c = vec_a.clone();

        let enqueue_event = session
            .enqueue_kernel(0, &mut simple_add, &work, None)
            .unwrap();
        let () = enqueue_event.wait().unwrap();
        let mut read_event = session
            .read_buffer(0, &mut mem_c, &mut vec_c[..], None)
            .unwrap();
        let read_output = read_event.wait().unwrap();
        assert_eq!(read_output, None);

        // at this point vec_c *should* be the result of calling simple_add and reading from mem_c;
        println!("  {}", string_from_slice(&vec_a[..]));
        println!("+ {}", string_from_slice(&vec_b[..]));
        println!("= {}", string_from_slice(&vec_c[..]));
    }
}

Trait Implementations

impl<T: ClNumber> Drop for BufferReadEvent<T>

fn drop(&mut self)

Executes the destructor for this type.