cumath 0.2.7

Cuda-based matrix/vector computations
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
144
145
146
147
148
149
150


use std::{ptr, mem::size_of, ops::{Deref, DerefMut}};
use super::*;



/// A GPU-allocated matrix
/// Holds a pointer to continuous GPU memory.
#[derive(Debug)]
pub struct CuMatrix<T: CuDataType> {
    deref: CuMatrixDeref<T>
}

impl<T: CuDataType> Drop for CuMatrix<T> {
    fn drop(&mut self) { cuda_free(self.deref.ptr as *mut c_void) }
}

impl<T: CuDataType> Deref for CuMatrix<T> {
    type Target = CuMatrixDeref<T>;
    fn deref(&self) -> &CuMatrixDeref<T> { &self.deref }
}
impl<T: CuDataType> DerefMut for CuMatrix<T> {
    fn deref_mut(&mut self) -> &mut CuMatrixDeref<T> { &mut self.deref }
}

macro_rules! impl_CuMatrix {
    ($inner_type:ident, $fn_init:ident) => {
        impl CuMatrix<$inner_type> {
            /// Returns a new zero GPU-allocated matrix from a dimension.
            pub fn zero(rows: usize, cols: usize) -> CuMatrix<$inner_type> {
                let len = rows * cols;
                let mut ptr = ptr::null_mut();
                cuda_malloc(&mut ptr, len * size_of::<$inner_type>());
                unsafe { $fn_init(ptr as *mut $inner_type, $inner_type::zero(), len as i32, DEFAULT_STREAM.stream) }
                CuMatrix { deref: CuMatrixDeref { rows, cols, len, ptr: ptr as *mut $inner_type, leading_dimension: rows } }
            }
            /// Returns a new GPU-allocated matrix from a dimension and an initial value.
            pub fn new(value: $inner_type, rows: usize, cols: usize) -> CuMatrix<$inner_type> {
                let len = rows * cols;
                let mut ptr = ptr::null_mut();
                cuda_malloc(&mut ptr, len * size_of::<$inner_type>());
                unsafe { $fn_init(ptr as *mut $inner_type, value, len as i32, DEFAULT_STREAM.stream) }
                CuMatrix { deref: CuMatrixDeref { rows, cols, len, ptr: ptr as *mut $inner_type, leading_dimension: rows } }
            }
        }
    };
}

impl_CuMatrix!(i32, VectorPacked_init_i32);
impl_CuMatrix!(f32, VectorPacked_init_f32);

impl<T: CuDataType> CuMatrix<T> {

    /// Returns a new GPU-allocated matrix from CPU data.
    pub fn from_host_data(rows: usize, cols: usize, data: &[T]) -> CuMatrix<T> {
        let len = rows*cols;
        let mut ptr = ptr::null_mut();
        cuda_malloc(&mut ptr, data.len() * size_of::<T>());
        cuda_memcpy(ptr, data.as_ptr() as *const c_void, data.len() * size_of::<T>(), cudaMemcpyKind::HostToDevice);
        CuMatrix {
            deref: CuMatrixDeref {
                ptr: ptr as *mut T,
                len,
                rows,
                cols,
                leading_dimension: rows,
            }
        }
    }
    /// Returns a new GPU-allocated matrix from CPU data.
    pub fn from_device_data(data: &CuMatrixDeref<T>) -> CuMatrix<T> {
        let mut ptr = ptr::null_mut();
        cuda_malloc(&mut ptr, data.len() * size_of::<T>());
        let mut output = CuMatrix {
            deref: CuMatrixDeref {
                ptr: ptr as *mut T,
                len: data.len,
                rows: data.rows,
                cols: data.cols,
                leading_dimension: data.rows,
            }
        };
        output.clone_from_device(data);
        output
    }

    /// Consume this Matrix to return a new CuVector holding its data
    pub fn into_vector(mut self) -> ::CuVector<T> {
        let vector = unsafe { ::CuVector::from_raw_ptr(self.ptr, self.len) };
        self.ptr = ptr::null_mut(); // So it won't be freed
        vector
    }

    /// Returns a vector slice containing this matrix datas
    pub fn as_vector(&self) -> ::CuVectorSlice<T> {
        ::CuVectorSlice {
            _parent: PhantomData,
            deref: ::CuVectorDeref {
                ptr: self.ptr,
                len: self.len,
            }
        }
    }

    /// Returns a mutable vector slice containing this matrix datas
    pub fn as_mut_vector(&mut self) -> ::CuVectorSliceMut<T> {
        ::CuVectorSliceMut {
            _parent: PhantomData,
            deref: ::CuVectorDeref {
                ptr: self.as_mut_ptr(),
                len: self.len(),
            }
        }
    }

    /// Returns a new slice
    pub fn slice_col<'a>(&'a self, col_offset: usize, nb_cols: usize) -> CuMatrixSlice<'a, T> {
        #[cfg(not(feature = "disable_checks"))] {
            assert_infeq_usize(col_offset + nb_cols, "col_offset+nb_cols", self.cols(), "self.cols()");
        }
        CuMatrixSlice {
            _parent: PhantomData,
            deref: CuMatrixDeref {
                ptr: unsafe { self.ptr.offset((col_offset*self.rows) as isize) },
                len: self.rows * nb_cols,
                rows: self.rows,
                cols: nb_cols,
                leading_dimension: self.leading_dimension,
            }
        }
    }

    /// Returns a new mutable slice
    pub fn slice_col_mut<'a>(&'a mut self, col_offset: usize, nb_cols: usize) -> CuMatrixSliceMut<'a, T> {
        #[cfg(not(feature = "disable_checks"))] {
            assert_infeq_usize(col_offset + nb_cols, "col_offset+nb_cols", self.cols(), "self.cols()");
        }
        CuMatrixSliceMut {
            _parent: PhantomData,
            deref: CuMatrixDeref {
                rows: self.leading_dimension(),
                cols: nb_cols,
                len: self.rows * nb_cols,
                ptr: unsafe { self.ptr.offset((col_offset*self.rows) as isize) },
                leading_dimension: self.rows,
            }
        }
    }

}