Run benchmarks.

Author: chriselrod

Project.toml

@@ -15,7 +15,7 @@ VectorizationBase = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f"
 [compat]
 DocStringExtensions = "0.8"
 OffsetArrays = "1"
-SIMDPirates = "0.8"
+SIMDPirates = "0.8.1"
 SLEEFPirates = "0.5"
 UnPack = "0,1"
 VectorizationBase = "0.12"

benchmark/benchmarkflops.jl

@@ -107,7 +107,7 @@ blastests() = [
     "LoopVectorization",
     "Julia", "Clang",
     "GFortran", "icc", "ifort",
-    "g++ & Eigen-3", "icpc & Eigen-3",
+    "g++ & Eigen-3", "clang++ & Eigen-3",
     "GFortran-builtin", "ifort-builtin",
     BLAS.vendor() === :mkl ? "IntelMKL" : "OpenBLAS", "MKL"
 ]    
@@ -160,7 +160,7 @@ function dot_bench!(br, s, i)
     br[9,i] = n_gflop / @belapsed dot($a, $b)
 end
 function benchmark_dot(sizes)
-    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "icpc & Eigen-3", BLAS.vendor() === :mkl ? "IntelMKL" : "OpenBLAS"]
+    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "clang++ & Eigen-3", BLAS.vendor() === :mkl ? "IntelMKL" : "OpenBLAS"]
     br = BenchmarkResult(tests, sizes)
     sm = br.sizedresults.results
     pmap(is -> dot_bench!(sm, is[2], is[1]), enumerate(sizes))
@@ -189,7 +189,7 @@ function selfdot_bench!(br, s, i)
     br[9,i] = n_gflop / @belapsed dot($a, $a)
 end
 function benchmark_selfdot(sizes)
-    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "icpc & Eigen-3", BLAS.vendor() === :mkl ? "IntelMKL" : "OpenBLAS"]
+    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "clang++ & Eigen-3", BLAS.vendor() === :mkl ? "IntelMKL" : "OpenBLAS"]
     br = BenchmarkResult(tests, sizes)
     sm = br.sizedresults.results
     pmap(is -> selfdot_bench!(sm, is[2], is[1]), enumerate(sizes))
@@ -258,9 +258,9 @@ function dot3_bench!(br, s, i)
     x = rand(M); A = rand(M, N); y = rand(N);
     dotblas = dot(x, A, y)
     n_gflop = M*N * 3e-9
-    br[1,i] = n_gflop / @belapsed jdot3v2avx($x, $A, $y)
+    br[1,i] = n_gflop / @belapsed jdot3avx($x, $A, $y)
     @assert jdot3avx(x, A, y) ≈ dotblas "LoopVec dot wrong?"
-    br[2,i] = n_gflop / @belapsed jdot3v2($x, $A, $y)
+    br[2,i] = n_gflop / @belapsed jdot3($x, $A, $y)
     @assert jdot3(x, A, y) ≈ dotblas "Julia dot wrong?"
     br[3,i] = n_gflop / @belapsed cdot3($x, $A, $y)
     @assert cdot3(x, A, y) ≈ dotblas "Clang dot wrong?"
@@ -273,11 +273,11 @@ function dot3_bench!(br, s, i)
     br[7,i] = n_gflop / @belapsed edot3($x, $A, $y)
     @assert edot3(x, A, y) ≈ dotblas "eigen dot wrong?"
     br[8,i] = n_gflop / @belapsed iedot3($x, $A, $y)
-    @assert iedot3(x, A, y) ≈ dotblas "i-eigen dot wrong?"
+    @assert iedot3(x, A, y) ≈ dotblas "c-eigen dot wrong?"
     br[9,i] = n_gflop / @belapsed dot($x, $A, $y)
 end
 function benchmark_dot3(sizes)
-    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "icpc & Eigen-3", "LinearAlgebra" ]
+    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "clang++ & Eigen-3", "LinearAlgebra" ]
     br = BenchmarkResult(tests, sizes)
     sm = br.sizedresults.results
     pmap(is -> dot3_bench!(sm, is[2], is[1]), enumerate(sizes))
