Add missing parallel=:threads implementations

These implementations are extremely basic, but they try to follow the
patterns in the other parts of the Parallel module. My real motivation
is to be able to move the Distributed implementations into an extension,
so that Graphs.jl does not depend on Distributed.

Author: topolarity

src/Parallel/distance.jl

@@ -2,17 +2,44 @@
 
 function eccentricity(
     g::AbstractGraph, vs=vertices(g), distmx::AbstractMatrix{T}=weights(g)
+    ; parallel=:distributed,
+) where {T<:Number}
+    return if parallel === :threads
+        threaded_eccentricity(g, vs, distmx)
+    elseif parallel === :distributed
+        distr_eccentricity(g, vs, distmx)
+    else
+        error("""Unsupported parallel argument '$(repr(parallel))' (supported: ':threads' or ':distributed')""")
+    end
+end
+
+function distr_eccentricity(
+    g::AbstractGraph, vs=vertices(g), distmx::AbstractMatrix{T}=weights(g)
 ) where {T<:Number}
     vlen = length(vs)
     eccs = SharedVector{T}(vlen)
     @sync @distributed for i in 1:vlen
-        eccs[i] = maximum(Graphs.dijkstra_shortest_paths(g, vs[i], distmx).dists)
+        d = Graphs.dijkstra_shortest_paths(g, vs[i], distmx)
+        eccs[i] = maximum(d.dists)
     end
     d = sdata(eccs)
     maximum(d) == typemax(T) && @warn("Infinite path length detected")
     return d
 end
 
+function threaded_eccentricity(
+    g::AbstractGraph, vs=vertices(g), distmx::AbstractMatrix{T}=weights(g)
+) where {T<:Number}
+    vlen = length(vs)
+    eccs = Vector{T}(vlen)
+    Base.Threads.@threads for i in 1:vlen
+        d = Graphs.dijkstra_shortest_paths(g, vs[i], distmx)
+        eccs[i] = maximum(d.dists)
+    end
+    maximum(eccs) == typemax(T) && @warn("Infinite path length detected")
+    return d
+end
+
 function eccentricity(g::AbstractGraph, distmx::AbstractMatrix)
     return eccentricity(g, vertices(g), distmx)
 end

src/Parallel/shortestpaths/dijkstra.jl

@@ -18,6 +18,39 @@ traversal information.
 """
 function dijkstra_shortest_paths(
     g::AbstractGraph{U}, sources=vertices(g), distmx::AbstractMatrix{T}=weights(g)
+    ; parallel=:distributed,
+) where {T<:Number} where {U}
+    return if parallel === :threads
+        threaded_dijkstra_shortest_paths(g, sources, distmx)
+    elseif parallel === :distributed
+        distr_dijkstra_shortest_paths(g, sources, distmx)
+    else
+        error("""Unsupported parallel argument '$(repr(parallel))' (supported: ':threads' or ':distributed')""")
+    end
+end
+
+function threaded_dijkstra_shortest_paths(
+    g::AbstractGraph{U}, sources=vertices(g), distmx::AbstractMatrix{T}=weights(g)
+) where {T<:Number} where {U}
+    n_v = nv(g)
+    r_v = length(sources)
+
+    # TODO: remove `Int` once julialang/#23029 / #23032 are resolved
+    dists = Matrix{T}(Int(r_v), Int(n_v))
+    parents = Matrix{U}(Int(r_v), Int(n_v))
+
+    Base.Threads.@threads for i in 1:r_v
+        state = Graphs.dijkstra_shortest_paths(g, sources[i], distmx)
+        dists[i, :] = state.dists
+        parents[i, :] = state.parents
+    end
+
+    result = MultipleDijkstraState(dists, parents)
+    return result
+end
+
+function distr_dijkstra_shortest_paths(
+    g::AbstractGraph{U}, sources=vertices(g), distmx::AbstractMatrix{T}=weights(g)
 ) where {T<:Number} where {U}
     n_v = nv(g)
     r_v = length(sources)

src/Parallel/traversals/greedy_color.jl

@@ -1,4 +1,26 @@
-function random_greedy_color(g::AbstractGraph{T}, reps::Integer) where {T<:Integer}
+function random_greedy_color(g::AbstractGraph{T}, reps::Integer;
+                             parallel=:distributed) where {T<:Integer}
+    return if parallel === :threads
+        threaded_greedy_color(g, reps)
+    elseif parallel === :distributed
+        distr_greedy_color(g, reps)
+    else
+        error("""Unsupported parallel argument '$(repr(parallel))' (supported: ':threads' or ':distributed')""")
+    end
+end
+
+function threaded_random_greedy_color(g::AbstractGraph{T}, reps::Integer) where {T<:Integer}
+    local_best = Any[nothing for _ in 1:reps]
+    Base.Threads.@threads for i in 1:reps
+        seq = shuffle(vertices(g))
+        local_best[t] = Graphs.perm_greedy_color(g, seq)
+    end
+    best = reduce(Graphs.best_color, local_best)
+
+    return convert(Graphs.Coloring{T}, best)
+end
+
+function distr_random_greedy_color(g::AbstractGraph{T}, reps::Integer) where {T<:Integer}
     best = @distributed (Graphs.best_color) for i in 1:reps
         seq = shuffle(vertices(g))
         Graphs.perm_greedy_color(g, seq)