rocmrc 0.4.0

Minimal safe ROCm bindings (HIP, hipRTC), modeled after cudarc
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

use super::{result, result::RocblasError, sys};
use crate::hip::{DevicePtr, DevicePtrMut};
use crate::rocblas::RocBlas;

#[derive(Debug, Copy, Clone)]
pub struct CopyConfig {
    pub n: sys::rocblas_int,
    pub incx: sys::rocblas_int,
    pub incy: sys::rocblas_int,
}

pub trait Copy<T> {
    /// `y := x`.
    fn copy<X: DevicePtr<T>, Y: DevicePtrMut<T>>(
        &self,
        cfg: CopyConfig,
        x: &X,
        y: &mut Y,
    ) -> Result<(), RocblasError>;
}

impl Copy<f32> for RocBlas {
    fn copy<X: DevicePtr<f32>, Y: DevicePtrMut<f32>>(
        &self,
        cfg: CopyConfig,
        x: &X,
        y: &mut Y,
    ) -> Result<(), RocblasError> {
        let (x, _record_x) = x.device_ptr(&self.stream);
        let (y, _record_y) = y.device_ptr_mut(&self.stream);
        unsafe {
            result::scopy(
                self.handle,
                cfg.n,
                x as *const _,
                cfg.incx,
                y as *mut _,
                cfg.incy,
            )
        }
    }
}

impl Copy<f64> for RocBlas {
    fn copy<X: DevicePtr<f64>, Y: DevicePtrMut<f64>>(
        &self,
        cfg: CopyConfig,
        x: &X,
        y: &mut Y,
    ) -> Result<(), RocblasError> {
        let (x, _record_x) = x.device_ptr(&self.stream);
        let (y, _record_y) = y.device_ptr_mut(&self.stream);
        unsafe {
            result::dcopy(
                self.handle,
                cfg.n,
                x as *const _,
                cfg.incx,
                y as *mut _,
                cfg.incy,
            )
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::hip::HipContext;

    #[test]
    fn test_scopy() {
        let ctx = HipContext::new(0).unwrap();
        let stream = ctx.default_stream();
        let blas = RocBlas::new(stream.clone()).unwrap();

        let x: [f32; 5] = [-0.5944882, 1.8055636, 0.52204555, -0.00397902, 0.39125723];
        let x_dev = stream.clone_htod(&x).unwrap();
        let mut y_dev = stream.alloc_zeros::<f32>(5).unwrap();
        blas.copy(
            CopyConfig {
                n: 5,
                incx: 1,
                incy: 1,
            },
            &x_dev,
            &mut y_dev,
        )
        .unwrap();

        let found = stream.clone_dtoh(&y_dev).unwrap();
        assert_eq!(found, x.to_vec());
    }

    #[test]
    fn test_dcopy() {
        let ctx = HipContext::new(0).unwrap();
        let stream = ctx.default_stream();
        let blas = RocBlas::new(stream.clone()).unwrap();

        let x: [f64; 5] = [-0.5944882, 1.8055636, 0.52204555, -0.00397902, 0.39125723];
        let x_dev = stream.clone_htod(&x).unwrap();
        let mut y_dev = stream.alloc_zeros::<f64>(5).unwrap();
        blas.copy(
            CopyConfig {
                n: 5,
                incx: 1,
                incy: 1,
            },
            &x_dev,
            &mut y_dev,
        )
        .unwrap();

        let found = stream.clone_dtoh(&y_dev).unwrap();
        assert_eq!(found, x.to_vec());
    }
}