@@ -316,7 +316,7 @@ function sse_bench!(br, s, i)
     br[9,i] = n_gflop / @belapsed sse!($Xβ, $y, $X, $β)
 end
 function benchmark_sse(sizes)
-    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "icpc & Eigen-3", BLAS.vendor() === :mkl ? "IntelMKL" : "OpenBLAS"]
+    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "clang++ & Eigen-3", BLAS.vendor() === :mkl ? "IntelMKL" : "OpenBLAS"]
     br = BenchmarkResult(tests, sizes)
     sm = br.sizedresults.results
     pmap(is -> sse_bench!(sm, is[2], is[1]), enumerate(sizes))
@@ -370,7 +370,7 @@ function aplusBc_bench!(br, s, i)
     @assert D ≈ Dcopy "i-eigen wrong?"; fill!(D, NaN);
 end
 function benchmark_aplusBc(sizes)
-    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "icpc & Eigen-3"]
+    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "clang++ & Eigen-3"]
     br = BenchmarkResult(tests, sizes)
     sm = br.sizedresults.results
     pmap(is -> aplusBc_bench!(sm, is[2], is[1]), enumerate(sizes))
@@ -402,7 +402,7 @@ function AplusAt_bench!(br, s, i)
     @assert B ≈ baseB "ifort-builtin wrong?"; fill!(B, NaN);
 end
 function benchmark_AplusAt(sizes)
-    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "icpc & Eigen-3", "GFortran-builtin", "ifort-builtin"]
+    tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "clang++ & Eigen-3", "GFortran-builtin", "ifort-builtin"]
     br = BenchmarkResult(tests, sizes)
     sm = br.sizedresults.results
     pmap(is -> AplusAt_bench!(sm, is[2], is[1]), enumerate(sizes))
@@ -453,9 +453,14 @@ function logdettriangle_bench!(br, s, i)
     @assert ld ≈ iclogdettriangle(U) "icc wrong?"
     br[6,i] = n_gflop / @belapsed iflogdettriangle($U)
     @assert ld ≈ iflogdettriangle(U) "ifort wrong?"
+    # br[7,i] = n_gflop / @belapsed elogdettriangle($U)
+    # @assert ld ≈ elogdettriangle(U) "eigen wrong?"; fill!(B, NaN);
+    # br[8,i] = n_gflop / @belapsed ielogdettriangle($U)
+    # @assert ld ≈ ielogdettriangle(U) "i-eigen wrong?"; fill!(B, NaN);
     br[7,i] = n_gflop / @belapsed logdet($U)
 end
 function benchmark_logdettriangle(sizes)
+    # tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "g++ & Eigen-3", "clang++ & Eigen-3", "LinearAlgebra"]
     tests = ["LoopVectorization", "Julia", "Clang", "GFortran", "icc", "ifort", "LinearAlgebra"]
     br = BenchmarkResult(tests, sizes)
     sm = br.sizedresults.results

benchmark/driver.jl

@@ -2,7 +2,7 @@
 # const LOOPVECBENCHDIR = joinpath(pkgdir("LoopVectorization"), "benchmarks")
 # includet(joinpath(LOOPVECBENCHDIR, "driver.jl"))
 
-using Distributed, LoopVectorization
+using Distributed, LoopVectorization, JLD2
 
 const LOOPVECBENCHDIR = joinpath(pkgdir(LoopVectorization), "benchmark")
 include(joinpath(LOOPVECBENCHDIR, "benchmarkflops.jl"))
@@ -22,6 +22,9 @@ end
 # sizes = 23:23
 sizes = 256:-1:2
 
+logdettriangle_bench = benchmark_logdettriangle(sizes); println("logdet(LowerTriangular(A)) benchmark results:"); println(logdettriangle_bench)
+dot3_bench = benchmark_dot3(sizes); println("x' * A * y benchmark results:"); println(dot3_bench)
+
 AmulB_bench = benchmark_AmulB(sizes); println("A * B benchmark results:"); println(AmulB_bench)
 AmulBt_bench = benchmark_AmulBt(sizes); println("A * B' benchmark results:"); println(AmulBt_bench)
 AtmulBt_bench = benchmark_AtmulBt(sizes); println("A' * B' benchmark results:"); println(AtmulBt_bench)
