Struct SessionBuilder

pub struct SessionBuilder<'a> {
    pub program_src: Option<&'a str>,
    pub program_binaries: Option<&'a [u8]>,
    pub device_type: Option<DeviceType>,
    pub platforms: Option<&'a [ClPlatformID]>,
    pub devices: Option<&'a [ClDeviceID]>,
    pub command_queue_properties: Option<CommandQueueProperties>,
}

Fields

program_src: Option<&'a str>

program_binaries: Option<&'a [u8]>

device_type: Option<DeviceType>

platforms: Option<&'a [ClPlatformID]>

devices: Option<&'a [ClDeviceID]>

command_queue_properties: Option<CommandQueueProperties>

Implementations

impl<'a> SessionBuilder<'a>

pub fn new() -> SessionBuilder<'a>

Examples found in repository

examples/ll_simple_add/main.rs (line 130)

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[..]));
    }
}

pub fn with_program_src(self, src: &'a str) -> SessionBuilder<'a>

Examples found in repository

examples/ll_simple_add/main.rs (line 130)

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[..]));
    }
}

pub fn with_program_binaries(self, bins: &'a [u8]) -> SessionBuilder<'a>

pub fn with_platforms(self, platforms: &'a [ClPlatformID]) -> SessionBuilder<'a>

pub fn with_devices(self, devices: &'a [ClDeviceID]) -> SessionBuilder<'a>

pub fn with_device_type(self, device_type: DeviceType) -> SessionBuilder<'a>

pub fn with_command_queue_properties( self, props: CommandQueueProperties, ) -> SessionBuilder<'a>

pub unsafe fn build(self) -> Output<Session>

Builds a SessionBuilder into a Session

Safety

This function may, in fact, be safe, mismanagement of objects and lifetimes are not possible as long as the underlying function calls are implemented as intended. However, this claim needs to be reviewed. For now it remains marked as unsafe.

Examples found in repository

examples/ll_simple_add/main.rs (line 130)

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<'a> Default for SessionBuilder<'a>

fn default() -> SessionBuilder<'a>

Returns the “default value” for a type.