format

Author: AntoineBut

benchmark/benchmarks.jl

@@ -56,8 +56,8 @@ BFS_RESULTS =
     DataFrame(operation = String[], size = Int[], implementation = String[], time = Real[])
 
 for SIZE in SIZES
-    SIZE2 = SIZE 
-    FILL = 0.001 
+    SIZE2 = SIZE
+    FILL = 0.001
     print("Generating random sparse matrix of size $SIZE x $SIZE2 with fill $FILL\n")
     A_csc_cpu =
         convert(SparseMatrixCSC{MAIN_TYPE,INDEX_TYPE}, sprand(MAIN_TYPE, SIZE2, SIZE, FILL))
@@ -308,7 +308,7 @@ for i = 1:4
         KernelAbstractions.synchronize(BACKEND)
     end evals = 1 setup =
         (res_gpu = KernelAbstractions.zeros(BACKEND, ELTYPE_RES, $SIZE))
-        
+
     SUITE2["mul!"]["GPU"]["GPUGraphsSELL"] = @benchmarkable begin
         for j = 1:10
             gpu_spmv!(res_gpu, $A_sell_gpu, $b_gpu; mul = MUL, add = ADD, accum = ACCUM)
@@ -324,46 +324,51 @@ for i = 1:4
         KernelAbstractions.synchronize(BACKEND)
     end evals = 1 setup =
         (res_gpu = KernelAbstractions.zeros(BACKEND, ELTYPE_RES, $SIZE))
-    
+
 
     graph = SimpleGraph(A_T)
     println("Built graph. ")
 
-    A_csr_cpu = transpose(convert(SparseMatrixCSC{BOOL_TYPE,INDEX_TYPE}, adjacency_matrix(graph, BOOL_TYPE; dir = :out)))
+    A_csr_cpu = transpose(
+        convert(
+            SparseMatrixCSC{BOOL_TYPE,INDEX_TYPE},
+            adjacency_matrix(graph, BOOL_TYPE; dir = :out),
+        ),
+    )
     print("Converting to GPU-CSR format\n")
     A_csr_gpu = SparseGPUMatrixCSR(A_csr_cpu, BACKEND)
 
     print("Converting to SELL format\n")
     A_sell_gpu = SparseGPUMatrixSELL(A_csr_cpu, 64, BACKEND)
 
-        SUITE2["bfs"]["CPU"]["SuiteSparseGraphBLAS"] = @benchmarkable begin
-            bfs_BLAS!($A_ssGB, one(INDEX_TYPE), res_ssGB)
-        end evals = 1 setup =
-            (res_ssGB = GBVector{INDEX_TYPE}($SIZE, fill = zero(INDEX_TYPE)))
+    SUITE2["bfs"]["CPU"]["SuiteSparseGraphBLAS"] = @benchmarkable begin
+        bfs_BLAS!($A_ssGB, one(INDEX_TYPE), res_ssGB)
+    end evals = 1 setup =
+        (res_ssGB = GBVector{INDEX_TYPE}($SIZE, fill = zero(INDEX_TYPE)))
 
-        SUITE2["bfs"]["GPU"]["GPUGraphsCSR"] = @benchmarkable begin
-            GPUGraphs.bfs_parents($A_csr_gpu, one(INDEX_TYPE))
-            KernelAbstractions.synchronize(BACKEND)
-        end evals = 1
+    SUITE2["bfs"]["GPU"]["GPUGraphsCSR"] = @benchmarkable begin
+        GPUGraphs.bfs_parents($A_csr_gpu, one(INDEX_TYPE))
+        KernelAbstractions.synchronize(BACKEND)
+    end evals = 1
 
-    end
+end
 
-    if i >= 2
+if i >= 2
 