@@ -34,15 +37,13 @@ filter2d_dynamic_bench = benchmark_filter2ddynamic(sizes); println("Benchmark re
 filter2d_3x3_bench = benchmark_filter2d3x3(sizes); println("Benchmark results for statically sized 3x3 convolution:"); println(filter2d_3x3_bench)
 filter2d_unrolled_bench = benchmark_filter2dunrolled(sizes); println("Benchmark results for unrolled 3x3 convolution:"); println(filter2d_unrolled_bench)
 
-dot3_bench = benchmark_dot3(sizes); println("x' * A * y benchmark results:"); println(dot3_bench)
 dot_bench = benchmark_dot(sizes); println("a' * b benchmark results:"); println(dot_bench)
 selfdot_bench = benchmark_selfdot(sizes); println("a' * a benchmark results:"); println(selfdot_bench)
 sse_bench = benchmark_sse(sizes); println("Benchmark resutls of summing squared error:"); println(sse_bench)
 aplusBc_bench = benchmark_aplusBc(sizes); println("Benchmark results of a .+ B .* c':"); println(aplusBc_bench)
 AplusAt_bench = benchmark_AplusAt(sizes); println("Benchmark results of A * A':"); println(AplusAt_bench)
 vexp_bench = benchmark_exp(sizes); println("Benchmark results of exponentiating a vector:"); println(vexp_bench)
 randomaccess_bench = benchmark_random_access(sizes); println("Benchmark results from using a vector of indices:"); println(randomaccess_bench)
-logdettriangle_bench = benchmark_logdettriangle(sizes); println("logdet(LowerTriangular(A)) benchmark results:"); println(logdettriangle_bench)
 
 const v = 1
 using Cairo, Fontconfig
@@ -68,3 +69,5 @@ saveplot("bench_AtmulBt_v", AtmulBt_bench);
 saveplot("bench_Amulvb_v", Amulvb_bench);
 saveplot("bench_Atmulvb_v", Atmulvb_bench);
 
+@save "benchmarkresults.jld2" logdettriangle_bench filter2d_dynamic_bench filter2d_3x3_bench filter2d_unrolled_bench dot_bench selfdot_bench dot3_bench sse_bench aplusBc_bench AplusAt_bench vexp_bench randomaccess_bench AmulB_bench AmulBt_bench AtmulB_bench AtmulBt_bench Amulvb_bench Atmulvb_bench
+

benchmark/loadsharedlibs.jl

@@ -35,11 +35,13 @@ end
 eigenfile = joinpath(LOOPVECBENCHDIR, "looptestseigen.cpp")
 if !isfile(LIBEIGENTEST) || mtime(eigenfile) > mtime(LIBEIGENTEST)
     # Clang seems to have trouble finding includes
-    run(`g++ -O3 -march=native -mprefer-vector-width=$(8REGISTER_SIZE) -I/usr/include/eigen3 -shared -fPIC $eigenfile -o $LIBEIGENTEST`)
-    # run(`clang++ -Ofast -march=native -mprefer-vector-width=$(8REGISTER_SIZE) -I/usr/include/c++/9 -I/usr/include/c++/9/x86_64-generic-linux -I/usr/include/eigen3 -shared -fPIC $eigenfile -o $LIBEIGENTEST`)
+    run(`g++ -O3 -march=native -mprefer-vector-width=$(8REGISTER_SIZE) -DEIGEN_VECTORIZE_AVX512 -I/usr/include/eigen3 -shared -fPIC $eigenfile -o $LIBEIGENTEST`)
+    
 end
 if !isfile(LIBIEIGENTEST) || mtime(eigenfile) > mtime(LIBIEIGENTEST)
-    run(`icpc -fast -qopt-zmm-usage=high -fargument-noalias-global -qoverride-limits -I/usr/include/eigen3 -shared -fPIC $eigenfile -o $LIBIEIGENTEST`)
+    # run(`/usr/bin/clang++ -Ofast -march=native -mprefer-vector-width=$(8REGISTER_SIZE) -DEIGEN_VECTORIZE_AVX512 -I/usr/include/c++/9 -I/usr/include/c++/9/x86_64-generic-linux -I/usr/include/eigen3 -shared -fPIC $eigenfile -o $LIBEIGENTEST`)
+    run(`/usr/bin/clang++ -Ofast -march=native -mprefer-vector-width=$(8REGISTER_SIZE) -DEIGEN_VECTORIZE_AVX512 -I/usr/include/eigen3 -shared -fPIC $eigenfile -o $LIBEIGENTEST`)
+    # run(`icpc -fast -qopt-zmm-usage=high -fargument-noalias-global -qoverride-limits -I/usr/include/eigen3 -shared -fPIC $eigenfile -o $LIBIEIGENTEST`)
 end
 
 MKL_ROOT = "/home/chriselrod/intel"
@@ -238,7 +240,7 @@ for (p,s) ∈ [(:c,Cshared) (:e,Eshared)]
     @eval function $(Symbol(prefix,p,:dot3))(x, A, y)
         M, N = size(A)
         ccall(
-            (:dot3v2, $s), Float64,
+            (:dot3, $s), Float64,
             (Ptr{Float64}, Ptr{Float64}, Ptr{Float64}, Clong, Clong),
             x, A, y, M, N
         )
@@ -247,7 +249,7 @@ end
     @eval function $(Symbol(prefix,:fdot3))(x, A, y)
         M, N = size(A)
         ccall(
-            (:dot3v2, $Fshared), Float64,
+            (:dot3, $Fshared), Float64,
             (Ptr{Float64}, Ptr{Float64}, Ptr{Float64}, Ref{Clong}, Ref{Clong}),
             x, A, y, Ref(M), Ref(N)
         )
@@ -382,16 +384,16 @@ end
             B, A, Ref(N)
         )
     end
