Merge branch 'master' of https://github.com/JuliaSparse/SuiteSparseGraphBLAS.jl

Author: rayegun

benchmarks/Manifest.toml

@@ -53,9 +53,9 @@ version = "0.1.6"
 
 [[Compat]]
 deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"]
-git-tree-sha1 = "96b0bc6c52df76506efc8a441c6cf1adcb1babc4"
+git-tree-sha1 = "b153278a25dd42c65abbf4e62344f9d22e59191b"
 uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
-version = "3.42.0"
+version = "3.43.0"
 
 [[CompilerSupportLibraries_jll]]
 deps = ["Artifacts", "Libdl"]
@@ -221,9 +221,9 @@ uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [[LogExpFunctions]]
 deps = ["ChainRulesCore", "ChangesOfVariables", "DocStringExtensions", "InverseFunctions", "IrrationalConstants", "LinearAlgebra"]
-git-tree-sha1 = "58f25e56b706f95125dcb796f39e1fb01d913a71"
+git-tree-sha1 = "a970d55c2ad8084ca317a4658ba6ce99b7523571"
 uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
-version = "0.3.10"
+version = "0.3.12"
 
 [[Logging]]
 uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
@@ -416,6 +416,18 @@ version = "0.4.1"
 deps = ["LinearAlgebra", "SparseArrays"]
 uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
+[[StatsAPI]]
+deps = ["LinearAlgebra"]
+git-tree-sha1 = "8d7530a38dbd2c397be7ddd01a424e4f411dcc41"
+uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
+version = "1.2.2"
+
+[[StatsBase]]
+deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]
+git-tree-sha1 = "8977b17906b0a1cc74ab2e3a05faa16cf08a8291"
+uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+version = "0.33.16"
+
 [[StorageOrders]]
 git-tree-sha1 = "365181758ec1084fecf147b72206f81a1310c8b7"
 uuid = "e9177fbf-8fde-426c-9425-4eed0f22262a"
@@ -433,7 +445,7 @@ uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
 
 [[SuiteSparseGraphBLAS]]
 deps = ["ChainRulesCore", "HyperSparseMatrices", "Libdl", "LinearAlgebra", "MacroTools", "Preferences", "Random", "SSGraphBLAS_jll", "Serialization", "SparseArrays", "SpecialFunctions", "StorageOrders", "SuiteSparse"]
-git-tree-sha1 = "33576d2926608fdfe958334400eac5b73c58c7d1"
+git-tree-sha1 = "6f6472faf84bf1b93e44e4bc75b5904cd987c281"
 repo-rev = "master"
 repo-url = "https://github.com/JuliaSparse/SuiteSparseGraphBLAS.jl.git"
 uuid = "c2e53296-7b14-11e9-1210-bddfa8111e1d"

benchmarks/Project.toml

@@ -2,6 +2,7 @@
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 MKLSparse = "0c723cd3-b8cd-5d40-b370-ba682dde9aae"
 SparseMatricesCSR = "a0a7dd2c-ebf4-11e9-1f05-cf50bc540ca1"
+StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 StorageOrders = "e9177fbf-8fde-426c-9425-4eed0f22262a"
 SuiteSparseGraphBLAS = "c2e53296-7b14-11e9-1210-bddfa8111e1d"
 SuiteSparseMatrixCollection = "ac199af8-68bc-55b8-82c4-7abd6f96ed98"

benchmarks/bench_subassign.jl

