Struct CommandQueue

Source

pub struct CommandQueue { /* private fields */ }

Implementations§

Source §

impl CommandQueue

Source

pub fn create( context: &Context, device: &Device, opt_props: Option<CommandQueueProperties>, ) -> Output<CommandQueue>

Creates a new CommandQueue with the given Context on the given Device.

Examples found in repository ?

examples/simple_add/main.rs (line 50)

14fn run_procedural() {
15    let src = include_str!("simple_add.ocl");
16
17    let mut platforms = Platform::list_all().unwrap();
18
19    if platforms.len() == 0 {
20        panic!("No platforms found!!!");
21    }
22
23    let platform = platforms.remove(0);
24    let devices = Device::list_all_devices(&platform).unwrap();
25
26    if devices.len() == 0 {
27        panic!("No devices found!!!");
28    }
29    let context = Context::create(&devices[..]).unwrap();
30
31    println!("creating program...");
32    let unbuilt_program: UnbuiltProgram =
33        UnbuiltProgram::create_with_source(&context, src).unwrap();
34
35    let names = devices.iter().map(|d| d.low_level_device().name().unwrap());
36    println!("building program on devices {:?}...", names);
37
38    let program: Program = unbuilt_program
39        .build(&devices[..])
40        .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
41
42    for device in devices[0..1].iter() {
43        let program2 = (&program).clone();
44        let r_count = program2.low_level_program().reference_count().unwrap();
45        let prog_log = program2.low_level_program().get_log(device).unwrap();
46        let prog_src = program2.low_level_program().source().unwrap();
47        println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
48        println!("Device {:?}", device);
49
50        let command_queue: CommandQueue = CommandQueue::create(&context, device, None).unwrap();
51
52        let vec_a = vec![1i64, 2, 3];
53        let vec_b = vec![0i64, -1, -2];
54
55        let len = vec_a.len();
56
57        let work: Work = Work::new(len);
58        let name = device.name().unwrap();
59        println!("{}", name);
60
61        let mem_a = Buffer::create_with_len::<i64>(&context, len).unwrap();
62        let mem_b = Buffer::create_with_len::<i64>(&context, len).unwrap();
63        let mem_c = Buffer::create_with_len::<i64>(&context, len).unwrap();
64    
65        println!("Creating kernel simple_add");
66        let simple_add = Kernel::create(&program2, "simple_add").unwrap();
67
68        println!("writing buffer a...");
69        let _write_event_a = command_queue.write_buffer(&mem_a, &vec_a, None).unwrap();
70
71        println!("writing buffer b...");
72        let _write_event_b = command_queue.write_buffer(&mem_b, &vec_b, None).unwrap();
73
74        println!("mem_a {:?}", mem_a);
75
76        let mut lock_a = mem_a.write_lock();
77        println!("setting simple_add arg 0 as mem_a");
78        unsafe { simple_add.set_arg(0, &mut *lock_a).unwrap() };
79
80        let mut lock_b = mem_b.write_lock();
81        println!("setting simple_add arg 1 as mem_b");
82        unsafe { simple_add.set_arg(1, &mut *lock_b).unwrap() };
83
84        let mut lock_c = mem_c.write_lock();
85        println!("setting simple_add mut arg 2 as mem_c");
86        unsafe { simple_add.set_arg(2, &mut *lock_c).unwrap() };
87
88        println!("calling enqueue_kernel on simple_add");
89        let () = command_queue
90            .enqueue_kernel(simple_add, &work, None)
91            .unwrap();
92
93        println!("Dropping locks...");
94        std::mem::drop(lock_a);
95        std::mem::drop(lock_b);
96        std::mem::drop(lock_c);
97
98        println!("done putting event into WaitList...");
99        let mut vec_c: Vec<i64> = vec![0; len];
100
101        let _read_event = command_queue.read_buffer(&mem_c, &mut vec_c, None).unwrap();
102
103        println!("  {}", string_from_slice(&vec_a[..]));
104        println!("+ {}", string_from_slice(&vec_b[..]));
105        println!("= {}", string_from_slice(&vec_c[..]));
106    }
107}

Source

pub fn create_copy(&self) -> Output<CommandQueue>

