blis/docs/Performance.md

Contents

• Contents
• Introduction
• General information
• Level-3 performance
  • ThunderX2
    • Experiment Details
    • Results
  • SkylakeX
    • Experiment Details
    • Results
  • Haswell
    • Experiment Details
    • Desults
  • Epyc
    • Experiment Details
    • Results
• Feedback

Introduction

This document showcases performance results for a representative sample of level-3 operations with BLIS and BLAS for several hardware architectures.

General information

Generally speaking, we publish three "panels" for each type of hardware, each of which reports one of: single-threaded performance, multithreaded performance on a single socket, or multithreaded performance on two sockets. Each panel will consist of a 4x5 grid of graphs, with each row representing a different datatype (single real, double real, single complex, and double complex) and each column representing a different operation (gemm, hemm/symm, herk/syrk, trmm, and trsm). Each of the 20 graphs within a panel will contain an x-axis that reports problem size, with all matrix dimensions equal to the problem size (e.g. m = n = k), resulting in square matrices. The y-axis will report GFLOPS (in the case of single-threaded performance) or GFLOPS/core (in the case of single- or dual-socket multithreaded performance), which is simply the total GFLOPS divided by the number of threads utilized. This normalization is done intentionally in order to facilitate visual comparison of multithreaded graphs and single-threaded graphs.

It's also worth pointing out that the top of each graph (e.g. the maximum y-axis value depicted) always corresponds to the theoretical peak performance under the conditions associated with that graph. Theoretical peak performance, in units of GFLOPS/core, is calculated as the product of:

1. the maximum sustainable clock rate in GHz; and
2. the maximum number of floating-point operations (flops) that can be executed per cycle.

Note that the maximum sustainable clock rate may change depending on the conditions. For example, on some systems the maximum clock rate is higher when only one core is active (e.g. single-threaded performance) versus when all cores are active (e.g. multithreaded performance). The maximum number of flops executable per cycle is generally computed as the product of:

1. the maximum number of fused multiply-add (FMA) vector instructions that can be issued per cycle;
2. the maximum number of elements that can be stored within a single vector register (for the datatype in question); and
3. 2.0, since an FMA instruction fuses two operations (a multiply and an add).

The problem size range, represented on the x-axis, is usually sampled with 50 equally-spaced problem size. For example, for single-threaded execution, we might choose to execute with problem sizes of 48 to 2400 in increments of 48, or 56 to 2800 in increments of 56. These values are almost never chosen for any particular (read: sneaky) reason; rather, we start with a "good" maximum problem size, such as 2400 or 2800, and then divide it by 50 to obtain the appropriate starting point and increment.

Finally, each point along each curve represents the best of three trials.

Interpretation

In general, the the curves associated with higher-performing implementations will appear higher in the graphs than lower-performing implementations. Ideally, an implementation will climb in performance (as a function of problem size) as quickly as possible and asymptotically approach some high fraction of peak performance.

Occasionally, we may publish graphs with incomplete curves--for example, only the first 25 data points in a typical 50-point series--usually because the implementation being tested was slow enough that it was not practical to allow it to finish.

Where along the x-axis you focus your attention will depend on the segment of the problem size range that you care about most. Some people's applications depend heavily on smaller problems, where "small" can mean anything from 200 to 1000 or even higher. Some people consider 1000 to be quite large, while others insist that 5000 is merely "medium." What each of us considers to be small, medium, or large (naturally) depends heavily on the kinds of dense linear algebra problems we tend to encounter. No one is "right" or "wrong" about their characterization of matrix smallness or bigness since each person's relative frame of reference can vary greatly. That said, the Science of High-Performance Computing group at The University of Texas at Austin tends to target matrices that it classifies as "medium-to-large", and so most of the graphs presented in this document will reflect that targeting in their x-axis range.

When corresponding with us, via email or when opening an issue on github, we kindly ask that you specify as closely as possible (though a range is fine) your problem size of interest so that we can better assist you.

Level-3 performance results

ThunderX2

ThunderX2 experiment details

• Location: Unknown
• Processor model: Marvell ThunderX2 CN9975
• Core topology: two sockets, 28 cores per socket, 56 cores total
• SMT status: disabled at boot-time
• Max clock rate: 2.2GHz (single-core and multicore)
• Max vector register length: 128 bits (NEON)
• Max FMA vector IPC: 2
• Peak performance:
  • single-core: 17.6 GFLOPS (double-precision), 35.2 GFLOPS (single-precision)
  • multicore: 17.6 GFLOPS/core (double-precision), 35.2 GFLOPS/core (single-precision)