@@ -0,0 +1,122 @@
+println(stdout, "Opening Script")
+using Pkg
+Pkg.activate(".")
+Pkg.instantiate()
+using SuiteSparseMatrixCollection
+using SuiteSparseGraphBLAS
+using SparseArrays
+using LinearAlgebra
+using StorageOrders
+using StatsBase
+println(stdout, "Loaded Packages")
+
+macro gbbench(ex)
+    return quote
+        gbset(:burble, true)
+        $(esc(ex))
+        gbset(:burble, false)
+        local taccum = 0
+        for i ∈ 1:3
+            local t0 = time_ns()
+            $(esc(ex))
+            local t1 = time_ns()
+            taccum += t1 - t0
+        end
+        taccum / 1e9
+    end
+end
+
+macro bench(ex)
+    return quote
+        $(esc(ex))
+        local taccum = 0
+        for i ∈ 1:3
+            local t0 = time_ns()
+            $(esc(ex))
+            local t1 = time_ns()
+            taccum += t1 - t0
+        end
+        taccum / 1e9
+    end
+end
+
+# Comment or uncomment this line to disable or enable MKLSparse respectively.
+# This will only work for SpMM and SpMV and only operates on CSC.
+#using MKLSparse
+
+const threadlist = [1, 2, 16]
+
+function idx(C, A, I, J)
+    if C isa SuiteSparseGraphBLAS.AbstractGBArray
+        Ao = storageorder(A) == ColMajor() ? "C" : "R"
+        Co = storageorder(A) == ColMajor() ? "C" : "R"
+        printstyled(stdout, "\nC::GBArray($(Co))[I, J] = A::GBArray($Ao, $(size(A)))\n")
+        result = @gbbench begin
+            C[I, J] = A
+            wait(C)
+        end
+        println(stdout, result, "s")
+        GC.gc()
+    else
+        printstyled(stdout, "\nC[I, J] = A::SparseMatrixCSC($(size(A)))\n")
+        result = @bench C[I, J] = A
+        println(stdout, result, "s")
+        GC.gc()
+    end
+    flush(stdout)
+    return result
+end
+
+function runthreadedidx(C, A, I, J)
+    v = []
+    for t ∈ threadlist
+        printstyled(stdout, "\nRunning GraphBLAS with $t threads\n"; bold=true)
+        gbset(:nthreads, t)
+        push!(v, idx(C, A, I, J))
+    end
+    return v
+end
+
+function singlebench(szC, szA)
+    gbresultsR = [0.0, 0.0, 0.0]
+    gbresultsC = [0.0, 0.0, 0.0]
+    SAresults = 0.0
+    printstyled(stdout, "\nC($szC)[I, J] = A($szA))\n"; bold=true)
+    println(stdout, "################################")
+    for i ∈ 1:10
+        C = SuiteSparseGraphBLAS.gbrand(Float64, szC[1:2]..., szC[3])
+        A = SuiteSparseGraphBLAS.gbrand(Float64, szA[1:2]..., szA[3])
+        wait(C)
+        wait(A)
+        I = sample(1:size(C, 1), size(A, 1), replace = false)
+        J = sample(1:size(C, 2), size(A, 2), replace = false)
+
+        flush(stdout)
+        gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
+        gbset(C, :format, SuiteSparseGraphBLAS.BYROW)
+        SuiteSparseGraphBLAS.wait(A)
+        gbresultsR .+= runthreadedidx(C, A, I, J)
+        gbset(A, :format, SuiteSparseGraphBLAS.BYCOL)
+        gbset(C, :format, SuiteSparseGraphBLAS.BYCOL)
+        SuiteSparseGraphBLAS.wait(A)
+        gbresultsC .+= runthreadedidx(C, A, I, J)
+        A = SparseMatrixCSC(A) 
+        C = SparseMatrixCSC(C)
+        SAresults += idx(C, A, I, J)
+    end
+    println(stdout, )
+    printstyled(stdout, "\nRESULTS, C($szC)[I, J] = A($szA): \n"; bold=true, color=:green)
+    println(stdout, "################################")
+    println(stdout, "A by row (1, 2, 16 thread): $(gbresultsR ./ 30)")
+    println(stdout, "A by col (1, 2, 16 thread): $(gbresultsC ./ 30)")
+    println(stdout, "SparseArrays: $(SAresults / 30)")
+    flush(stdout)
+    return nothing
+end
+
+singlebench((10_000, 10_000, 0.001), (2_000, 2_000, 0.1))
+#singlebench((1_000_000, 1_000_000, 0.01), (5_000, 5_000, 0.005))
+#singlebench((25_000_000, 25_000_000, 1e-7), (5_000, 5_000, 0.002))
+#singlebench((50_000_000, 50_000_000, 1e-7), (100_000, 100_000, 0.001))
+#
+#singlebench((50_000_000, 50_000_000, 1e-7), (1_000, 1_000, 1.0))

benchmarks/benchmarks2.jl

@@ -73,9 +73,11 @@ end
 
 function tpose(A::SuiteSparseGraphBLAS.GBArray)
     Ao = storageorder(A) == ColMajor() ? "C" : "R"
