Stable release | 3.8.0
/ 12 November 2017 |
---|---|

Written in | depends on implementation |

Platform | Cross-platform |

Type | Library |

Website | www |

**Basic Linear Algebra Subprograms** (**BLAS**) is a specification that prescribes a set of low-level routines for performing common linear algebra operations such as vector addition, scalar multiplication, dot products, linear combinations, and matrix multiplication. They are the *de facto* standard low-level routines for linear algebra libraries; the routines have bindings for both C ("CBLAS interface") and Fortran ("BLAS interface"). Although the BLAS specification is general, BLAS implementations are often optimized for speed on a particular machine, so using them can bring substantial performance benefits. BLAS implementations will take advantage of special floating point hardware such as vector registers or SIMD instructions.

It originated as a Fortran library in 1979^{[1]} and its interface was standardized by the BLAS Technical (BLAST) Forum, whose latest BLAS report can be found on the netlib website.^{[2]} This Fortran library is known as the *reference implementation* (sometimes confusingly referred to as *the* BLAS library) and is not optimized for speed but is in the public domain.^{[3]}^{[4]}

Most computing libraries that offer linear algebra routines conform to common BLAS user interface command structures, thus queries to those libraries (and the associated results) are often portable between BLAS library branches, such as cuBLAS (nvidia GPU, GPGPU), rocBLAS (amd GPU, GPGP), and OpenBLAS. This interoperability is then the basis of functioning homogenous code implementations between heterzygous cascades of computing architectures (such as those found in some advanced clustering implementations). Examples of CPU-based BLAS library branches include: OpenBLAS, BLIS (BLAS-like Library Instantiation Software), Arm Performance Libraries,^{[5]} ATLAS, and Intel Math Kernel Library (iMKL). AMD maintains a fork of BLIS that is optimized for the AMD platform, although it is unclear whether integrated ombudsmen resources are present in that particular software-hardware implementation.^{[6]} ATLAS is a portable library that automatically optimizes itself for an arbitrary architecture. iMKL is a freeware^{[7]} and proprietary^{[8]} vendor library optimized for x86 and x86-64 with a performance emphasis on Intel processors.^{[9]} OpenBLAS is an open-source library that is hand-optimized for many of the popular architectures. The LINPACK benchmarks rely heavily on the BLAS routine `gemm`

for its performance measurements.

Many numerical software applications use BLAS-compatible libraries to do linear algebra computations, including LAPACK, LINPACK, Armadillo, GNU Octave, Mathematica,^{[10]} MATLAB,^{[11]} NumPy,^{[12]} R, and Julia.

With the advent of numerical programming, sophisticated subroutine libraries became useful. These libraries would contain subroutines for common high-level mathematical operations such as root finding, matrix inversion, and solving systems of equations. The language of choice was FORTRAN. The most prominent numerical programming library was IBM's Scientific Subroutine Package (SSP).^{[13]} These subroutine libraries allowed programmers to concentrate on their specific problems and avoid re-implementing well-known algorithms. The library routines would also be better than average implementations; matrix algorithms, for example, might use full pivoting to get better numerical accuracy. The library routines would also have more efficient routines. For example, a library may include a program to solve a matrix that is upper triangular. The libraries would include single-precision and double-precision versions of some algorithms.

Initially, these subroutines used hard-coded loops for their low-level operations. For example, if a subroutine needed to perform a matrix multiplication, then the subroutine would have three nested loops. Linear algebra programs have many common low-level operations (the so-called "kernel" operations, not related to operating systems).^{[14]} Between 1973 and 1977, several of these kernel operations were identified.^{[15]} These kernel operations became defined subroutines that math libraries could call. The kernel calls had advantages over hard-coded loops: the library routine would be more readable, there were fewer chances for bugs, and the kernel implementation could be optimized for speed. A specification for these kernel operations using scalars and vectors, the level-1 Basic Linear Algebra Subroutines (BLAS), was published in 1979.^{[16]} BLAS was used to implement the linear algebra subroutine library LINPACK.

The BLAS abstraction allows customization for high performance. For example, LINPACK is a general purpose library that can be used on many different machines without modification. LINPACK could use a generic version of BLAS. To gain performance, different machines might use tailored versions of BLAS. As computer architectures became more sophisticated, vector machines appeared. BLAS for a vector machine could use the machine's fast vector operations. (While vector processors eventually fell out of favor, vector instructions in modern CPUs are essential for optimal performance in BLAS routines.)

