update bench

Author: rayegun

benchmarks/benchmarks2.jl

@@ -3,33 +3,52 @@ Pkg.activate(".")
 Pkg.instantiate()
 using SuiteSparseMatrixCollection
 using SuiteSparseGraphBLAS
-using BenchmarkTools
 using SparseArrays
 using LinearAlgebra
 using StorageOrders
 
-#OPTIONS SET 1:
-# Maximum number of samples taken for each benchmark
-BenchmarkTools.DEFAULT_PARAMETERS.samples = 3
-BenchmarkTools.DEFAULT_PARAMETERS.evals = 1
-# Total amount of time allowed for each benchmark, minimum of 1 sample taken.
-BenchmarkTools.DEFAULT_PARAMETERS.seconds = 180
+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
+        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, 16]
-
-const suite = BenchmarkGroup()
+const threadlist = [1, 2, 16]
 const ssmc = ssmc_db()
 
 function mxm(A::SparseMatrixCSC, B)
     printstyled(stdout, "\nC = A::SparseMatrixCSC($(size(A))) * B::$(typeof(B))($(size(B)))\n")
-    result = @benchmark $A * $B
-    show(stdout, MIME("text/plain"), result)
+    result = @bench A * B
+    println(stdout, result, "s")
     flush(stdout)
-    return median(result)
+    return result
 end
 
 function mxm(A::SuiteSparseGraphBLAS.GBArray, B::SuiteSparseGraphBLAS.GBArray; accumdenseoutput=false)
@@ -38,22 +57,16 @@ function mxm(A::SuiteSparseGraphBLAS.GBArray, B::SuiteSparseGraphBLAS.GBArray; a
     if !accumdenseoutput
         printstyled(stdout, "\nC::GBArray = A::GBArray($Ao, $(size(A))) * B::GBArray($Bo, $(size(B)))\n")
         flush(stdout)
-        gbset(:burble, true)
-        mul(A, B)
-        gbset(:burble, false)
-        result = @benchmark mul($A, $B)
+        result = @gbbench mul(A, B)
     else
         printstyled(stdout, "\nC::GBArray += A::GBArray($Ao, $(size(A))) * B::GBArray($Bo, $(size(B)))\n")
         C = GBMatrix(zeros(eltype(A), size(A, 1), size(B, 2)))
         flush(stdout)
-        gbset(:burble, true)
-        mul!(C, A, B; accum=+)
-        gbset(:burble, false)
-        result = @benchmark mul!($C, $A, $B; accum=+)
+        result = @gbbench mul!(C, A, B; accum=+)
     end
-    show(stdout, MIME("text/plain"), result)
+    println(stdout, result, "s")
     flush(stdout)
-    return median(result)
+    return result
 end
 
 function singlebench(pathornum)
@@ -71,7 +84,8 @@ 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, "Sparse * Vec\n"; bold=true)
+    printstyled(stdout, "\nSparse * Vec\n"; bold=true)
+    println(stdout, "################################")
     flush(stdout)
     B = rand(eltype(A), size(A, 2))
     B = GBVector(B)
@@ -81,12 +95,16 @@ function singlebench(pathornum)
     diag(A)
     gbresultsC = runthreaded(A, B; accumdenseoutput=true)
     SAresults = mxm(SparseMatrixCSC(A), Vector(B))
-    printstyled(stdout, "RESULTS, Sparse * DenseVec: \n"; bold=true, color=:green)
-    println(stdout, "A by row: $gbresultsR")
-    println(stdout, "A by col: $gbresultsC")
+    printstyled(stdout, "\nRESULTS, Sparse * DenseVec: \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 * (n x 2)\n"; bold=true)
+    println(stdout, "################################")
+    flush(stdout)
     B = GBMatrix(rand(eltype(A), size(A, 2), 2))
     gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
     diag(A)
@@ -95,12 +113,16 @@ function singlebench(pathornum)
     diag(A)
     gbresultsC = runthreaded(A, B; accumdenseoutput=true)
     SAresults = mxm(SparseMatrixCSC(A), Matrix(B))
-    printstyled(stdout, "RESULTS, Sparse * n x 2 Dense: \n"; bold=true, color=:green)
-    println(stdout, "A by row: $gbresultsR")
-    println(stdout, "A by col: $gbresultsC")
+    printstyled(stdout, "\nRESULTS, Sparse * n x 2 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 * (n x 32)\n"; bold=true)
+    println(stdout, "################################")
+    flush(stdout)
     B = GBMatrix(rand(eltype(A), size(A, 2), 32))
     gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
     diag(A)
@@ -109,25 +131,29 @@ function singlebench(pathornum)
     diag(A)
     gbresultsC = runthreaded(A, B; accumdenseoutput=true)
     SAresults = mxm(SparseMatrixCSC(A), Matrix(B))
-    printstyled(stdout, "RESULTS, Sparse * n x 32 Dense: \n"; bold=true, color=:green)
-    println(stdout, "A by row: $gbresultsR")
-    println(stdout, "A by col: $gbresultsC")
+    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)
+    println(stdout, "################################")
+    flush(stdout)
     gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
     diag(A)
     gbresultsR = runthreaded(A, transpose(A))
     gbset(A, :format, SuiteSparseGraphBLAS.BYCOL)
     diag(A)
     gbresultsC = runthreaded(A, transpose(A))
-    A2 = SparseMatrixCSC(A)
+    A2 = SparseMatrixCSC(A) 
     SAresults = mxm(A2, transpose(A2))
     println(stdout, )
-    printstyled(stdout, "\n\nRESULTS, Sparse * Sparse: \n"; bold=true, color=:green)
-    println(stdout, "A by row: $gbresultsR")
-    println(stdout, "A by col: $gbresultsC")
+    printstyled(stdout, "\nRESULTS, Sparse * Sparse: \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