• Operating system: Ubuntu 16.04 (Linux kernel 4.15.0)
• Compiler: gcc 7.3.0
• Results gathered: 14 February 2019
• Implementations tested:
  • BLIS 075143df (0.5.1-39)
    • configured with ./configure -t openmp thunderx2 (single- and multithreaded)
    • sub-configuration exercised: thunderx2
  • OpenBLAS 52d3f7a
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=0 (single-threaded)
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=1 NUM_THREADS=56 (multithreaded)
  • ARMPL 18.4
• Affinity:
  • Thread affinity for BLIS was specified manually via GOMP_CPU_AFFINITY="0 1 2 3 ... 55". However, multithreaded OpenBLAS appears to revert to single-threaded execution if GOMP_CPU_AFFINITY is set. Therefore, when measuring OpenBLAS performance, the GOMP_CPU_AFFINITY was unset.
• Frequency throttling (via cpupower):
  • No changes made.
• Comments:
  • ARMPL performance is remarkably uneven across datatypes and operations, though it would appear their "base" consists of OpenBLAS, which they then optimize for select, targeted routines. Unfortunately, we were unable to test the absolute latest versions of OpenBLAS and ARMPL on this hardware before we lost access. We will rerun these experiments once we gain access to a similar system.

ThunderX2 results

pdf

• ThunderX2 single-threaded
• ThunderX2 multithreaded (32 cores)
• ThunderX2 multithreaded (64 cores)

png (inline)

• ThunderX2 single-threaded
• ThunderX2 multithreaded (32 cores)
• ThunderX2 multithreaded (64 cores)

---

SkylakeX

SkylakeX experiment details

• Location: Oracle cloud
• Processor model: Intel Xeon Platinum 8167M (SkylakeX/AVX-512)
• Core topology: two sockets, 26 cores per socket, 52 cores total
• SMT status: enabled, but not utilized
• Max clock rate: 2.0GHz (single-core and multicore)
• Max vector register length: 512 bits (AVX-512)
• Max FMA vector IPC: 2
• Peak performance:
  • single-core: 64 GFLOPS (double-precision), 128 GFLOPS (single-precision)
  • multicore: 64 GFLOPS/core (double-precision), 128 GFLOPS/core (single-precision)
• Operating system: Ubuntu 18.04 (Linux kernel 4.15.0)
• Compiler: gcc 7.3.0
• Results gathered: 6 March 2019
• Implementations tested:
  • BLIS 9f1dbe5 (0.5.1-54)
    • configured with ./configure -t openmp auto (single- and multithreaded)
    • sub-configuration exercised: skx
  • OpenBLAS 0.3.5
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=0 (single-threaded)
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=1 NUM_THREADS=52 (multithreaded)
  • MKL 2019 update 1
• Affinity:
  • Thread affinity for BLIS was specified manually via GOMP_CPU_AFFINITY="0 1 2 3 ... 51". However, multithreaded OpenBLAS appears to revert to single-threaded execution if GOMP_CPU_AFFINITY is set. Therefore, when measuring OpenBLAS performance, the GOMP_CPU_AFFINITY was unset.
• Frequency throttling (via cpupower):
  • No changes made.
• Comments:
  • MKL yields superb performance for most operations, though BLIS is not far behind except for trsm. (We understand the trsm underperformance and hope to address it in the future.) OpenBLAS lags far behind MKL and BLIS due to lack of full support for AVX-512, and possibly other reasons related to software architecture and register/cache blocksizes.

SkylakeX results

pdf

• SkylakeX single-threaded
• SkylakeX multithreaded (32 cores)
• SkylakeX multithreaded (64 cores)

png (inline)

• SkylakeX single-threaded
• SkylakeX multithreaded (26 cores)
• SkylakeX multithreaded (52 cores)

---

Haswell

Haswell experiment details

• Location: TACC (Lonestar5)
• Processor model: Intel Xeon E5-2690 v3 (Haswell)
• Core topology: two sockets, 12 cores per socket, 24 cores total
• SMT status: enabled, but not utilized
• Max clock rate: 3.5GHz (single-core), 3.1GHz (multicore)
• Max vector register length: 256 bits (AVX2)
• Max FMA vector IPC: 2
• Peak performance:
  • single-core: 56 GFLOPS (double-precision), 112 GFLOPS (single-precision)
  • multicore: 49.6 GFLOPS/core (double-precision), 99.2 GFLOPS/core (single-precision)