Creates a new copy of a CommandQueue with CommandQueue’s Context on the CommandQueue’s Device.

This function is useful for executing concurrent operations on a device within the same Context.

Source

pub fn low_level_context(&self) -> ClContext

The low-level context of the CommandQueue

Source

pub fn low_level_device(&self) -> ClDeviceID

Source

pub fn write_buffer<T: ClNumber>( &self, device_buffer: &Buffer, host_buffer: &[T], opts: Option<CommandQueueOptions>, ) -> Output<()>

write_buffer is used to move data from the host buffer (buffer: &[T]) to the OpenCL cl_mem pointer inside d_mem: &Buffer<T>.

Examples found in repository ?

examples/simple_add/main.rs (line 69)

14fn run_procedural() {
15    let src = include_str!("simple_add.ocl");
16
17    let mut platforms = Platform::list_all().unwrap();
18
19    if platforms.len() == 0 {
20        panic!("No platforms found!!!");
21    }
22
23    let platform = platforms.remove(0);
24    let devices = Device::list_all_devices(&platform).unwrap();
25
26    if devices.len() == 0 {
27        panic!("No devices found!!!");
28    }
29    let context = Context::create(&devices[..]).unwrap();
30
31    println!("creating program...");
32    let unbuilt_program: UnbuiltProgram =
33        UnbuiltProgram::create_with_source(&context, src).unwrap();
34
35    let names = devices.iter().map(|d| d.low_level_device().name().unwrap());
36    println!("building program on devices {:?}...", names);
37
38    let program: Program = unbuilt_program
39        .build(&devices[..])
40        .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
41
42    for device in devices[0..1].iter() {
43        let program2 = (&program).clone();
44        let r_count = program2.low_level_program().reference_count().unwrap();
45        let prog_log = program2.low_level_program().get_log(device).unwrap();
46        let prog_src = program2.low_level_program().source().unwrap();
47        println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
48        println!("Device {:?}", device);
49
50        let command_queue: CommandQueue = CommandQueue::create(&context, device, None).unwrap();
51
52        let vec_a = vec![1i64, 2, 3];
53        let vec_b = vec![0i64, -1, -2];
54
55        let len = vec_a.len();
56
57        let work: Work = Work::new(len);
58        let name = device.name().unwrap();
59        println!("{}", name);
60
61        let mem_a = Buffer::create_with_len::<i64>(&context, len).unwrap();
62        let mem_b = Buffer::create_with_len::<i64>(&context, len).unwrap();
63        let mem_c = Buffer::create_with_len::<i64>(&context, len).unwrap();
64    
65        println!("Creating kernel simple_add");
66        let simple_add = Kernel::create(&program2, "simple_add").unwrap();
67
68        println!("writing buffer a...");
69        let _write_event_a = command_queue.write_buffer(&mem_a, &vec_a, None).unwrap();
70
71        println!("writing buffer b...");
72        let _write_event_b = command_queue.write_buffer(&mem_b, &vec_b, None).unwrap();
73
74        println!("mem_a {:?}", mem_a);
75
76        let mut lock_a = mem_a.write_lock();
77        println!("setting simple_add arg 0 as mem_a");
78        unsafe { simple_add.set_arg(0, &mut *lock_a).unwrap() };
79
80        let mut lock_b = mem_b.write_lock();
81        println!("setting simple_add arg 1 as mem_b");
82        unsafe { simple_add.set_arg(1, &mut *lock_b).unwrap() };
83
84        let mut lock_c = mem_c.write_lock();
85        println!("setting simple_add mut arg 2 as mem_c");
86        unsafe { simple_add.set_arg(2, &mut *lock_c).unwrap() };
87
88        println!("calling enqueue_kernel on simple_add");
89        let () = command_queue
90            .enqueue_kernel(simple_add, &work, None)
91            .unwrap();
92
93        println!("Dropping locks...");
94        std::mem::drop(lock_a);
95        std::mem::drop(lock_b);
96        std::mem::drop(lock_c);
97
98        println!("done putting event into WaitList...");
99        let mut vec_c: Vec<i64> = vec![0; len];
100
101        let _read_event = command_queue.read_buffer(&mem_c, &mut vec_c, None).unwrap();
102
103        println!("  {}", string_from_slice(&vec_a[..]));
104        println!("+ {}", string_from_slice(&vec_b[..]));
105        println!("= {}", string_from_slice(&vec_c[..]));
106    }
107}