-        SUITE2["mul!"]["GPU"]["GPUGraphsSELL"] = @benchmarkable begin
-            for j = 1:10
-                gpu_spmv!(res_gpu, $A_sell_gpu, $b_gpu; mul = MUL, add = ADD, accum = ACCUM)
-            end
-            KernelAbstractions.synchronize(BACKEND)
-        end evals = 1 setup =
-            (res_gpu = KernelAbstractions.zeros(BACKEND, ELTYPE_RES, $SIZE))
-
-        if MAIN_TYPE == Bool
-            SUITE2["bfs"]["GPU"]["GPUGraphsSELL"] = @benchmarkable begin
-                GPUGraphs.bfs_parents($A_sell_gpu, one(INDEX_TYPE))
-                KernelAbstractions.synchronize(BACKEND)
-            end evals = 1
+    SUITE2["mul!"]["GPU"]["GPUGraphsSELL"] = @benchmarkable begin
+        for j = 1:10
+            gpu_spmv!(res_gpu, $A_sell_gpu, $b_gpu; mul = MUL, add = ADD, accum = ACCUM)
         end
+        KernelAbstractions.synchronize(BACKEND)
+    end evals = 1 setup =
+        (res_gpu = KernelAbstractions.zeros(BACKEND, ELTYPE_RES, $SIZE))
+
+    if MAIN_TYPE == Bool
+        SUITE2["bfs"]["GPU"]["GPUGraphsSELL"] = @benchmarkable begin
+            GPUGraphs.bfs_parents($A_sell_gpu, one(INDEX_TYPE))
+            KernelAbstractions.synchronize(BACKEND)
+        end evals = 1
+    end
 
     println("Launching benchmarks\n")
     bench_res2 = run(SUITE2)

benchmark/plots.jl

@@ -50,11 +50,11 @@ savefig(p_bfs, "benchmark/out/plot_bfs_results.png")
 # Plot the speedup relative to the SuiteSparseGraphBLAS implementation
 
 # Get the times
-ssgb_times = df[df.implementation.=="SuiteSparseGraphBLAS", :time]
-csr_gpu_times = df[df.implementation.=="GPUGraphsCSR", :time]
-ell_gpu_times = df[df.implementation.=="GPUGraphsELL", :time]
-cusparse_csr_times = df[df.implementation.=="CUSPARSE-CSR", :time]
-cusparse_csc_times = df[df.implementation.=="CUSPARSE-CSC", :time]
+ssgb_times = df[df.implementation .== "SuiteSparseGraphBLAS", :time]
+csr_gpu_times = df[df.implementation .== "GPUGraphsCSR", :time]
+ell_gpu_times = df[df.implementation .== "GPUGraphsELL", :time]
+cusparse_csr_times = df[df.implementation .== "CUSPARSE-CSR", :time]
+cusparse_csc_times = df[df.implementation .== "CUSPARSE-CSC", :time]
 
 
 
@@ -83,9 +83,9 @@ savefig(speedup_plot, "benchmark/out/plot_spmv_speedup.png")
 # Get the times
 graphsjl_times = df_bfs[df_bfs.implementation .== "Graphs.jl", :time]
 
-ssgb_times = df_bfs[df_bfs.implementation.=="SuiteSparseGraphBLAS", :time]
-csr_gpu_times = df_bfs[df_bfs.implementation.=="GPUGraphsCSR", :time]
-ell_gpu_times = df_bfs[df_bfs.implementation.=="GPUGraphsELL", :time]
+ssgb_times = df_bfs[df_bfs.implementation .== "SuiteSparseGraphBLAS", :time]
+csr_gpu_times = df_bfs[df_bfs.implementation .== "GPUGraphsCSR", :time]
+ell_gpu_times = df_bfs[df_bfs.implementation .== "GPUGraphsELL", :time]
 
 # Calculate the speedup
 speedup_ssgb = graphsjl_times ./ ssgb_times
@@ -116,7 +116,7 @@ df2_bfs = DataFrame(CSV.File("benchmark/out/bfs_results_data.csv"))
 df2_bfs[!, :time] /= 1e9  # convert ns to s
 
 # For each dataset, normalize the time by the time of the SuiteSparseGraphBLAS implementation
-gb_times = df2[df2.implementation.=="CUSPARSE-CSR", :time]
+gb_times = df2[df2.implementation .== "CUSPARSE-CSR", :time]
 gb_times_column = repeat(gb_times, inner = 4)
 # Normalize the time by the SuiteSparseGraphBLAS time
 df2[!, :time] = julia_times_column ./ df2[!, :time]
