graphblas_sparse_linear_algebra 0.62.0

Wrapper for SuiteSparse:GraphBLAS
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

use std::ffi::c_void;
use std::ptr;
use std::{mem::MaybeUninit, sync::Arc};

use suitesparse_graphblas_sys::{GrB_Index, GrB_Matrix, GrB_Matrix_deserialize};

use crate::collections::sparse_matrix::SparseMatrix;
use crate::index::IndexConversion;
use crate::value_type::ValueType;
use crate::{context::Context, error::SparseLinearAlgebraError};

pub trait DeserializeSparseMatrix<T: ValueType> {
    unsafe fn deserialize_suitesparse_graphblas_sparse_matrix(
        context: Arc<Context>,
        serialized_suitesparse_graphblas_sparse_matrix: &[u8],
    ) -> Result<SparseMatrix<T>, SparseLinearAlgebraError>;
}

impl<T: ValueType> DeserializeSparseMatrix<T> for SparseMatrix<T> {
    unsafe fn deserialize_suitesparse_graphblas_sparse_matrix(
        context: Arc<Context>,
        serialized_suitesparse_graphblas_sparse_matrix: &[u8],
    ) -> Result<SparseMatrix<T>, SparseLinearAlgebraError> {
        let graphblas_sparse_matrix = unsafe {
            deserialize_suitesparse_graphblas_sparse_matrix(
                &context,
                serialized_suitesparse_graphblas_sparse_matrix,
            )
        }?;
        SparseMatrix::from_graphblas_matrix(context.to_owned(), graphblas_sparse_matrix)
    }
}

pub unsafe fn deserialize_suitesparse_graphblas_sparse_matrix(
    context: &Arc<Context>,
    serialized_suitesparse_graphblas_sparse_matrix: &[u8],
) -> Result<GrB_Matrix, SparseLinearAlgebraError> {
    let mut suitesparse_graphblas_sparse_matrix: MaybeUninit<GrB_Matrix> = MaybeUninit::uninit();
    let raw_pointer_to_serialized_suitesparse_graphblas_sparse_matrix: *const c_void =
        serialized_suitesparse_graphblas_sparse_matrix.as_ptr() as *const c_void;
    let size_of_serialized_suitesparse_graphblas_sparse_matrix: GrB_Index =
        serialized_suitesparse_graphblas_sparse_matrix
            .len()
            .to_graphblas_index()?;

    context.call_without_detailed_error_information(|| unsafe {
        GrB_Matrix_deserialize(
            suitesparse_graphblas_sparse_matrix.as_mut_ptr(),
            ptr::null_mut(),
            raw_pointer_to_serialized_suitesparse_graphblas_sparse_matrix,
            size_of_serialized_suitesparse_graphblas_sparse_matrix,
        )
    })?;
    // TODO: research if using GxB_Matrix_deserialize would enable retrieving detailed error information

    let suitesparse_graphblas_sparse_matrix =
        unsafe { suitesparse_graphblas_sparse_matrix.assume_init() };

    Ok(suitesparse_graphblas_sparse_matrix)
}

#[cfg(test)]
mod tests {
    use crate::collections::sparse_matrix::operations::{
        FromMatrixElementList, GetSparseMatrixElementList,
        SerializeSuitesparseGraphblasSparseMatrix,
    };
    use crate::collections::sparse_matrix::{
        GetGraphblasSparseMatrix, MatrixElementList, SparseMatrix,
    };
    use crate::collections::LZ4HighCompressionSerializer;
    use crate::operators::binary_operator::First;

    use super::*;

    #[test]
    fn serialize_and_deserialize_suitesparse_graphblas_sparse_matrix() {
        let context = Context::init_default().unwrap();

        let element_list = MatrixElementList::<u8>::from_element_vector(vec![
            (1, 1, 1).into(),
            (2, 2, 2).into(),
            (2, 4, 10).into(),
            (2, 5, 11).into(),
        ]);

        let matrix = SparseMatrix::<u8>::from_element_list(
            context.clone(),
            (10, 15).into(),
            element_list.clone(),
            &First::<u8>::new(),
        )
        .unwrap();

        let zstd_serializer = LZ4HighCompressionSerializer::new(
            context.clone(),
            crate::collections::LZ4HighCompressionLevel::DEFAULT,
        )
        .unwrap();

        let serialized_matrix = unsafe {
            zstd_serializer
                .serialize_suitesparse_grapblas_sparse_matrix(matrix.graphblas_matrix_ptr())
                .unwrap()
        };

        let deserialized_sparse_matrix = unsafe {
            SparseMatrix::<u8>::deserialize_suitesparse_graphblas_sparse_matrix(
                context,
                &serialized_matrix,
            )
        }
        .unwrap();

        assert_eq!(
            matrix.element_list().unwrap(),
            deserialized_sparse_matrix.element_list().unwrap()
        )
    }
}