type instability

Author: sbromberger

REQUIRE

@@ -1,2 +1,3 @@
 julia 0.6
 LightGraphs 0.10.5
+JLD2

src/StaticGraphs.jl

@@ -1,6 +1,7 @@
 module StaticGraphs
 
 using LightGraphs
+using JLD2
 
 import Base:
     convert, eltype, show, ==, Pair, Tuple, in, copy, length, start, next, done, issubset, zero, one,
@@ -10,7 +11,7 @@ import LightGraphs:
     _NI, _insert_and_dedup!, AbstractEdge, AbstractEdgeIter,
     src, dst, edgetype, nv, ne, vertices, edges, is_directed,
     has_vertex, has_edge, in_neighbors, out_neighbors,
-    indegree, outdegree, degree, insorted,
+    indegree, outdegree, degree, insorted, squash,
 
     AbstractGraphFormat, loadgraph, savegraph
 
@@ -50,7 +51,11 @@ An abstract type representing a simple graph structure.
 AbstractStaticGraphs must have the following elements:
 - weightmx::AbstractSparseMatrix{Real}
 """
-abstract type AbstractStaticGraph <: AbstractSimpleGraph end
+abstract type AbstractStaticGraph{T<:Integer, U<:Integer} <: AbstractSimpleGraph{T} end
+
+vectype(g::AbstractStaticGraph{T, U}) where T where U = T
+indtype(g::AbstractStaticGraph{T, U}) where T where U = U
+eltype(x::AbstractStaticGraph) = vectype(x)
 
 function show(io::IO, g::AbstractStaticGraph)
     if is_directed(g)
@@ -59,9 +64,9 @@ function show(io::IO, g::AbstractStaticGraph)
         dir = "undirected"
     end
     if nv(g) == 0
-        print(io, "empty $dir simple static $(eltype(g)) graph")
+        print(io, "empty $dir simple static {$(vectype(g)), $(indtype(g))} graph")
     else
-        print(io, "{$(nv(g)), $(ne(g))} $dir simple static $(eltype(g)) graph")
+        print(io, "{$(nv(g)), $(ne(g))} $dir simple static {$(vectype(g)), $(indtype(g))} graph")
     end
 end
 
@@ -76,9 +81,9 @@ end
     return fastview(g.f_vec, r)
 end
 
-nv(g::AbstractStaticGraph) = length(g.f_ind) - 1
-vertices(g::AbstractStaticGraph) = one(eltype(g)):nv(g)
-eltype(x::AbstractStaticGraph) = eltype(x.f_vec)
+nv(g::AbstractStaticGraph{T, U}) where T where U = T(length(g.f_ind) - 1)
+vertices(g::AbstractStaticGraph{T, U}) where T where U = one(T):nv(g)
+
 
 has_edge(g::AbstractStaticGraph, e::AbstractStaticEdge) =
     insorted(dst(e), neighbors(g, src(e)))

src/persistence.jl

@@ -1,64 +1,37 @@
 # StaticGraphs are binary files with the following format:
-# f_vec, 0, f_ind
+# sizeof(T), sizeU, f_vec, 0, f_ind
 # StaticDiGraphs have the following format:
-# f_vec, 0, f_ind, 0, b_vec, 0, b_ind
+# bits in T, bits in U, f_vec, 0, f_ind, 0, b_vec, 0, b_ind
 
 abstract type StaticGraphFormat <: AbstractGraphFormat end
-struct SGFormat{T<:Integer} <: StaticGraphFormat end
-struct SDGFormat{T<:Integer} <: StaticGraphFormat end
+struct SGFormat <: StaticGraphFormat end
+struct SDGFormat <: StaticGraphFormat end
 
-SGFormat() = SGFormat{Int64}()
-SGFormat(T::DataType) = SGFormat{T}()
-
-SDGFormat() = SDGFormat{Int64}()
-SDGFormat(T::DataType) = SDGFormat{T}()
-
-
-function savesg(fn::AbstractString, g::StaticGraph, T::DataType)
-    open(fn, "w+") do io
-        arr = vcat(g.f_vec, [0], g.f_ind)
-        v = Mmap.mmap(io, Vector{T}, length(arr))
-        for i = 1:length(arr)
-            @inbounds v[i] = arr[i]
-        end
-        Mmap.sync!(v)
-    end
+function savesg(fn::AbstractString, g::StaticGraph)
+    f_ind = g.f_ind
+    f_vec = g.f_vec
+    @save fn f_vec f_ind
     return 1
 end
 
-function savesg(fn::AbstractString, g::StaticDiGraph, T::DataType)
-    open(fn, "w+") do io
-        farr = vcat(g.f_vec, [0], g.f_ind)
-        barr = vcat(g.b_vec, [0], g.b_ind)
-        arr = vcat(farr, [0], barr)
-        v = Mmap.mmap(io, Vector{T}, length(arr))
-        for i = 1:length(arr)
-            @inbounds v[i] = arr[i]
-        end
-        Mmap.sync!(v)
-    end
+function savesg(fn::AbstractString, g::StaticDiGraph)
+    f_ind = g.f_ind
+    f_vec = g.f_vec
+    b_ind = g.b_ind
+    b_vec = g.b_vec
+    @save fn f_vec f_ind b_vec b_ind
     return 1
 end
 
-function loadsg(fn::AbstractString, ::SGFormat{T}) where T <: Integer
-    open(fn, "r") do io
-        arr = Mmap.mmap(io, Vector{T})
-        zeroind = findfirst(arr, 0)
-        StaticGraph{T}(arr[1:zeroind-1], arr[zeroind+1:end])
-    end
+function loadsg(fn::AbstractString, ::SGFormat)
+    @load fn f_vec f_ind
+    return StaticGraph(f_vec, f_ind)
 end
 
-function loadsg(fn::AbstractString, ::SDGFormat{T}) where T <: Integer
-    open(fn, "r") do io
-        arr = Mmap.mmap(io, Vector{T})
-        (z1, z2, z3) = findin(arr, 0)
-        f_arr = fastview(arr, 1:(z1 - 1))
-        f_ind = fastview(arr, (z1 + 1):(z2 - 1))
-        b_arr = fastview(arr, (z2 + 1):(z3 - 1))
-        b_ind = fastview(arr, (z3 + 1):length(arr))
-        StaticDiGraph{T}(f_arr, f_ind, b_arr, b_ind)
-    end
+function loadsg(fn::AbstractString, ::SDGFormat)
+    @load fn f_vec f_ind b_vec b_ind
+    return StaticGraph(f_vec, f_ind, b_vec, b_ind)
 end
 
-loadgraph(fn::AbstractString, gname::String, s::T) where T <: StaticGraphFormat = loadsg(fn, s)
-savegraph(fn::AbstractString, g::AbstractStaticGraph) =  savesg(fn, g, eltype(g))
+loadgraph(fn::AbstractString, gname::String) = loadsg(fn, s)
+savegraph(fn::AbstractString, g::AbstractStaticGraph) =  savesg(fn, g)

src/staticdigraph.jl

@@ -1,13 +1,13 @@
 """
