update benchmark

Author: rayegun

.gitignore

@@ -6,3 +6,4 @@ docs/site/
 .vscode
 Manifest.toml
 LocalPreferences.toml
+benchmarks/results.txt

benchmarks/benchmarks2.jl

@@ -13,45 +13,46 @@ using StorageOrders
 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 = 1000
+BenchmarkTools.DEFAULT_PARAMETERS.seconds = 180
 
 # 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
 
-# Change this to change the size of the dense RHS of csrtimesfull and csctimesfull
-const sizefullrhs = [1, 4, 16, 64, 1024]
-
-const threadlist = [1, Sys.CPU_THREADS ÷ 2]
+const threadlist = [1, 16]
 
 const suite = BenchmarkGroup()
 const ssmc = ssmc_db()
 
 function mxm(A::SparseMatrixCSC, B)
-    printstyled("\nC = A::SparseMatrixCSC($(size(A))) * B::$(typeof(B))($(size(B)))\n")
-    result = @benchmark $A * $B samples=3 evals=1 seconds=2
+    printstyled(stdout, "\nC = A::SparseMatrixCSC($(size(A))) * B::$(typeof(B))($(size(B)))\n")
+    result = @benchmark $A * $B
     show(stdout, MIME("text/plain"), result)
+    flush(stdout)
     return median(result)
 end
 
 function mxm(A::SuiteSparseGraphBLAS.GBArray, B::SuiteSparseGraphBLAS.GBArray; accumdenseoutput=false)
     Ao = storageorder(A) == ColMajor() ? "C" : "R"
     Bo = storageorder(B) == ColMajor() ? "C" : "R"
     if !accumdenseoutput
-        printstyled("\nC::GBArray = A::GBArray($Ao, $(size(A))) * B::GBArray($Bo, $(size(B)))\n")
+        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) samples=3 evals=1 seconds=2
+        result = @benchmark mul($A, $B)
     else
-        printstyled("\nC::GBArray += A::GBArray($Ao, $(size(A))) * B::GBArray($Bo, $(size(B)))\n")
+        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=+) samples=3 evals=1 seconds=2
+        result = @benchmark mul!($C, $A, $B; accum=+)
     end
     show(stdout, MIME("text/plain"), result)
+    flush(stdout)
     return median(result)
 end
 
@@ -67,57 +68,52 @@ function singlebench(pathornum)
     end
     name = basename(path)
     A = SuiteSparseGraphBLAS.mmread(path)
-    printstyled("\n#################################################################################\n"; bold=true, color=:green)
-    printstyled("Benchmarking $name:\n"; bold=true, color=:green)
-    printstyled("#################################################################################\n"; bold=true, color=:green)
-    printstyled("Sparse * Vec\n"; bold=true)
-    printstyled("A matrix: \n")
-    show(stdout, MIME("text/plain"), A)
+    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)
+    flush(stdout)
     B = rand(eltype(A), size(A, 2))
     B = GBVector(B)
-    
-    printstyled("B matrix: \n")
-    show(stdout, MIME("text/plain"), B)
 
     gbresultsR = runthreaded(A, B; accumdenseoutput=true)
     gbset(A, :format, SuiteSparseGraphBLAS.BYCOL)
     diag(A)
     gbresultsC = runthreaded(A, B; accumdenseoutput=true)
     SAresults = mxm(SparseMatrixCSC(A), Vector(B))
-    printstyled("RESULTS, Sparse * DenseVec: \n"; bold=true, color=:green)
-    println("A by row: $gbresultsR")
-    println("A by col: $gbresultsC")
-    println("SparseArrays: $SAresults")
+    printstyled(stdout, "RESULTS, Sparse * DenseVec: \n"; bold=true, color=:green)
+    println(stdout, "A by row: $gbresultsR")
+    println(stdout, "A by col: $gbresultsC")
+    println(stdout, "SparseArrays: $SAresults")
+    flush(stdout)
 
     B = GBMatrix(rand(eltype(A), size(A, 2), 2))
-    printstyled("B matrix: \n")
-    show(stdout, MIME("text/plain"), B)
     gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
     diag(A)
     gbresultsR = runthreaded(A, B; accumdenseoutput=true)
     gbset(A, :format, SuiteSparseGraphBLAS.BYCOL)
     diag(A)
     gbresultsC = runthreaded(A, B; accumdenseoutput=true)
     SAresults = mxm(SparseMatrixCSC(A), Matrix(B))
-    printstyled("RESULTS, Sparse * n x 2 Dense: \n"; bold=true, color=:green)
-    println("A by row: $gbresultsR")
-    println("A by col: $gbresultsC")
-    println("SparseArrays: $SAresults")
+    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")
+    println(stdout, "SparseArrays: $SAresults")
+    flush(stdout)
 
     B = GBMatrix(rand(eltype(A), size(A, 2), 32))
-    printstyled("B matrix: \n")
-    show(stdout, MIME("text/plain"), B)
     gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
     diag(A)
     gbresultsR = runthreaded(A, B; accumdenseoutput=true)
     gbset(A, :format, SuiteSparseGraphBLAS.BYCOL)
     diag(A)
     gbresultsC = runthreaded(A, B; accumdenseoutput=true)
     SAresults = mxm(SparseMatrixCSC(A), Matrix(B))
-    printstyled("RESULTS, Sparse * n x 32 Dense: \n"; bold=true, color=:green)
-    println("A by row: $gbresultsR")
-    println("A by col: $gbresultsC")
-    println("SparseArrays: $SAresults")
+    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")
+    println(stdout, "SparseArrays: $SAresults")
+    flush(stdout)
 
 
     gbset(A, :format, SuiteSparseGraphBLAS.BYROW)
@@ -128,19 +124,19 @@ function singlebench(pathornum)
     gbresultsC = runthreaded(A, transpose(A))
     A2 = SparseMatrixCSC(A)
     SAresults = mxm(A2, transpose(A2))
-    println()
-    printstyled("\n\nRESULTS, Sparse * Sparse: \n"; bold=true, color=:green)
-    println("A by row: $gbresultsR")
-    println("A by col: $gbresultsC")
-    println("SparseArrays: $SAresults")
-    println()
+    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")
+    println(stdout, "SparseArrays: $SAresults")
+    flush(stdout)
     return nothing
 end
 
 function runthreaded(A, B; accumdenseoutput=false)
     v = []
     for t ∈ threadlist
-        printstyled("\nRunning GraphBLAS with $t threads\n"; bold=true)
+        printstyled(stdout, "\nRunning GraphBLAS with $t threads\n"; bold=true)
         gbset(:nthreads, t)
         push!(v, mxm(A, B; accumdenseoutput))
     end