custos 0.7.0

A minimal OpenCL, WGPU, CUDA and host CPU array manipulation engine.
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

use crate::{number::Number, Buffer, CUDA};
use std::ffi::c_void;

use super::{
    api::{cuOccupancyMaxPotentialBlockSize, culaunch_kernel},
    fn_cache,
};

/// Converts `Self` to a (cuda) *mut c_void.
/// This enables taking `Buffer` and a number `T` as an argument to an CUDA kernel.
/// # Example
/// ```
/// use custos::{CUDA, Buffer, cuda::AsCudaCvoidPtr};
///
/// fn args(args: &[&dyn AsCudaCvoidPtr]) {
///     // ...
/// }
///
/// fn main() -> custos::Result<()> {
///     let device = CUDA::new(0)?;
///
///     let buf = Buffer::<f32, _>::new(&device, 10);
///     let num = 4;
///     args(&[&num, &buf]);
///     Ok(())
/// }
/// ```
pub trait AsCudaCvoidPtr {
    /// Converts `Self` to a (cuda) *mut c_void.
    /// # Example
    /// ```
    /// use custos::{CUDA, Buffer, cuda::AsCudaCvoidPtr};
    ///
    /// fn main() -> custos::Result<()> {
    ///     let device = CUDA::new(0)?;
    ///     let buf = Buffer::<f32, _>::new(&device, 10);
    ///     
    ///     let _ptr = buf.as_cvoid_ptr();
    ///     Ok(())
    /// }
    ///
    fn as_cvoid_ptr(&self) -> *mut c_void;
}

impl<'a, T> AsCudaCvoidPtr for &Buffer<'a, T, CUDA> {
    fn as_cvoid_ptr(&self) -> *mut c_void {
        &self.ptr.ptr as *const u64 as *mut c_void
    }
}

impl<'a, T> AsCudaCvoidPtr for Buffer<'a, T, CUDA> {
    fn as_cvoid_ptr(&self) -> *mut c_void {
        &self.ptr.ptr as *const u64 as *mut c_void
    }
}

impl<T: Number> AsCudaCvoidPtr for T {
    fn as_cvoid_ptr(&self) -> *mut c_void {
        self as *const T as *mut c_void
    }
}

/// uses calculated occupancy as launch configuration to launch a CUDA kernel
/// # Safety
/// All kernel arguments must be set.
pub fn launch_kernel1d(
    len: usize,
    device: &CUDA,
    src: &str,
    fn_name: &str,
    params: &[&dyn AsCudaCvoidPtr],
) -> crate::Result<()> {
    let params = params
        .iter()
        .map(|param| param.as_cvoid_ptr())
        .collect::<Vec<_>>();

    let func = fn_cache(device, src, fn_name)?;

    let mut min_grid_size = 0;
    let mut block_size = 0;

    unsafe {
        cuOccupancyMaxPotentialBlockSize(
            &mut min_grid_size,
            &mut block_size,
            func.0,
            0,
            0,
            len as i32,
        )
        .to_result()?
    };
    let grid_size = (len as i32 + block_size - 1) / block_size;

    culaunch_kernel(
        &func,
        [grid_size as u32, 1, 1],
        [block_size as u32, 1, 1],
        device.stream(),
        &params,
    )?;
    Ok(())
}