-    StaticDiGraph{T}
+    StaticDiGraph{T, U}
 
 A type representing a static directed graph.
 """
-struct StaticDiGraph{T<:Integer} <: AbstractStaticGraph
+struct StaticDiGraph{T<:Integer, U<:Integer} <: AbstractStaticGraph{T, U}
     f_vec::Vector{T}
-    f_ind::Vector{T}
+    f_ind::Vector{U}
     b_vec::Vector{T}
-    b_ind::Vector{T}
+    b_ind::Vector{U}
 end
 
 @inline function _bvrange(g::StaticDiGraph, s)
@@ -21,17 +21,24 @@ end
     return fastview(g.b_vec, r)
 end
 
-ne(g::StaticDiGraph) = length(g.f_vec)
+ne(g::StaticDiGraph{T, U}) where T where U = U(length(g.f_vec))
 
 # sorted src, dst vectors for forward and backward edgelists.
-function StaticDiGraph(n_v, f_ss::Vector{T}, f_ds::Vector{T}, b_ss::Vector{T}, b_ds::Vector{T}) where T <: Integer
+function StaticDiGraph(n_v, f_ss::AbstractVector, f_ds::AbstractVector, b_ss::AbstractVector, b_ds::AbstractVector)
     length(f_ss) == length(f_ds) == length(b_ss) == length(b_ds) || error("source and destination vectors must be equal length")
-    (n_v == 0 || length(f_ss) == 0) && return StaticDiGraph(T[], T[1], T[], T[1])
+    (n_v == 0 || length(f_ss) == 0) && return StaticDiGraph(UInt8[], UInt8[1], UInt8[], UInt8[1])
     f_ind = [searchsortedfirst(f_ss, x) for x in 1:n_v]
     push!(f_ind, length(f_ss)+1)
     b_ind = [searchsortedfirst(b_ss, x) for x in 1:n_v]
     push!(b_ind, length(b_ss)+1)
-    return StaticDiGraph{T}(f_ds, f_ind, b_ds, b_ind)
+    T = mintype(f_ds)
+    U = mintype(f_ind)
+    return StaticDiGraph{T}(
+        convert(T, f_ds), 
+        convert(U, f_ind), 
+        convert(T, b_ds),
+        convert(U, b_ind)
+    )
 end
 
 # sorted src, dst tuples for forward and backward

src/staticgraph.jl

@@ -5,24 +5,26 @@
 
 A type representing an undirected static graph.
 """