@@ -136,16 +136,16 @@ p2 = @df df2 bar(
 )
 # Add the speedup
 speedups = df2[!, :time]
-if false 
-annotate!(1, 0, text("$(round(speedups[1], digits = 2))x \n", :black, 8, :center))
-annotate!(2, 0, text("$(round(speedups[2], digits = 2))x \n", :black, 8, :center))
-annotate!(3, 0, text("$(round(speedups[3], digits = 2))x \n", :black, 8, :center))
-annotate!(4, 0, text("$(round(speedups[4], digits = 2))x \n", :black, 8, :center))
-annotate!(5, 0, text("$(round(speedups[5], digits = 2))x \n", :black, 8, :center))
-annotate!(6, 0, text("$(round(speedups[6], digits = 2))x \n", :black, 8, :center))
-annotate!(7, 0, text("$(round(speedups[7], digits = 2))x \n", :black, 8, :center))
-annotate!(8, 0, text("$(round(speedups[8], digits = 2))x \n", :black, 8, :center))
-annotate!(9, 0, text("$(round(speedups[9], digits = 2))x \n", :black, 8, :center))
+if false
+    annotate!(1, 0, text("$(round(speedups[1], digits = 2))x \n", :black, 8, :center))
+    annotate!(2, 0, text("$(round(speedups[2], digits = 2))x \n", :black, 8, :center))
+    annotate!(3, 0, text("$(round(speedups[3], digits = 2))x \n", :black, 8, :center))
+    annotate!(4, 0, text("$(round(speedups[4], digits = 2))x \n", :black, 8, :center))
+    annotate!(5, 0, text("$(round(speedups[5], digits = 2))x \n", :black, 8, :center))
+    annotate!(6, 0, text("$(round(speedups[6], digits = 2))x \n", :black, 8, :center))
+    annotate!(7, 0, text("$(round(speedups[7], digits = 2))x \n", :black, 8, :center))
+    annotate!(8, 0, text("$(round(speedups[8], digits = 2))x \n", :black, 8, :center))
+    annotate!(9, 0, text("$(round(speedups[9], digits = 2))x \n", :black, 8, :center))
 end
 display(p2)
 
@@ -168,7 +168,6 @@ p2_bfs = @df df2_bfs bar(
     legend = :topleft,
     title = "BFS",
     ylim = (0, 1),
-
 )
 # Add the speedup
 speedups_bfs = 1 ./ df2_bfs[!, :time]

src/algorithms/shortest_path.jl

