fix serialization and a few other issues on current release

Author: rayegun

src/abstracts.jl

@@ -12,3 +12,9 @@ const AbstractGBVector{T, F, O} = AbstractGBArray{T, F, O, 1}
 
 # P = pointer vectors, B = bitmap storage, A = value storage
 abstract type AbstractGBShallowArray{T, F, O, P, B, A, N} <: AbstractGBArray{T, F, O, N} end
+
+const GBVecOrMat{T, F, O} = Union{AbstractGBVector{T, F, O}, AbstractGBMatrix{T, F, O}}
+const GBMatrixOrTranspose{T, F, O} = Union{AbstractGBMatrix{T, F, O}, Transpose{<:Any, <:AbstractGBMatrix{T, F, O}}}
+const GBVectorOrTranspose{T, F, O} = Union{AbstractGBVector{T, F, O}, Transpose{<:Any, <:AbstractGBVector{T, F, O}}}
+const GBArrayOrTranspose{T, F, O} = Union{AbstractGBArray{T, F, O}, Transpose{<:Any, <:AbstractGBArray{T, F, O}}}
+const VecMatOrTrans = Union{DenseVecOrMat, Transpose{<:Any, <:DenseVecOrMat}}

src/constants.jl

@@ -1,8 +1,3 @@
-const GBVecOrMat{T, F, O} = Union{AbstractGBVector{T, F, O}, AbstractGBMatrix{T, F, O}}
-const GBMatrixOrTranspose{T, F, O} = Union{AbstractGBMatrix{T, F, O}, Transpose{<:Any, <:AbstractGBMatrix{T, F, O}}}
-const GBVectorOrTranspose{T, F, O} = Union{AbstractGBVector{T, F, O}, Transpose{<:Any, <:AbstractGBVector{T, F, O}}}
-const GBArrayOrTranspose{T, F, O} = Union{AbstractGBArray{T, F, O}, Transpose{<:Any, <:AbstractGBArray{T, F, O}}}
-const VecMatOrTrans = Union{DenseVecOrMat, Transpose{<:Any, <:DenseVecOrMat}}
 const ptrtogbtype = IdDict{Ptr, GBType}()
 
 const GrBOp = Union{
@@ -32,4 +27,4 @@ const OperatorUnion = Union{
     GrBOp
 }
 
-const ALL = GBAllType(C_NULL)
+const ALL = GBAllType(C_NULL)

src/gbtypes.jl

@@ -46,8 +46,7 @@ mutable struct GBType{T} <: AbstractGBType
 end
 
 
-
-const GBTYPES = IdDict{DataType, GBType}()
+const JLTOGBTYPES = IdDict{DataType, GBType}()
 
 """
     gbtype(x)
@@ -57,7 +56,7 @@ Determine the GBType equivalent of a Julia primitive type.
 See also: [`juliatype`](@ref)
 """
 function gbtype(::Type{T}; builtin = false, loaded = false, typestr = string(T)) where T
-    (get!(GBTYPES, T) do 
+    (get!(JLTOGBTYPES, T) do
         return GBType{T}(builtin, loaded, LibGraphBLAS.GrB_Type(), typestr)
     end)::GBType{T}
 end
@@ -111,7 +110,7 @@ Base.unsafe_convert(::Type{Ptr{LibGraphBLAS.GrB_Index}}, s::GBAllType) = s.p
 Base.length(::GBAllType) = 0 #Allow indexing with ALL
 
 """
-    tojuliatype(x::GBType)
+    juliatype(x::GBType)
 
 Determine the Julia equivalent of a GBType.
 
@@ -132,4 +131,3 @@ juliatype(::GBType{T}) where {T} = T
 @_gbtype Float64 GrB_FP64
 @_gbtype ComplexF32 GxB_FC32
 @_gbtype ComplexF64 GxB_FC64
-

src/operations/operationutils.jl

@@ -26,7 +26,7 @@ inferbinarytype(::Type{X}, ::Type{Y}, op::TypedBinaryOperator{F, X2, Y2, Z}) whe
 """
     Complement{T}
 
-The complement of a GraphBLAS mask. 
+The complement of a GraphBLAS mask.
 This wrapper will set the mask argument of a GraphBLAS operation to be the negation of the
 original mask.
 
@@ -47,14 +47,14 @@ struct Structural{T}
 end
 
 Complement(A::T) where {
-    T<:Union{GBArrayOrTranspose, 
-    Structural{<:GBArrayOrTranspose}, 
+    T<:Union{GBArrayOrTranspose,
+    Structural{<:GBArrayOrTranspose},
     Complement{<:GBArrayOrTranspose}}
 } = Complement{T}(A)
 
 Base.:~(A::T) where {
-    T<:Union{GBArrayOrTranspose, 
-    Structural{<:GBArrayOrTranspose}, 
+    T<:Union{GBArrayOrTranspose,
+    Structural{<:GBArrayOrTranspose},
     Complement}
 } = Complement(A)
 Base.parent(C::Complement) = C.parent
@@ -116,9 +116,20 @@ _promotefill(x, ::AbstractGBArray{<:Any, Missing}, op) = missing
 _promotefill(::AbstractGBArray{<:Any, Missing}, ::AbstractGBArray{<:Any, <:Any}, op) = missing
 _promotefill(::AbstractGBArray{<:Any, <:Any}, ::AbstractGBArray{<:Any, Missing}, op) = missing
 
+_promotefill(::AbstractGBArray{<:Any, Nothing}, ::AbstractGBArray{<:Any, Nothing}, op) = nothing
+_promotefill(::AbstractGBArray{<:Any, Nothing}, y, op) = nothing
+_promotefill(x, ::AbstractGBArray{<:Any, Nothing}, op) = nothing
+_promotefill(::AbstractGBArray{<:Any, Nothing}, ::AbstractGBArray{<:Any, <:Any}, op) = nothing
+_promotefill(::AbstractGBArray{<:Any, <:Any}, ::AbstractGBArray{<:Any, Nothing}, op) = nothing
+
 _promotefill(x, op) = x
 
 function _promotefill(x::AbstractGBArray{<:Any, T}, y::AbstractGBArray{<:Any, U}, op) where {T, U}
-    getfill(x) ≈ getfill(y) && (return inferbinarytype(T, U, op)(getfill(x)))
-    return defaultfill(inferbinarytype(T, U, op)) # fallback to defaultfill.
-end
+    V = inferbinarytype(T, U, op)
+    xfill, yfill = getfill(x), getfill(y)
+    if (V === T === U) && xfill == yfill
+        return xfill
+    else # TODO: in 1.0 handle fills correctly no matter what.
+        return defaultfill(inferbinarytype(T, U, op)) # fallback to defaultfill.
+    end
+end

src/serialization.jl

@@ -2,31 +2,86 @@ function Serialization.serialize(s::AbstractSerializer, A::GBVecOrMat)
     Serialization.writetag(s.io, Serialization.OBJECT_TAG)
     Serialization.serialize(s, typeof(A))
     Serialization.serialize(s, A.fill)
-    v = Vector{UInt8}(undef, serialize_sizehint(A))
-    sz = Ref{LibGraphBLAS.GrB_Index}()
+    hint = serialize_sizehint(A)
+    v = Vector{UInt8}(undef, hint)
+    sz = Ref{LibGraphBLAS.GrB_Index}(hint)
     @wraperror LibGraphBLAS.GrB_Matrix_serialize(v, sz, A)
     resize!(v, sz[])
     serialize(s, v)
     return nothing
 end
 
-function _gbdeserialize(s::AbstractSerializer, ::Type{T}) where {T} # Only for internal use, we assume we've already got a GB<Something> here.
-    fill = deserialize(s)
+function _gbdeserialize_matrix(v, ::Type{T}) where {T} # Only for internal use, we assume we've already got a GB<Something> here.
     refA = Ref{LibGraphBLAS.GrB_Matrix}() # Everything is a GrB_Matrix in the end.
-    v = deserialize(s)
-    @wraperror LibGraphBLAS.GrB_Matrix_deserialize(refA, gbtype(T), v, LibGraphBLAS.GrB_Index(length(v)))
-    return refA[], fill
+    @wraperror LibGraphBLAS.GrB_Matrix_deserialize(refA, T === Nothing ? C_NULL : gbtype(T), v, LibGraphBLAS.GrB_Index(length(v)))
+    return refA
+end
+
+function _gbdeserialize_fill(s::AbstractSerializer) # Only for internal use, we assume we've already got a GB<Something> here.
+    return deserialize(s)
 end
 
 function Serialization.deserialize(s::AbstractSerializer, ::Type{GBMatrix{T, Tf}}) where {T, Tf}
-    return GBMatrix{T, Tf}(_gbdeserialize(s, T)...)
+    fill = _gbdeserialize_fill(s)
+    v = deserialize(s)
+    return GBMatrix{T, Tf}(_gbdeserialize_matrix(v, T), fill)
 end
 function Serialization.deserialize(s::AbstractSerializer, ::Type{GBVector{T, Tf}}) where {T, Tf}
-    return GBVector{T, Tf}(_gbdeserialize(s, T)...)
+    fill = _gbdeserialize_fill(s)
+    v = deserialize(s)
+    return GBVector{T, Tf}(_gbdeserialize_matrix(v, T), fill)
 end
 
 function serialize_sizehint(A::GBVecOrMat)
     sz = Ref{LibGraphBLAS.GrB_Index}()
     @wraperror LibGraphBLAS.GrB_Matrix_serializeSize(sz, A)
     return sz[]
 end
+
+gbwrite(filename::AbstractString, A::GBVecOrMat) = open(io->gbwrite(io, A), filename, "w")
+
+function gbwrite(io::IO, A::GBVecOrMat)
+    hint = serialize_sizehint(A)
+    v = Vector{UInt8}(undef, hint)
+    sz = Ref{LibGraphBLAS.GrB_Index}(hint)
+    @wraperror LibGraphBLAS.GrB_Matrix_serialize(v, sz, A)
+    resize!(v, sz[])
+    write(io, v)
+end
+
+gbread(filename::AbstractString, ::Type{T}; fill = defaultfill(Tf)) where {Te, Tf, T<:GBVecOrMat{Te, Tf}} =
+    open(io->gbread(io, T; fill), filename, "r")
+
+# TODO: I don't love how this works with fill. Rewrite for 1.0 with SparseBase
+function gbread(io::IO, ::Type{GBMatrix{T, Tf}}; fill = defaultfill(Tf)) where {T, Tf}
+    v = read(io)
+    gb = _gbdeserialize_matrix(v, T)
+    GBMatrix{T, Tf}(gb, fill)
+end
+function gbread(io::IO, ::Type{GBVector{T, Tf}}; fill = defaultfill(Tf)) where {T, Tf}
+    v = read(io)
+    gb = _gbdeserialize_matrix(v, T)
+    GBVector{T, Tf}(gb, fill)
+end
+
+gbread_matrix(filename::AbstractString; fill = Nothing) =
+    open(io->gbread_matrix(io; fill), filename, "r")
+
+function gbread_matrix(io::IO; fill = Nothing)
+    v = read(io)
+    gb = _gbdeserialize_matrix(v, Nothing) # we don't know the eltype pass nothing
+    type = Ref{LibGraphBLAS.GrB_Type}()
+    LibGraphBLAS.GxB_Matrix_type(type, gb[])
+    T = juliatype(ptrtogbtype[type[]])
+    fill = fill === Nothing ? defaultfill(T) : fill
+    return GBMatrix{T}(gb; fill)
+end
+function gbread_vector(io::IO; fill = Nothing)
+    v = read(io)
+    gb = _gbdeserialize_matrix(v, Nothing) # we don't know the eltype pass nothing
+    type = Ref{LibGraphBLAS.GrB_Type}()
+    LibGraphBLAS.GxB_Matrix_type(type, gb)
+    T = juliatype(ptrtogbtype[type[]])
+    fill = fill === Nothing ? defaultfill(T) : fill
+    return GBVector{T}(gb; fill)
+end

src/solvers/cholmod.jl

@@ -4,7 +4,7 @@ using LinearAlgebra
 import LinearAlgebra: (\),
                  cholesky, cholesky!, det, diag, ishermitian, isposdef,
                  issuccess, issymmetric, ldlt, ldlt!, logdet, Symmetric, Hermitian, lu
-using ..SuiteSparseGraphBLAS: AbstractGBMatrix, AbstractGBVector, unsafepack!, unsafeunpack!, GBMatrix, 
+using ..SuiteSparseGraphBLAS: AbstractGBMatrix, AbstractGBVector, unsafepack!, unsafeunpack!, GBMatrix,
 GBVector, AbstractGBArray, LibGraphBLAS, ColMajor, sparsitystatus,
 _sizedjlmalloc, increment!, isshallow, nnz, tempunpack!, storedeltype
 using SuiteSparseGraphBLAS
@@ -66,11 +66,11 @@ function CHOLMOD.Dense(A::AbstractGBMatrix)
     end
 end
 
-function _extract_args(s, ::Type{T}) where {T<:CHOLMOD.VTypes}
-    ptr = SuiteSparseGraphBLAS._copytoraw(unsafe_wrap(Array, s.p, (s.ncol + 1,), own = false))
+function _extract_args(s, ::Type{T}, ::Type{I}) where {T<:CHOLMOD.VTypes, I<:CHOLMOD.ITypes}
+    ptr = SuiteSparseGraphBLAS._copytoraw(unsafe_wrap(Array, Ptr{I}(s.p), (s.ncol + 1,), own = false))
     l = ptr[end] - 1
     return s.nrow, s.ncol, ptr,
-        SuiteSparseGraphBLAS._copytoraw(unsafe_wrap(Array, s.i, (l + 1,), own = false)), 
+        SuiteSparseGraphBLAS._copytoraw(unsafe_wrap(Array, Ptr{I}(s.i), (l + 1,), own = false)),
         SuiteSparseGraphBLAS._copytoraw(unsafe_wrap(Array, Ptr{T}(s.x), (l + 1,), own = false))
 end
 
@@ -82,24 +82,24 @@ function GBVector{T, F}(D::CHOLMOD.Dense{T}; fill = defaultfill(F)) where {T, F}
     SuiteSparseGraphBLAS.unsafepack!(A, D, false; order = ColMajor())
     return A
 end
-function GBVector{T, F}(S::CHOLMOD.Sparse{T}; fill = defaultfill(F)) where {T, F}
+function GBVector{T, F}(S::CHOLMOD.Sparse{T, I}; fill = defaultfill(F)) where {T, F, I}
     @assert size(S, 2) == 1
     s = unsafe_load(pointer(S))
     if s.stype != 0
         throw(ArgumentError("matrix has stype != 0. Convert to matrix " *
             "with stype == 0 before converting to GBMatrix"))
     end
-    nrow, ncol, ptr, idx, vals = _extract_args(s, T)
+    nrow, ncol, ptr, idx, vals = _extract_args(s, T, I)
     A = GBVector{T}(nrow; fill)
     SuiteSparseGraphBLAS.unsafepack!(
-        A, ptr, idx, vals, false; 
+        A, ptr, idx, vals, false;
         order = ColMajor(), jumbled = s.sorted == 0)
     return A
 end
 
-GBVector{T}(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} = 
+GBVector{T}(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} =
     GBVector{T, F}(D; fill)
-GBVector(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} = 
+GBVector(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} =
     GBVector{T, F}(D; fill)
 
 for Mat ∈ [:GBMatrix, :GBMatrixC, :GBMatrixR]
@@ -111,23 +111,23 @@ for Mat ∈ [:GBMatrix, :GBMatrixC, :GBMatrixR]
             SuiteSparseGraphBLAS.unsafepack!(A, D, false; order = ColMajor())
             return A
         end
-        function $Mat{T, F}(S::CHOLMOD.Sparse{T}; fill = defaultfill(F)) where {T, F}
+        function $Mat{T, F}(S::CHOLMOD.Sparse{T, I}; fill = defaultfill(F)) where {T, F, I}
             s = unsafe_load(pointer(S))
             if s.stype != 0
                 throw(ArgumentError("matrix has stype != 0. Convert to matrix " *
                     "with stype == 0 before converting to GBMatrix"))
             end
-            nrow, ncol, ptr, idx, vals = _extract_args(s, T)
+            nrow, ncol, ptr, idx, vals = _extract_args(s, T, I)
             A = $Mat{T}(nrow, ncol; fill)
             SuiteSparseGraphBLAS.unsafepack!(
-                A, ptr, idx, vals, false; 
+                A, ptr, idx, vals, false;
                 order = ColMajor(), jumbled = s.sorted == 0)
             return A
         end
 
-        $Mat{T}(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} = 
+        $Mat{T}(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} =
             $Mat{T, F}(D; fill)
-        $Mat(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} = 
+        $Mat(D::Union{CHOLMOD.Sparse{T}, CHOLMOD.Dense{T}}; fill::F = defaultfill(T)) where {T, F} =
             $Mat{T, F}(D; fill)
 
         function LinearAlgebra.Symmetric{Float64,<:$Mat{Float64}}(S::Sparse{Float64})
@@ -137,7 +137,7 @@ for Mat ∈ [:GBMatrix, :GBMatrixC, :GBMatrixR]
             Symmetric(A, s.stype > 0 ? :U : :L)
         end
         convert(T::Type{Symmetric{Float64,<:$Mat{Float64}}}, A::Sparse{Float64}) = T(A)
-        
+
         function LinearAlgebra.Hermitian{Tv,<:$Mat{Tv}}(A::Sparse{Tv}) where Tv<:VTypes
             s = unsafe_load(pointer(A))
             ishermitian(A) || throw(ArgumentError("matrix is not Hermitian"))
@@ -183,7 +183,7 @@ end
 function CHOLMOD.getLd!(S::AbstractGBMatrix)
     nz = nnz(S)
     colptr, rowvals, nonzeros, repack! = tempunpack!(
-        S, SuiteSparseGraphBLAS.Sparse(); 
+        S, SuiteSparseGraphBLAS.Sparse();
         order = ColMajor()
     )
     d = Vector{eltype(S)}(undef, size(S, 1))
@@ -264,7 +264,7 @@ function LinearAlgebra.lu(A::GBRealHermSymComplexHermF64SSL)
     return lu(copy(A))
 end
 
-# TODO: Improve these, to use better promotion: 
+# TODO: Improve these, to use better promotion:
 Base.:*(A::Symmetric{Float64,G},
     B::AbstractGBArray) where {G<:AbstractGBMatrix} = GBMatrix(Sparse(A)*Sparse(B))
 Base.:*(A::Hermitian{ComplexF64,<:GBMatrix},
@@ -278,4 +278,4 @@ Base.:*(A::AbstractGBArray{ComplexF64},
     B::Hermitian{ComplexF64,<:AbstractGBMatrix}) = GBMatrix(Sparse(A)*Sparse(B))
 Base.:*(A::AbstractGBArray{Float64},
     B::Hermitian{Float64,<:AbstractGBMatrix}) = GBMatrix(Sparse(A)*Sparse(B))
-end
+end