-struct StaticGraph{T<:Integer} <: AbstractStaticGraph
+struct StaticGraph{T<:Integer, U<:Integer} <: AbstractStaticGraph{T, U}
     f_vec::Vector{T}
-    f_ind::Vector{T}
+    f_ind::Vector{U}
 end
 
 badj(g::StaticGraph, s) = fadj(g, s)
 
-ne(g::StaticGraph) = length(g.f_vec) ÷ 2
+ne(g::StaticGraph{T, U}) where T where U = T(length(g.f_vec) ÷ 2)
 
 
 # sorted src, dst vectors
 # note: this requires reverse edges included in the sorted vector.  
-function StaticGraph(n_v, ss::Vector{T}, ds::Vector{T}) where T <: Integer
+function StaticGraph(n_v, ss::AbstractVector, ds::AbstractVector)
     length(ss) != length(ds) && error("source and destination vectors must be equal length")
-    (n_v == 0 || length(ss) == 0) && return StaticGraph(T[], T[1])
+    (n_v == 0 || length(ss) == 0) && return StaticGraph(UInt8[], UInt8[1])
     f_ind = [searchsortedfirst(ss, x) for x in 1:n_v]
     push!(f_ind, length(ss)+1)
-    return StaticGraph{T}(ds, f_ind)
+    T = mintype(ds)
+    U = mintype(f_ind)
+    return StaticGraph{T, U}(convert(Vector{T},ds), convert(Vector{U}, f_ind))
 end
 
 # sorted src, dst tuples
@@ -42,7 +44,7 @@ end
 
 ==(g::StaticGraph, h::StaticGraph) = g.f_vec == h.f_vec && g.f_ind == h.f_ind
 
-degree(g::StaticGraph, v::Integer) = length(_fvrange(g, v))
+degree(g::StaticGraph{T, U}, v::Integer) where T where U = T(length(_fvrange(g, v)))
 degree(g::StaticGraph) = [degree(g, v) for v in vertices(g)]
 indegree(g::StaticGraph, v::Integer) = degree(g, v)
 indegree(g::StaticGraph) = degree(g)
@@ -56,5 +58,5 @@ outdegree(g::StaticGraph) = degree(g)
 Return `true` if `g` is a directed graph.
 """
 is_directed(::Type{StaticGraph}) = false
-is_directed(::Type{StaticGraph{T}}) where T = false
+is_directed(::Type{StaticGraph{T, U}}) where T where U = false
 is_directed(g::StaticGraph) = false

src/utils.jl

@@ -25,3 +25,32 @@ From https://github.com/rdeits/NNLS.jl/blob/0a9bf56774595b5735bc738723bd3cb94138
         view(parent, range)
     end
 end
+
+"""
+    squashsorted(v)
+
+Returns the sorted vector `v` converted to the smallest possible
+integer type that can fit all values.
+
+### Implementation Notes
+`v` is assumed to be sorted.
+"""
+function squashsorted(v::AbstractVector)
+    validtypes = [UInt8, UInt16, UInt32, UInt64, UInt128]
+    l = v[end]
+    for T in validtypes
+        l < typemax(T) && return convert(Vector{T}, v)
+    end
+    return v
+end
+
+function mintype(v::AbstractVector)
+    validtypes = [UInt8, UInt16, UInt32, UInt64, UInt128]
+    l = v[end]
+    for T in validtypes
+        l < typemax(T) && return T
+    end
+    return eltype(v)
+end
+
+