Source

pub fn read_buffer<T: ClNumber>( &self, device_buffer: &Buffer, host_buffer: &mut [T], opts: Option<CommandQueueOptions>, ) -> Output<Option<Vec<T>>>

read_buffer is used to move data from the device_mem (cl_mem pointer inside &DeviceMem<T>) into a host_buffer (&mut [T]).

Examples found in repository ?

examples/simple_add/main.rs (line 101)

14fn run_procedural() {
15    let src = include_str!("simple_add.ocl");
16
17    let mut platforms = Platform::list_all().unwrap();
18
19    if platforms.len() == 0 {
20        panic!("No platforms found!!!");
21    }
22
23    let platform = platforms.remove(0);
24    let devices = Device::list_all_devices(&platform).unwrap();
25
26    if devices.len() == 0 {
27        panic!("No devices found!!!");
28    }
29    let context = Context::create(&devices[..]).unwrap();
30
31    println!("creating program...");
32    let unbuilt_program: UnbuiltProgram =
33        UnbuiltProgram::create_with_source(&context, src).unwrap();
34
35    let names = devices.iter().map(|d| d.low_level_device().name().unwrap());
36    println!("building program on devices {:?}...", names);
37
38    let program: Program = unbuilt_program
39        .build(&devices[..])
40        .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
41
42    for device in devices[0..1].iter() {
43        let program2 = (&program).clone();
44        let r_count = program2.low_level_program().reference_count().unwrap();
45        let prog_log = program2.low_level_program().get_log(device).unwrap();
46        let prog_src = program2.low_level_program().source().unwrap();
47        println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
48        println!("Device {:?}", device);
49
50        let command_queue: CommandQueue = CommandQueue::create(&context, device, None).unwrap();
51
52        let vec_a = vec![1i64, 2, 3];
53        let vec_b = vec![0i64, -1, -2];
54
55        let len = vec_a.len();
56
57        let work: Work = Work::new(len);
58        let name = device.name().unwrap();
59        println!("{}", name);
60
61        let mem_a = Buffer::create_with_len::<i64>(&context, len).unwrap();
62        let mem_b = Buffer::create_with_len::<i64>(&context, len).unwrap();
63        let mem_c = Buffer::create_with_len::<i64>(&context, len).unwrap();
64    
65        println!("Creating kernel simple_add");
66        let simple_add = Kernel::create(&program2, "simple_add").unwrap();
67
68        println!("writing buffer a...");
69        let _write_event_a = command_queue.write_buffer(&mem_a, &vec_a, None).unwrap();
70
71        println!("writing buffer b...");
72        let _write_event_b = command_queue.write_buffer(&mem_b, &vec_b, None).unwrap();
73
74        println!("mem_a {:?}", mem_a);
75
76        let mut lock_a = mem_a.write_lock();
77        println!("setting simple_add arg 0 as mem_a");
78        unsafe { simple_add.set_arg(0, &mut *lock_a).unwrap() };
79
80        let mut lock_b = mem_b.write_lock();
81        println!("setting simple_add arg 1 as mem_b");
82        unsafe { simple_add.set_arg(1, &mut *lock_b).unwrap() };
83
84        let mut lock_c = mem_c.write_lock();
85        println!("setting simple_add mut arg 2 as mem_c");
86        unsafe { simple_add.set_arg(2, &mut *lock_c).unwrap() };
87
88        println!("calling enqueue_kernel on simple_add");
89        let () = command_queue
90            .enqueue_kernel(simple_add, &work, None)
91            .unwrap();
92
93        println!("Dropping locks...");
94        std::mem::drop(lock_a);
95        std::mem::drop(lock_b);
96        std::mem::drop(lock_c);
97
98        println!("done putting event into WaitList...");
99        let mut vec_c: Vec<i64> = vec![0; len];
100
101        let _read_event = command_queue.read_buffer(&mem_c, &mut vec_c, None).unwrap();
102
103        println!("  {}", string_from_slice(&vec_a[..]));
104        println!("+ {}", string_from_slice(&vec_b[..]));
105        println!("= {}", string_from_slice(&vec_c[..]));
106    }
107}