-    Bo = storageorder(B) == ColMajor() ? "C" : "R"
-    printstyled(stdout, "\nC::GBArray = transpose(A::GBArray($Ao, $(size(A))))\n")
-    result = @gbbench copy(transpose(A))
+    C = similar(A)
+    gbset(C, :format, storageorder(A) === ColMajor() ? SuiteSparseGraphBLAS.BYCOL : SuiteSparseGraphBLAS.BYROW)
+    Co = storageorder(A) == ColMajor() ? "C" : "R"
+    printstyled(stdout, "\nC::GBArray($(Co)) = transpose(A::GBArray($Ao, $(size(A))))\n")
+    result = @gbbench SuiteSparseGraphBLAS.gbtranspose!(C, A)
     println(stdout, result, "s")
     GC.gc()
     flush(stdout)
@@ -91,7 +93,45 @@ function tpose(A::SparseMatrixCSC)
     return result
 end
 
-function spdbench(A)
+function runthreadedt(A; accumdenseoutput=false)
+    v = []
+    for t ∈ threadlist
+        printstyled(stdout, "\nRunning GraphBLAS with $t threads\n"; bold=true)
+        gbset(:nthreads, t)
+        push!(v, tpose(A))
+    end
+    return v
+end
+
+function idx(C, A, I, J)
+    if C isa SuiteSparseGraphBLAS.AbstractGBArray
+        Ao = storageorder(A) == ColMajor() ? "C" : "R"
+        Co = storageorder(A) == ColMajor() ? "C" : "R"
+        printstyled(stdout, "\nC::GBArray($(Co))[I, J] = A::GBArray($Ao, $(size(A)))\n")
+        result = @gbbench begin
+            C[I, J] = A
+            wait(C)
+        end
+        println(stdout, result, "s")
+        GC.gc()
+    else
+        printstyled(stdout, "\nC[I, J] = A::SparseMatrixCSC($(size(A)))\n")
+        result = @bench C[I, J] = A
+        println(stdou, result, "s")
+        GC.gc()
+    end
+    flush(stdout)
+    return result
+end
+
+function runthreadedidx(C, A, I, J)
+    v = []
+    for t ∈ threadlist
+        printstyled(stdout, "\nRunning GraphBLAS with $t threads\n"; bold=true)
+        gbset(:nthreads, t)
+        push!(v, idx(C, A, I, J))
+    end
+    return v
 end
 
 function singlebench(pathornum)
@@ -113,12 +153,13 @@ function singlebench(pathornum)
     printstyled(stdout, "\n#################################################################################\n"; bold=true, color=:green)
     printstyled(stdout, "Benchmarking $name:\n"; bold=true, color=:green)
     printstyled(stdout, "#################################################################################\n"; bold=true, color=:green)
+    
     printstyled(stdout, "\nSparse * Vec\n"; bold=true)
     println(stdout, "################################")
     flush(stdout)
     B = rand(eltype(A), size(A, 2))
     B = GBVector(B)
-
+# 
     gbresultsR = runthreaded(A, B; accumdenseoutput=true)
     gbset(A, :format, SuiteSparseGraphBLAS.BYCOL)
     diag(A)
@@ -130,7 +171,7 @@ function singlebench(pathornum)
     println(stdout, "A by col (1, 2, 16 thread): $gbresultsC")
     println(stdout, "SparseArrays: $SAresults")
     flush(stdout)
-
+# 
     printstyled(stdout, "\nSparse * (n x 2)\n"; bold=true)
     println(stdout, "################################")
     flush(stdout)
@@ -148,7 +189,7 @@ function singlebench(pathornum)
     println(stdout, "A by col (1, 2, 16 thread): $gbresultsC")
     println(stdout, "SparseArrays: $SAresults")
     flush(stdout)
-
+# 
     printstyled(stdout, "\nSparse * (n x 32)\n"; bold=true)
     println(stdout, "################################")
     flush(stdout)
@@ -166,7 +207,7 @@ function singlebench(pathornum)
     println(stdout, "A by col (1, 2, 16 thread): $gbresultsC")
     println(stdout, "SparseArrays: $SAresults")
     flush(stdout)
-
+# 
     printstyled(stdout, "\nSparse * Sparse'"; bold=true)
     println(stdout, "################################")
     flush(stdout)