• Operating system: Cray Linux Environment 6 (Linux kernel 4.4.103)
• Compiler: gcc 6.3.0
• Results gathered: 25-26 February 2019
• Implementations tested:
  • BLIS 075143df (0.5.1-39)
    • configured with ./configure -t openmp auto (single- and multithreaded)
    • sub-configuration exercised: haswell
  • OpenBLAS 0.3.5
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=0 (single-threaded)
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=1 NUM_THREADS=24 (multithreaded)
  • MKL 2018 update 2
• Affinity:
  • Thread affinity for BLIS was specified manually via GOMP_CPU_AFFINITY="0 1 2 3 ... 23". However, multithreaded OpenBLAS appears to revert to single-threaded execution if GOMP_CPU_AFFINITY is set. Therefore, when measuring OpenBLAS performance, the GOMP_CPU_AFFINITY was unset.
• Frequency throttling (via cpupower):
  • No changes made.
• Comments:
  • We were pleasantly surprised by how competitive BLIS performs relative to MKL on this multicore Haswell system, which is a very common microarchitecture, and very similar to the more recent Broadwells, Skylakes (desktop), Kaby Lakes, and Coffee Lakes that succeeded it.

Haswell results

pdf

• Haswell single-threaded
• Haswell multithreaded (32 cores)
• Haswell multithreaded (64 cores)

png (inline)

• Haswell single-threaded
• Haswell multithreaded (12 cores)
• Haswell multithreaded (24 cores)

---

Epyc

Epyc experiment details

• Location: Oracle cloud
• Processor model: AMD Epyc 7551 (Zen1)
• Core topology: two sockets, 4 dies per socket, 2 core complexes (CCX) per die, 4 cores per CCX, 64 cores total
• SMT status: enabled, but not utilized
• Max clock rate: 3.0GHz (single-core), 2.55GHz (multicore)
• Max vector register length: 256 bits (AVX2)
• Max FMA vector IPC: 1
  • Alternatively, FMA vector IPC is 2 when vectors are limited to 128 bits each.
• Peak performance:
  • single-core: 24 GFLOPS (double-precision), 48 GFLOPS (single-precision)
  • multicore: 20.4 GFLOPS/core (double-precision), 40.8 GFLOPS/core (single-precision)
• Operating system: Ubuntu 18.04 (Linux kernel 4.15.0)
• Compiler: gcc 7.3.0
• Results gathered: 6 March 2019, 19 March 2019
• Implementations tested:
  • BLIS 9f1dbe5 (0.5.1-54)
    • configured with ./configure -t openmp auto (single- and multithreaded)
    • sub-configuration exercised: zen
  • OpenBLAS 0.3.5
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=0 (single-threaded)
    • configured with BINARY=64 NO_CBLAS=1 NO_LAPACK=1 NO_LAPACKE=1 USE_THREAD=1 NUM_THREADS=64 (multithreaded)
  • MKL 2019 update 1
• Affinity:
  • Thread affinity for BLIS was specified manually via GOMP_CPU_AFFINITY="0 1 2 3 ... 63". However, multithreaded OpenBLAS appears to revert to single-threaded execution if GOMP_CPU_AFFINITY is set. Therefore, when measuring OpenBLAS performance, the GOMP_CPU_AFFINITY was unset.
• Frequency throttling (via cpupower):
  • Driver: acpi-cpufreq
  • Governor: performance
  • Hardware limits: 1.2GHz - 2.0GHz
  • Adjusted minimum: 2.0GHz
• Comments:
  • MKL performance is dismal, despite being linked in the same manner as on the Xeon Platinum. It's not clear what is causing the slowdown. It could be that MKL's runtime kernel/blocksize selection logic is falling back to some older, more basic implementation because CPUID is not returning Intel as the hardware vendor. Alternatively, it's possible that MKL is trying to use kernels for the closest Intel architectures--say, Haswell/Broadwell--but its implementations use Haswell-specific optimizations that, due to microarchitectural differences, degrade performance on Zen.

Epyc results

pdf

• Epyc single-threaded
• Epyc multithreaded (32 cores)
• Epyc multithreaded (64 cores)

png (inline)

• Epyc single-threaded
• Epyc multithreaded (32 cores)
• Epyc multithreaded (64 cores)

---

Feedback

Please let us know what you think of these performance results! Similarly, if you have any questions or concerns, or are interested in reproducing these performance experiments on your own hardware, we invite you to open an issue and start a conversation with BLIS developers.

Thanks for your interest in BLIS!