Other machine features became available and could also be exploited. Consequently, BLAS was augmented from 1984 to 1986 with level-2 kernel operations that concerned vector-matrix operations. Memory hierarchy was also recognized as something to exploit. Many computers have cache memory that is much faster than main memory; keeping matrix manipulations localized allows better usage of the cache. In 1987 and 1988, the level 3 BLAS were identified to do matrix-matrix operations. The level 3 BLAS encouraged block-partitioned algorithms. The LAPACK library uses level 3 BLAS.^{[17]}

The original BLAS concerned only densely stored vectors and matrices. Further extensions to BLAS, such as for sparse matrices, have been addressed.^{[18]}

BLAS functionality is categorized into three sets of routines called "levels", which correspond to both the chronological order of definition and publication, as well as the degree of the polynomial in the complexities of algorithms; Level 1 BLAS operations typically take linear time, *O*(*n*), Level 2 operations quadratic time and Level 3 operations cubic time.^{[19]} Modern BLAS implementations typically provide all three levels.

This level consists of all the routines described in the original presentation of BLAS (1979),^{[1]} which defined only *vector operations* on strided arrays: dot products, vector norms, a generalized vector addition of the form

(called "`axpy`

", "a x plus y") and several other operations.

This level contains *matrix-vector operations* including, among other things, a *ge*neralized *m*atrix-*v*ector multiplication (`gemv`

):

as well as a solver for * x* in the linear equation

with * T* being triangular. Design of the Level 2 BLAS started in 1984, with results published in 1988.

This level, formally published in 1990,^{[19]} contains *matrix-matrix operations*, including a "general matrix multiplication" (`gemm`

), of the form

where * A* and

Also included in Level 3 are routines for computing

where * T* is a triangular matrix, among other functionality.

Due to the ubiquity of matrix multiplications in many scientific applications, including for the implementation of the rest of Level 3 BLAS,^{[21]} and because faster algorithms exist beyond the obvious repetition of matrix-vector multiplication, `gemm`

is a prime target of optimization for BLAS implementers. E.g., by decomposing one or both of * A*,

`gemm`

can be implemented recursively. This is one of the motivations for including the A common variation of `gemm`

is the `gemm3m`

, which calculates a complex product using "three real matrix multiplications and five real matrix additions instead of the conventional four real matrix multiplications and two real matrix additions", an algorithm similar to Strassen algorithm first described by Peter Ungar.^{[24]}

- Accelerate
- Apple's framework for macOS and iOS, which includes tuned versions of BLAS and LAPACK.
^{[25]}^{[26]} - Arm Performance Libraries
- Arm Performance Libraries, supporting Arm 64-bit AArch64-based processors, available from Arm.
^{[5]} - ATLAS
- Automatically Tuned Linear Algebra Software, an open source implementation of BLAS APIs for C and Fortran 77.
^{[27]} - BLIS
- BLAS-like Library Instantiation Software framework for rapid instantiation. Optimized for most modern CPUs. BLIS is a complete refactoring of the GotoBLAS that reduces the amount of code that must be written for a given platform.
^{[28]}^{[29]} - C++ AMP BLAS
- The C++ AMP BLAS Library is an open source implementation of BLAS for Microsoft's AMP language extension for Visual C++.
^{[30]} - cuBLAS
- Optimized BLAS for NVIDIA based GPU cards, requiring few additional library calls.
^{[31]} - NVBLAS
- Optimized BLAS for NVIDIA based GPU cards, providing only Level 3 functions, but as direct drop-in replacement for other BLAS libraries.
^{[32]} - clBLAS
- An OpenCL implementation of BLAS by AMD. Part of the AMD Compute Libraries.
^{[33]} - clBLAST
- A tuned OpenCL implementation of most of the BLAS api.
^{[34]} - Eigen BLAS
- A Fortran 77 and C BLAS library implemented on top of the MPL-licensed Eigen library, supporting x86, x86-64, ARM (NEON), and PowerPC architectures.
- ESSL
- IBM's Engineering and Scientific Subroutine Library, supporting the PowerPC architecture under AIX and Linux.
^{[35]} - GotoBLAS
- Kazushige Goto's BSD-licensed implementation of BLAS, tuned in particular for Intel Nehalem/Atom, VIA Nanoprocessor, AMD Opteron.
^{[36]} - GNU Scientific Library
- Multi-platform implementation of many numerical routines. Contains a CBLAS interface.
- HP MLIB
- HP's Math library supporting IA-64, PA-RISC, x86 and Opteron architecture under HP-UX and Linux.
- Intel MKL
- The Intel Math Kernel Library, supporting x86 32-bits and 64-bits, available free from Intel.
^{[7]}Includes optimizations for Intel Pentium, Core and Intel Xeon CPUs and Intel Xeon Phi; support for Linux, Windows and macOS.^{[37]} - MathKeisan
- NEC's math library, supporting NEC SX architecture under SUPER-UX, and Itanium under Linux
^{[38]} - Netlib BLAS
- The official reference implementation on Netlib, written in Fortran 77.
^{[39]} - Netlib CBLAS
- Reference C interface to the BLAS. It is also possible (and popular) to call the Fortran BLAS from C.
^{[40]} - OpenBLAS
- Optimized BLAS based on GotoBLAS, supporting x86, x86-64, MIPS and ARM processors.
^{[41]} - PDLIB/SX
- NEC's Public Domain Mathematical Library for the NEC SX-4 system.
^{[42]} - rocBLAS
- Implementation that runs on AMD GPUs via ROCm.
^{[43]} - SCSL
- SGI's Scientific Computing Software Library contains BLAS and LAPACK implementations for SGI's Irix workstations.
^{[44]} - Sun Performance Library
- Optimized BLAS and LAPACK for SPARC, Core and AMD64 architectures under Solaris 8, 9, and 10 as well as Linux.
^{[45]} - uBLAS
- A generic C++ template class library providing BLAS functionality. Part of the Boost library. It provides bindings to many hardware-accelerated libraries in a unifying notation. Moreover, uBLAS focuses on correctness of the algorithms using advanced C++ features.
^{[46]}

- Armadillo
- Armadillo is a C++ linear algebra library aiming towards a good balance between speed and ease of use. It employs template classes, and has optional links to BLAS/ATLAS and LAPACK. It is sponsored by NICTA (in Australia) and is licensed under a free license.
^{[47]} - LAPACK
- LAPACK is a higher level Linear Algebra library built upon BLAS. Like BLAS, a reference implementation exists, but many alternatives like libFlame and MKL exist.
- Mir
- An LLVM-accelerated generic numerical library for science and machine learning written in D. It provides generic linear algebra subprograms (GLAS). It can be built on a CBLAS implementation.
^{[48]}

See also: LAPACK § Similar projects |

- Elemental
- Elemental is an open source software for distributed-memory dense and sparse-direct linear algebra and optimization.
^{[49]} - HASEM
- is a C++ template library, being able to solve linear equations and to compute eigenvalues. It is licensed under BSD License.
^{[50]} - LAMA
- The Library for Accelerated Math Applications (LAMA) is a C++ template library for writing numerical solvers targeting various kinds of hardware (e.g. GPUs through CUDA or OpenCL) on distributed memory systems, hiding the hardware specific programming from the program developer
- MTL4
- The Matrix Template Library version 4 is a generic C++ template library providing sparse and dense BLAS functionality. MTL4 establishes an intuitive interface (similar to MATLAB) and broad applicability thanks to generic programming.

Several extensions to BLAS for handling sparse matrices have been suggested over the course of the library's history; a small set of sparse matrix kernel routines was finally standardized in 2002.^{[51]}

The traditional BLAS functions have been also ported to architectures that support large amounts of parallelism such as GPUs. Here, the traditional BLAS functions provide typically good performance for large matrices. However, when computing e.g., matrix-matrix-products of many small matrices by using the GEMM routine, those architectures show significant performance losses. To address this issue, in 2017 a batched version of the BLAS function has been specified.^{[52]}

Taking the GEMM routine from above as an example, the batched version performs the following computation simultaneously for many matrices:

The index in square brackets indicates that the operation is performed for all matrices in a stack. Often, this operation is implemented for a strided batched memory layout where all matrices follow concatenated in the arrays , and .

Batched BLAS functions can be a versatile tool and allow e.g. a fast implementation of exponential integrators and Magnus integrators that handle long integration periods with many time steps.^{[53]} Here, the matrix exponentiation, the computationally expensive part of the integration, can be implemented in parallel for all time-steps by using Batched BLAS functions.