@@ -179,32 +220,31 @@ function singlebench(pathornum)
     A2 = SparseMatrixCSC(A) 
     SAresults = mxm(A2, transpose(A2))
     println(stdout, )
-    printstyled(stdout, "\nRESULTS, Sparse * Sparse: \n"; bold=true, color=:green)
+    printstyled(stdout, "\nRESULTS, Sparse * n x 32 Dense: \n"; bold=true, color=:green)
     println(stdout, "################################")
     println(stdout, "A by row (1, 2, 16 thread): $gbresultsR")
     println(stdout, "A by col (1, 2, 16 thread): $gbresultsC")
     println(stdout, "SparseArrays: $SAresults")
     flush(stdout)
 
-    printstyled(stdout, "\nSparse * Sparse'"; bold=true)
+    printstyled(stdout, "\nC = copy(transpose(A))"; bold=true)
     println(stdout, "################################")
     flush(stdout)
     gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
     diag(A)
-    gbresultsR = runthreaded(A, transpose(A))
+    gbresultsR = runthreadedt(A)
     gbset(A, :format, SuiteSparseGraphBLAS.BYCOL)
     diag(A)
-    gbresultsC = runthreaded(A, transpose(A))
-    A2 = SparseMatrixCSC(A) 
-    SAresults = mxm(A2, transpose(A2))
+    gbresultsC = runthreadedt(A)
+    A2 = SparseMatrixCSC(A)
+    SAresults = tpose(A2)
     println(stdout, )
-    printstyled(stdout, "\nRESULTS, Sparse * Sparse: \n"; bold=true, color=:green)
+    printstyled(stdout, "\nRESULTS, C = copy(transpose(A)): \n"; bold=true, color=:green)
     println(stdout, "################################")
     println(stdout, "A by row (1, 2, 16 thread): $gbresultsR")
     println(stdout, "A by col (1, 2, 16 thread): $gbresultsC")
     println(stdout, "SparseArrays: $SAresults")
     flush(stdout)
-
     return nothing
 end
 

src/SuiteSparseGraphBLAS.jl

@@ -143,7 +143,7 @@ function __init__()
     # In the future this should hopefully allow us to do no-copy passing of arrays between Julia and SS:GrB.
     # In the meantime it helps Julia respond to memory pressure from SS:GrB and finalize things in a timely fashion.
     @wraperror LibGraphBLAS.GxB_init(LibGraphBLAS.GrB_NONBLOCKING, cglobal(:jl_malloc), cglobal(:jl_calloc), cglobal(:jl_realloc), cglobal(:jl_free))
-    gbset(:nthreads, Sys.CPU_THREADS ÷ 2)
+    gbset(:nthreads, BLAS.get_num_threads())
     # Eagerly load selectops constants.
     _loadselectops()
     ALL.p = load_global("GrB_ALL", LibGraphBLAS.GrB_Index)

src/wait.jl

@@ -1,47 +1,47 @@
 function Base.wait(A::AbstractGBArray)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_Matrix_wait(gbpointer(A), waitmode)
-    return nothing
+    return A
 end
 
 function Base.wait(A::LibGraphBLAS.GrB_UnaryOp)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_UnaryOp_wait(A, waitmode)
-    return nothing
+    return A
 end
 
 function Base.wait(A::LibGraphBLAS.GrB_BinaryOp)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_BinaryOp_wait(A, waitmode)
-    return nothing
+    return A
 end
 
 function Base.wait(A::LibGraphBLAS.GxB_SelectOp)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_SelectOp_wait(A, waitmode)
-    return nothing
+    return A
 end
 
 function Base.wait(A::LibGraphBLAS.GrB_IndexUnaryOp)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_IndexUnaryOp_wait(A, waitmode)
-    return nothing
+    return A
 end
 
 function Base.wait(A::LibGraphBLAS.GrB_Monoid)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_Monoid_wait(A, waitmode)
-    return nothing
+    return A
 end
 
 function Base.wait(A::LibGraphBLAS.GrB_Semiring)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_Semiring_wait(A, waitmode)
-    return nothing
+    return A
 end
 
 function Base.wait(A::GBScalar)
     waitmode = LibGraphBLAS.GrB_MATERIALIZE
     @wraperror LibGraphBLAS.GrB_Scalar_wait(A, waitmode)
-    return nothing
+    return A
 end