@@ -57,7 +57,7 @@ function shortest_path!(
     while true
 
         iter += one(Ti)
-        
+
         gpu_spmv!(
             next,
             A_T,
@@ -74,7 +74,7 @@ function shortest_path!(
                 return nothing
             end
         end
-        
+
         # Update the dist array
         dist .= next
 

src/spmm/CSC.jl

@@ -1 +1 @@
-#TODO
+#TODO

src/spmm/spmm.jl

@@ -1,4 +1,4 @@
 
 include("CSR.jl")
 include("CSC.jl")
-include("SELL.jl")
+include("SELL.jl")

src/spmv/CSC.jl

@@ -58,4 +58,4 @@ function gpu_spmv!(
         accum;
         ndrange = size(A, 1),
     )
-end
+end

src/spmv/SELL.jl

@@ -6,8 +6,8 @@ function gpu_spmv!(
     mul::Function = GPUGraphs_mul,
     add::Function = GPUGraphs_add,
     accum::Function = GPUGraphs_second,
-    range::Union{Nothing, UnitRange} = nothing,
-    mask::Union{Nothing, AbstractVector} = nothing,
+    range::Union{Nothing,UnitRange} = nothing,
+    mask::Union{Nothing,AbstractVector} = nothing,
 ) where {
     Tv,
     Ti<:Integer,
@@ -20,9 +20,9 @@ function gpu_spmv!(
     if mask === nothing && range === nothing
         _simple_gpu_spmv!(C, A, B, mul, add, accum)
     elseif mask !== nothing && range === nothing
-        _dense_mask_gpu_spmv!(C, A, B,  mul, add, accum, mask)
+        _dense_mask_gpu_spmv!(C, A, B, mul, add, accum, mask)
     elseif mask === nothing && range !== nothing
-        _range_gpu_spmv!(C, A, B,mul, add, accum, range)
+        _range_gpu_spmv!(C, A, B, mul, add, accum, range)
     else
         _range_mask_gpu_spmv!(C, A, B, mul, add, accum, mask, range)
     end
@@ -123,7 +123,7 @@ end
         acc = monoid_neutral_element
         for i = (a_slice_ptr[slice]+offset):slice_size:(a_slice_ptr[slice+1]-1)
             col = a_col_val[i]
-            if col == -1 
+            if col == -1
                 break
             end
             acc = add(acc, mul(a_nz_val[i], b[col], row, col, col, 1), row, col, col, 1)
@@ -273,7 +273,7 @@ end
         acc = monoid_neutral_element
         for i = (a_slice_ptr[slice]+offset):slice_size:(a_slice_ptr[slice+1]-1)
             col = a_col_val[i]
-            if col == -1 
+            if col == -1
                 break
             end
             acc = add(acc, mul(a_nz_val[i], b[col], row, col, col, 1), row, col, col, 1)
@@ -342,22 +342,26 @@ function _validate_args(
     MaskVec<:AbstractVector{Tmask},
 }
     # Check dimensions
-    if size(A, 2) != length(B) 
+    if size(A, 2) != length(B)
         throw(DimensionMismatch("Matrix dimensions must agree"))
     end
     if size(C, 1) != size(A, 1)
         throw(DimensionMismatch("Matrix dimensions must agree"))
     end
     # Check types
     if !(promote_type(Tv, InputType) <: ResType)
-        throw(ArgumentError("Result type must be able to hold the result of the multiplication"))
+        throw(
+            ArgumentError(
+                "Result type must be able to hold the result of the multiplication",
+            ),
+        )
     end
     # Check backends
     backend = get_backend(A)
     if get_backend(B) != backend || get_backend(C) != backend
         throw(ArgumentError("All inputs must be on the same backend"))
     end
-     # Check mask if provided
+    # Check mask if provided
     if mask !== nothing
         # Check mask type
         if !(typeof(mask) <: AbstractVector{Tmask})
@@ -372,4 +376,4 @@ function _validate_args(
             throw(ArgumentError("Mask must be on the same backend as A"))
         end
     end
-end
+end

src/storage/CSR.jl

@@ -187,4 +187,3 @@ sprand_gpu(::Type{Tv}, m::Int, n::Int, p::Real, backend::Backend) where {Tv} =
 
 # KA functions
 KernelAbstractions.get_backend(A::SparseGPUMatrixCSR) = get_backend(A.nzval)
-

src/storage/GPUGraphsMatrix.jl

@@ -3,9 +3,9 @@
 "
     Abstract type for a GPU compatible sparse matrix
 "
-abstract type AbstractSparseGPUMatrix{Tv,Ti<:Integer} <: SparseArrays.AbstractSparseMatrix{Tv,Ti} 
-end
+abstract type AbstractSparseGPUMatrix{Tv,Ti<:Integer} <:
+              SparseArrays.AbstractSparseMatrix{Tv,Ti} end
 
 include("CSC.jl")
 include("CSR.jl")
-include("SELL.jl")
+include("SELL.jl")

src/storage/SELL.jl

@@ -152,7 +152,7 @@ function SparseGPUMatrixSELL(
 
 
         end
-        
+
         # Reshape the sub-matrix to make it column-major vector and copy it to final storage
 
         colval_padded[slice_ptr[slice]:(slice_ptr[slice+1]-1)] =
@@ -245,4 +245,3 @@ SparseArrays.nnz(A::SparseGPUMatrixSELL) = A.nnz
 
 # KA functions
 KernelAbstractions.get_backend(A::SparseGPUMatrixSELL) = get_backend(A.nzval)
-