obrah 3.4.0

High-level Rust wrapper around OpenCL using OBWIO
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::data::Buffer;
use crate::runtime::{ClError, Env};
use obwio::*;
use std::ffi::c_void;

/// setarg() sets an argument. For scalar values, use setarg_scalar().
/// The third parameter, arg, is the 0-based index of the kernel argument.
///
/// # Examples
///
/// ```rust
/// use obrah::kernel;
/// use obrah::runtime;
/// use obrah::data;
/// use obrah::runtime::Env;
///
/// fn main() -> Result<(), Box<dyn std::error::Error>> {
///
///     let mut env = Env::new(0, 0)?;
///     env.use_kernel("examples/vecadd_kernel.cl")?.program()?.make_kernel("vec_add")?;
///
///     let mut a = vec![7.0f32, 8.0, 2.0, 6.0];
///     let mut b = vec![134.0f32, 134.11, 34.8, 112.9];
///     let mut result = vec![0.0f32; a.len()];
///
///     // Buffers
///     let mut buf_a = data::Buffer::new(&mut env, &mut a);
///     let mut buf_b = data::Buffer::new(&mut env, &mut b);
///     let mut buf_result = data::Buffer::new(&mut env, &mut result);
///
///      // Send data to GPU
///     buf_a.to(&mut env);
///     buf_b.to(&mut env);
///
///     // Set kernel arguments
///     kernel::setarg(&env, &mut buf_a, 0);
///     kernel::setarg(&env, &mut buf_b, 1);
///     kernel::setarg(&env, &mut buf_result, 2);
/// Ok(())
/// }
/// ```
///
pub fn setarg<T>(env: &Env, buffer: &Buffer<T>, arg: usize) -> Result<(), ClError>
where
    T: Clone + 'static,
{
    unsafe {
        let size = std::mem::size_of::<cl_mem>();
        let buf_ptr: *const std::ffi::c_void = &buffer.buffer as *const _ as *const _;
        clSetKernelArg(env.kernel, arg as u32, size, buf_ptr as *const _);
        if env.err != 0 {
            return Err(ClError::from(env.err));
        }
        Ok(())
    }
}

pub fn get_devices() {
    unsafe {
        let mut num_platforms = 0;
        clGetPlatformIDs(0, std::ptr::null_mut(), &mut num_platforms);
        let mut platforms = vec![std::ptr::null_mut(); num_platforms as usize];
        clGetPlatformIDs(num_platforms, platforms.as_mut_ptr(), std::ptr::null_mut());

        for (p_idx, &platform) in platforms.iter().enumerate() {
            println!("Platform {}:", p_idx);

            let mut num_devices = 0;
            clGetDeviceIDs(
                platform,
                CL_DEVICE_TYPE_ALL.into(),
                0,
                std::ptr::null_mut(),
                &mut num_devices,
            );
            let mut devices = vec![std::ptr::null_mut(); num_devices as usize];
            clGetDeviceIDs(
                platform,
                CL_DEVICE_TYPE_ALL.into(),
                num_devices,
                devices.as_mut_ptr(),
                std::ptr::null_mut(),
            );

            for (d_idx, &device) in devices.iter().enumerate() {
                let mut size = 0;
                clGetDeviceInfo(device, CL_DEVICE_NAME, 0, std::ptr::null_mut(), &mut size);
                let mut name_buf = vec![0u8; size];
                clGetDeviceInfo(
                    device,
                    CL_DEVICE_NAME,
                    size,
                    name_buf.as_mut_ptr() as *mut _,
                    std::ptr::null_mut(),
                );

                let name = std::ffi::CStr::from_bytes_with_nul(&name_buf).unwrap();
                println!("  Device {}: {}", d_idx, name.to_str().unwrap());
            }
        }
    }
}

/// Set a scalar argument.
/// Scalar arguments are single-data types, such as
/// floats and integers.
/// They cannot be read from.
pub fn setarg_scalar<T>(env: &Env, val: &T, arg: usize)
where
    T: Clone + 'static,
{
    unsafe {
        let size = std::mem::size_of::<T>();
        clSetKernelArg(
            env.kernel,
            arg as u32,
            size,
            val as *const T as *const c_void,
        );
        if env.err != 0 {
            panic!("OpenCL error: {}", env.err);
        }
    }
}

/// Run the kernel! Simply input the number of threads in the x, and threads in the y.
pub fn run_kernel(env: &mut Env, threadsx: usize, threadsy: usize) {
    unsafe {
        let global_work_size: [usize; 2] = [threadsx, threadsy];
        clEnqueueNDRangeKernel(
            env.queue,
            env.kernel,
            2,
            std::ptr::null(),
            global_work_size.as_ptr(),
            std::ptr::null(),
            0,
            std::ptr::null_mut(),
            std::ptr::null_mut(),
        );
        clFinish(env.queue);
    }
}