Struct Work

Source

pub struct Work {
    pub global_size: Dims,
    pub global_offset: Option<Dims>,
    pub local_size: Option<Dims>,
}

Expand description

Work is a representation of 1, 2, or 3 dimensions.

For global_size none of the specified dimensions can be 0.

For global_offset any specficied dimension can be any usize.

For local_size none of the specified dimensions can be 0.

Fields§

§global_size: Dims§global_offset: Option<Dims>§local_size: Option<Dims>

Implementations§

Source §

impl Work

Source

pub fn new<D: Into<Dims>>(global_size: D) -> Work

Examples found in repository ?

examples/ll_simple_add/main.rs (line 56)

12fn run_procedural() {
13    unsafe {
14        let src = include_str!("simple_add.ocl");
15
16        let mut platforms = list_platforms().unwrap();
17
18        if platforms.len() == 0 {
19            panic!("No platforms found!!!");
20        }
21
22        let platform = platforms.remove(0);
23        let devices = list_devices_by_type(&platform, DeviceType::ALL).unwrap();
24
25        if devices.len() == 0 {
26            panic!("No devices found!!!");
27        }
28        let context = ClContext::create(&devices[..]).unwrap();
29
30        println!("creating program...");
31        let mut program: ClProgram = ClProgram::create_with_source(&context, src).unwrap();
32
33        let names = devices.iter().map(|d| d.name().unwrap());
34        println!("building program on devices {:?}...", names);
35
36        let () = program
37            .build(&devices[..])
38            .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
39
40        for device in devices[0..1].iter() {
41            let program2 = (&program).clone();
42            let r_count = program2.reference_count().unwrap();
43            let prog_log = program2.get_log(device).unwrap();
44            let prog_src = program2.source().unwrap();
45            println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
46            println!("Device {:?}", device);
47
48            let mut command_queue: ClCommandQueue =
49                ClCommandQueue::create(&context, device, None).unwrap();
50
51            let vec_a = vec![1i64, 2, 3];
52            let vec_b = vec![0i64, -1, -2];
53
54            let len = vec_a.len();
55
56            let work: Work = Work::new(len);
57            let name = device.name().unwrap();
58            println!("{}", name);
59
60            let mut mem_a = ClMem::create::<i64, usize>(
61                &context,
62                len,
63                HostAccess::WriteOnly,
64                KernelAccess::ReadOnly,
65                MemLocation::AllocOnDevice,
66            )
67            .unwrap();
68            let mut mem_b = ClMem::create::<i64, usize>(
69                &context,
70                len,
71                HostAccess::WriteOnly,
72                KernelAccess::ReadOnly,
73                MemLocation::AllocOnDevice,
74            )
75            .unwrap();
76            let mut mem_c = ClMem::create::<i64, usize>(
77                &context,
78                len,
79                HostAccess::ReadOnly,
80                KernelAccess::WriteOnly,
81                MemLocation::AllocOnDevice,
82            )
83            .unwrap();
84            println!("Creating kernel simple_add");
85            let mut simple_add = ClKernel::create(&program2, "simple_add").unwrap();
86
87            println!("writing buffer a...");
88            let _write_event_a = command_queue
89                .write_buffer(&mut mem_a, &vec_a[..], None)
90                .unwrap();
91
92            println!("writing buffer b...");
93            let _write_event_b = command_queue
94                .write_buffer(&mut mem_b, &vec_b[..], None)
95                .unwrap();
96
97            println!("mem_a {:?}", mem_a);
98
99            println!("setting simple_add arg 0 as mem_a");
100            simple_add.set_arg(0, &mut mem_a).unwrap();
101
102            println!("setting simple_add arg 1 as mem_b");
103            simple_add.set_arg(1, &mut mem_b).unwrap();
104
105            println!("setting simple_add mut arg 2 as mem_c");
106            simple_add.set_arg(2, &mut mem_c).unwrap();
107
108            println!("calling enqueue_kernel on simple_add");
109            let event = command_queue
110                .enqueue_kernel(&mut simple_add, &work, None)
111                .unwrap();
112            let () = event.wait().unwrap();
113            println!("done putting event into WaitList...");
114            let mut vec_c = vec![0i64; len];
115
116            let _read_event = command_queue
117                .read_buffer(&mem_c, &mut vec_c[..], None)
118                .unwrap();
119
120            println!("  {}", string_from_slice(&vec_a[..]));
121            println!("+ {}", string_from_slice(&vec_b[..]));
122            println!("= {}", string_from_slice(&vec_c[..]));
123        }
124    }
125}
126
127fn run_with_session() {
128    let src = include_str!("simple_add.ocl");
129    unsafe {
130        let mut session = SessionBuilder::new().with_program_src(src).build().unwrap();
131
132        let vec_a = vec![1i64, 2, 3];
133        let vec_b = vec![0i64, -1, -2];
134
135        let mut mem_a = session.create_mem(&vec_a[..]).unwrap();
136        let mut mem_b = session.create_mem(&vec_b[..]).unwrap();
137        let mut mem_c: ClMem = session.create_mem::<i64, usize>(vec_a.len()).unwrap();
138
139        let mut simple_add = session.create_kernel("simple_add").unwrap();
140
141        simple_add.set_arg(0, &mut mem_a).unwrap();
142        simple_add.set_arg(1, &mut mem_b).unwrap();
143        simple_add.set_arg(2, &mut mem_c).unwrap();
144        let work: Work = Work::new(vec_a.len());
145
146        let mut vec_c = vec_a.clone();
147
148        let enqueue_event = session
149            .enqueue_kernel(0, &mut simple_add, &work, None)
150            .unwrap();
151        let () = enqueue_event.wait().unwrap();
152        let mut read_event = session
153            .read_buffer(0, &mut mem_c, &mut vec_c[..], None)
154            .unwrap();
155        let read_output = read_event.wait().unwrap();
156        assert_eq!(read_output, None);
157
158        // at this point vec_c *should* be the result of calling simple_add and reading from mem_c;
159        println!("  {}", string_from_slice(&vec_a[..]));
160        println!("+ {}", string_from_slice(&vec_b[..]));
161        println!("= {}", string_from_slice(&vec_c[..]));
162    }
163}

Source

pub fn global_work_size(&self) -> Output<GlobalWorkSize>

A 3D array that describes the Volume of the Work. A Work’s global_work_size must describe a non-zero Volume. For example, [4, 3, 2] is a 4 by 3 by 2 Volume that does not result in an empty volume (4 * 3 * 2 != 0); to drive this point home the Volume [3, 3, 0] is not a valid global_work_size because the product of its elements equal 0.

Source

pub fn global_work_offset(&self) -> GlobalWorkOffset

A 3D array that describes the 3 dimensional offset of the Work. The global_work_size can be None or can be specified as a Dims. Because the global_work_offset describes an of a 3 dimensional collection/buffer the dimensionality of the data can be zero. Some([0, 0, 0]) is a valid global_work_offset.

Source