Source

pub fn enqueue_kernel( &self, kernel: Kernel, work: &Work, opts: Option<CommandQueueOptions>, ) -> Output<()>

Examples found in repository ?

examples/simple_add/main.rs (line 90)

14fn run_procedural() {
15    let src = include_str!("simple_add.ocl");
16
17    let mut platforms = Platform::list_all().unwrap();
18
19    if platforms.len() == 0 {
20        panic!("No platforms found!!!");
21    }
22
23    let platform = platforms.remove(0);
24    let devices = Device::list_all_devices(&platform).unwrap();
25
26    if devices.len() == 0 {
27        panic!("No devices found!!!");
28    }
29    let context = Context::create(&devices[..]).unwrap();
30
31    println!("creating program...");
32    let unbuilt_program: UnbuiltProgram =
33        UnbuiltProgram::create_with_source(&context, src).unwrap();
34
35    let names = devices.iter().map(|d| d.low_level_device().name().unwrap());
36    println!("building program on devices {:?}...", names);
37
38    let program: Program = unbuilt_program
39        .build(&devices[..])
40        .unwrap_or_else(|e| panic!("Failed to build program {:?}", e));
41
42    for device in devices[0..1].iter() {
43        let program2 = (&program).clone();
44        let r_count = program2.low_level_program().reference_count().unwrap();
45        let prog_log = program2.low_level_program().get_log(device).unwrap();
46        let prog_src = program2.low_level_program().source().unwrap();
47        println!("Program log {:?} {:?}, {:?}", r_count, prog_log, prog_src);
48        println!("Device {:?}", device);
49
50        let command_queue: CommandQueue = CommandQueue::create(&context, device, None).unwrap();
51
52        let vec_a = vec![1i64, 2, 3];
53        let vec_b = vec![0i64, -1, -2];
54
55        let len = vec_a.len();
56
57        let work: Work = Work::new(len);
58        let name = device.name().unwrap();
59        println!("{}", name);
60
61        let mem_a = Buffer::create_with_len::<i64>(&context, len).unwrap();
62        let mem_b = Buffer::create_with_len::<i64>(&context, len).unwrap();
63        let mem_c = Buffer::create_with_len::<i64>(&context, len).unwrap();
64    
65        println!("Creating kernel simple_add");
66        let simple_add = Kernel::create(&program2, "simple_add").unwrap();
67
68        println!("writing buffer a...");
69        let _write_event_a = command_queue.write_buffer(&mem_a, &vec_a, None).unwrap();
70
71        println!("writing buffer b...");
72        let _write_event_b = command_queue.write_buffer(&mem_b, &vec_b, None).unwrap();
73
74        println!("mem_a {:?}", mem_a);
75
76        let mut lock_a = mem_a.write_lock();
77        println!("setting simple_add arg 0 as mem_a");
78        unsafe { simple_add.set_arg(0, &mut *lock_a).unwrap() };
79
80        let mut lock_b = mem_b.write_lock();
81        println!("setting simple_add arg 1 as mem_b");
82        unsafe { simple_add.set_arg(1, &mut *lock_b).unwrap() };
83
84        let mut lock_c = mem_c.write_lock();
85        println!("setting simple_add mut arg 2 as mem_c");
86        unsafe { simple_add.set_arg(2, &mut *lock_c).unwrap() };
87
88        println!("calling enqueue_kernel on simple_add");
89        let () = command_queue
90            .enqueue_kernel(simple_add, &work, None)
91            .unwrap();
92
93        println!("Dropping locks...");
94        std::mem::drop(lock_a);
95        std::mem::drop(lock_b);
96        std::mem::drop(lock_c);
97
98        println!("done putting event into WaitList...");
99        let mut vec_c: Vec<i64> = vec![0; len];
100
101        let _read_event = command_queue.read_buffer(&mem_c, &mut vec_c, None).unwrap();
102
103        println!("  {}", string_from_slice(&vec_a[..]));
104        println!("+ {}", string_from_slice(&vec_b[..]));
105        println!("= {}", string_from_slice(&vec_c[..]));
106    }
107}