-for (p,s) ∈ [(:c,Cshared) (:e,Eshared)]
-    @eval function $(Symbol(prefix,p,:AplusAt!))(B, A)
-        N = size(B,1)
-        ccall(
-            (:AplusAt, $s), Cvoid,
-            (Ptr{Float64}, Ptr{Float64}, Clong),
-            B, A, N
-        )
+    for (p,s) ∈ [(:c,Cshared) (:e,Eshared)]
+        @eval function $(Symbol(prefix,p,:AplusAt!))(B, A)
+            N = size(B,1)
+            ccall(
+                (:AplusAt, $s), Cvoid,
+                (Ptr{Float64}, Ptr{Float64}, Clong),
+                B, A, N
+            )
+        end
     end
-end
     @eval function $(Symbol(prefix,:crandomaccess))(P, basis, coefs)
         A, C = size(P)
         ccall(
@@ -408,14 +410,16 @@ end
             P, basis, coefs, Ref(A), Ref(C)
         )
     end
-    @eval function $(Symbol(prefix,:clogdettriangle))(T::Union{LowerTriangular,UpperTriangular})
-        N = size(T,1)
-        Tp = parent(T)
-        ccall(
-            (:logdettriangle, $Cshared), Float64,
-            (Ptr{Float64}, Clong),
-            Tp, N
-        )
+    for (p,s) ∈ [(:c,Cshared) (:e,Eshared)]
+        @eval function $(Symbol(prefix,p,:logdettriangle))(T::Union{LowerTriangular,UpperTriangular})
+            N = size(T,1)
+            Tp = parent(T)
+            ccall(
+                (:logdettriangle, $s), Float64,
+                (Ptr{Float64}, Clong),
+                Tp, N
+            )
+        end
     end
     @eval function $(Symbol(prefix,:flogdettriangle))(T::Union{LowerTriangular,UpperTriangular})
         N = size(T,1)

benchmark/looptests.c

@@ -131,7 +131,7 @@ double selfdot(double* restrict a, long N){
   }
   return s;
 }
