Struct TaskArg

Source

pub struct TaskArg<'a> { /* private fields */ }

Expand description

Represents a data argument for an MCL task along with the use flags (e.g. input, output, access type etc.)

Implementations§

Source §

impl<'a> TaskArg<'a>

Source

pub fn input_slice<T>(slice: &'a [T]) -> Self

Create a new task input argument from slice

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();
     let data = vec![0; 4];
     let task = mcl.task("my_kernel", 1)
                 .arg(mcl_rs::TaskArg::input_slice(&data));

Source

pub fn input_scalar<T>(scalar: &'a T) -> Self

Create a new task input argument from scalar

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();
     let data = 4;
     let task = mcl.task("my_kernel", 1)
                 .arg(mcl_rs::TaskArg::input_scalar(&data));

Source

pub fn input_shared<T>(name: &str, size: usize) -> Self

Available on crate feature shared_mem only.

Create an new task input argument using a shared memory buffer

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();

     let num_elems = 100;
     let buffer = mcl.create_shared_buffer(mcl_rs::TaskArg::input_shared::<f32>("my_buffer",num_elems).resident(true));
     let task = mcl.task("my_kernel",1)
                   .input_shared(buffer);

Source

pub fn output_slice<T>(slice: &'a mut [T]) -> Self

Create a new task output argument from slice

Returns a new TaskArg

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();
     let mut data = vec![0; 4];
     let mcl_future = mcl.task("my_kernel", 1)
                 .arg(mcl_rs::TaskArg::output_slice(&mut data));

Source

pub fn output_shared<T>(name: &str, size: usize) -> Self

Available on crate feature shared_mem only.

Create an new task output argument using a shared memory buffer

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();

     let num_elems = 100;
     let buffer = mcl.create_shared_buffer(mcl_rs::TaskArg::output_shared::<f32>("my_buffer",num_elems).resident(true));
     let task = mcl.task("my_kernel",1)
                   .output_shared(buffer);

Source

pub fn output_scalar<T>(scalar: &'a T) -> Self

Create a new task output argument from scalar

Returns a new TaskArg

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();
     let mut data = 4;
     let mcl_future = mcl.task("my_kernel", 1)
                 .arg(mcl_rs::TaskArg::output_scalar(&mut data));

Source

pub fn inout_slice<T>(slice: &'a [T]) -> Self

Create a new task input+output argument from slice

Returns a new TaskArg

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();
     let mut data = vec![0; 4];
     let mcl_future = mcl.task("my_kernel", 1)
                 .arg(mcl_rs::TaskArg::inout_slice(&mut data));

Source

pub fn inout_shared<T>(name: &str, size: usize) -> Self

Available on crate feature shared_mem only.

Create an new task input+output argument using a shared memory buffer

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();

     let num_elems = 100;
     let buffer = mcl.create_shared_buffer(mcl_rs::TaskArg::inout_shared::<f32>("my_buffer",num_elems).resident(true));
     let task = mcl.task("my_kernel",1)
                   .inout_shared(buffer);

Source

pub fn inout_scalar<T>(scalar: &'a T) -> Self

Create a new task input+output argument from scalar

Returns a new TaskArg

§Examples

     let mcl = mcl_rs::MclEnvBuilder::new().initialize();
     mcl.create_prog("my_prog",mcl_rs::PrgType::Src)
         .with_compile_args("-D MYDEF").load();
     let mut data = 4;
     let mcl_future = mcl.task("my_kernel", 1)
                 .arg(mcl_rs::TaskArg::inout_scalar(&mut data));

Source