-double dot3(double* restrict x, double* restrict A, double* restrict y, long M, long N){
+double dot3v2(double* restrict x, double* restrict A, double* restrict y, long M, long N){
   double s = 0.0;
   for (long n = 0; n < N; n++){
     for (long m = 0; m < M; m++){
@@ -140,7 +140,7 @@ double dot3(double* restrict x, double* restrict A, double* restrict y, long M,
   }
   return s;
 }
-double dot3v2(double* restrict x, double* restrict A, double* restrict y, long M, long N){
+double dot3(double* restrict x, double* restrict A, double* restrict y, long M, long N){
   double s = 0.0;
   for (long n = 0; n < N; n++){
     double t = 0.0;

benchmark/looptests.f90

@@ -151,30 +151,30 @@ real(C_double) function selfdot(a, N) BIND(C, name="selfdot")
          selfdot = selfdot + a(i) * a(i)
       end do
     end function selfdot
-    real(C_double) function dot3(x, A, y, M, N) BIND(C, name="dot3")
+    real(C_double) function dot3v2(x, A, y, M, N) BIND(C, name="dot3v2")
       integer(C_long), intent(in) :: M, N
       real(C_double), intent(in) :: x(M), A(M,N), y(N)
       real(C_double) :: t
       integer(C_long) :: mm, nn
-      dot3 = 0.0d0
+      dot3v2 = 0.0d0
       do concurrent(nn = 1:N, mm = 1:M)
-         dot3 = dot3 + x(mm) * A(mm, nn) * y(nn)
+         dot3v2 = dot3v2 + x(mm) * A(mm, nn) * y(nn)
       end do
-    end function dot3
-    real(C_double) function dot3v2(x, A, y, M, N) BIND(C, name="dot3v2")
+    end function dot3v2
+    real(C_double) function dot3(x, A, y, M, N) BIND(C, name="dot3")
       integer(C_long), intent(in) :: M, N
       real(C_double), intent(in) :: x(M), A(M,N), y(N)
       real(C_double) :: t
       integer(C_long) :: mm, nn
-      dot3v2 = 0.0d0
+      dot3 = 0.0d0
       do concurrent(nn = 1:N)
          t = 0.0d0
          do concurrent(mm = 1:M)
             t = t + x(mm) * A(mm, nn)
          end do
-         dot3v2 = dot3v2 + t * y(nn)
+         dot3 = dot3 + t * y(nn)
       end do
-    end function dot3v2
+    end function dot3
     real(C_double) function dot3builtin(x, A, y, M, N) BIND(C, name="dot3builtin")
       integer(C_long), intent(in) :: M, N
       real(C_double), intent(in) :: x(M), A(M,N), y(N)

benchmark/looptests.jl

@@ -99,23 +99,23 @@ function jselfdotavx(a)
     end
     s
 end
-function jdot3(x, A, y)
+function jdot3v2(x, A, y)
     M, N = size(A)
     s = zero(promote_type(eltype(x), eltype(A), eltype(y)))
     @inbounds @fastmath for n ∈ 1:N, m ∈ 1:M
         s += x[m] * A[m,n] * y[n]
     end
     s
 end
-function jdot3avx(x, A, y)
+function jdot3v2avx(x, A, y)
     M, N = size(A)
     s = zero(promote_type(eltype(x), eltype(A), eltype(y)))
     @avx for n ∈ 1:N, m ∈ 1:M
         s += x[m] * A[m,n] * y[n]
     end
     s
 end
-function jdot3v2(x, A, y)
+function jdot3(x, A, y)
     s = zero(promote_type(eltype(x), eltype(A), eltype(y)))
     @inbounds @fastmath for n ∈ axes(A,2)
         t = zero(s)
@@ -126,7 +126,7 @@ function jdot3v2(x, A, y)
     end
     s
 end
-function jdot3v2avx(x, A, y)
+function jdot3avx(x, A, y)
     s = zero(promote_type(eltype(x), eltype(A), eltype(y)))
     @avx for n ∈ axes(A,2)
         t = zero(s)

benchmark/looptestseigen.cpp

@@ -15,6 +15,7 @@ extern "C" {
   void aplusBc(double*, double*, double*, double*, long, long);
   double OLSlp(double*, double*, double*, long, long);
   void AplusAt(double*, double*, long);
+  double logdettriangle(double*, long);
 }
 
 typedef Map<MatrixXd> mMatrix;
@@ -108,3 +109,8 @@ void AplusAt(double* pB, double* pA, long N){
   return;
 }
 
+// double logdettriangle(double* pA, long N){
+//   mMatrix A(pA, N, N);
+//   return log(A.diagonal()).sum();
+// }
+