OpenBLAS is an optimized BLAS (Basic Linear Algebra Subprograms) library based on GotoBLAS2 1.13 BSD version.
Please read the documentation on the OpenBLAS wiki pages: https://github.com/xianyi/OpenBLAS/wiki.
For a general introduction to the BLAS routines, please refer to the extensive documentation of their reference implementation hosted at netlib: https://www.netlib.org/blas. On that site you will likewise find documentation for the reference implementation of the higher-level library LAPACK - the Linear Algebra Package that comes included with OpenBLAS. If you are looking for a general primer or refresher on Linear Algebra, the set of six 20-minute lecture videos by Prof. Gilbert Strang on either MIT OpenCourseWare https://ocw.mit.edu/resources/res-18-010-a-2020-vision-of-linear-algebra-spring-2020/ or Youtube https://www.youtube.com/playlist?list=PLUl4u3cNGP61iQEFiWLE21EJCxwmWvvek may be helpful.
We provide official binary packages for the following platform:
You can download them from file hosting on sourceforge.net or from the Releases section of the github project page, https://github.com/xianyi/OpenBLAS/releases.
Download from project homepage, https://xianyi.github.com/OpenBLAS/, or check out the code using Git from https://github.com/xianyi/OpenBLAS.git. (If you want the most up to date version, be sure to use the develop branch - master is several years out of date due to a change of maintainership.) Buildtime parameters can be chosen in Makefile.rule, see there for a short description of each option. Most can also be given directly on the make or cmake command line.
Building OpenBLAS requires the following to be installed:
Simply invoking make
(or gmake
on BSD) will detect the CPU automatically.
To set a specific target CPU, use make TARGET=xxx
, e.g. make TARGET=NEHALEM
.
The full target list is in the file TargetList.txt
. For building with cmake
, the
usual conventions apply, i.e. create a build directory either underneath the toplevel
OpenBLAS source directory or separate from it, and invoke cmake
there with the path
to the source tree and any build options you plan to set.
Set CC
and FC
to point to the cross toolchains, and set HOSTCC
to your host C compiler.
The target must be specified explicitly when cross compiling.
Examples:
On an x86 box, compile this library for a loongson3a CPU:
make BINARY=64 CC=mips64el-unknown-linux-gnu-gcc FC=mips64el-unknown-linux-gnu-gfortran HOSTCC=gcc TARGET=LOONGSON3A
or same with the newer mips-crosscompiler put out by Loongson that defaults to the 32bit ABI:
make HOSTCC=gcc CC='/opt/mips-loongson-gcc7.3-linux-gnu/2019.06-29/bin/mips-linux-gnu-gcc -mabi=64' FC='/opt/mips-loongson-gcc7.3-linux-gnu/2019.06-29/bin/mips-linux-gnu-gfortran -mabi=64' TARGET=LOONGSON3A
On an x86 box, compile this library for a loongson3a CPU with loongcc (based on Open64) compiler:
make CC=loongcc FC=loongf95 HOSTCC=gcc TARGET=LOONGSON3A CROSS=1 CROSS_SUFFIX=mips64el-st-linux-gnu- NO_LAPACKE=1 NO_SHARED=1 BINARY=32
A debug version can be built using make DEBUG=1
.
The IBM MASS library consists of a set of mathematical functions for C, C++, and Fortran applications that are tuned for optimum performance on POWER architectures. OpenBLAS with MASS requires a 64-bit, little-endian OS on POWER. The library can be installed as shown:
On Ubuntu:
wget -q http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/ubuntu/public.gpg -O- | sudo apt-key add -
echo "deb http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/ubuntu/ trusty main" | sudo tee /etc/apt/sources.list.d/ibm-xl-compiler-eval.list
sudo apt-get update
sudo apt-get install libxlmass-devel.8.1.5
On RHEL/CentOS:
wget http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/rhel7/repodata/repomd.xml.key
sudo rpm --import repomd.xml.key
wget http://public.dhe.ibm.com/software/server/POWER/Linux/xl-compiler/eval/ppc64le/rhel7/ibm-xl-compiler-eval.repo
sudo cp ibm-xl-compiler-eval.repo /etc/yum.repos.d/
sudo yum install libxlmass-devel.8.1.5
After installing the MASS library, compile OpenBLAS with USE_MASS=1
.
For example, to compile on Power8 with MASS support: make USE_MASS=1 TARGET=POWER8
.
Use PREFIX=
when invoking make
, for example
make install PREFIX=your_installation_directory
The default installation directory is /opt/OpenBLAS
.
Please read GotoBLAS_01Readme.txt
for older CPU models already supported by the 2010 GotoBLAS.
USE_OPENMP=1
make HOSTCC=gcc TARGET=C910V CC=riscv64-unknown-linux-gnu-gcc FC=riscv64-unknown-linux-gnu-gfortran
OpenBLAS can be built for multiple targets with runtime detection of the target cpu by specifiying DYNAMIC_ARCH=1
in Makefile.rule, on the gmake command line or as -DDYNAMIC_ARCH=TRUE
in cmake.
For x86_64, the list of targets this activates contains Prescott, Core2, Nehalem, Barcelona, Sandybridge, Bulldozer, Piledriver, Steamroller, Excavator, Haswell, Zen, SkylakeX. For cpu generations not included in this list, the corresponding older model is used. If you also specify DYNAMIC_OLDER=1
, specific support for Penryn, Dunnington, Opteron, Opteron/SSE3, Bobcat, Atom and Nano is added. Finally there is an option DYNAMIC_LIST
that allows to specify an individual list of targets to include instead of the default.
DYNAMIC_ARCH
is also supported on x86, where it translates to Katmai, Coppermine, Northwood, Prescott, Banias,
Core2, Penryn, Dunnington, Nehalem, Athlon, Opteron, Opteron_SSE3, Barcelona, Bobcat, Atom and Nano.
On ARMV8, it enables support for CortexA53, CortexA57, CortexA72, CortexA73, Falkor, ThunderX, ThunderX2T99, TSV110 as well as generic ARMV8 cpus.
For POWER, the list encompasses POWER6, POWER8 and POWER9, on ZARCH it comprises Z13 and Z14.
The TARGET
option can be used in conjunction with DYNAMIC_ARCH=1
to specify which cpu model should be assumed for all the
common code in the library, usually you will want to set this to the oldest model you expect to encounter.
Please note that it is not possible to combine support for different architectures, so no combined 32 and 64 bit or x86_64 and arm64 in the same library.
Statically link with libopenblas.a
or dynamically link with -lopenblas
if OpenBLAS was
compiled as a shared library.
Environment variables are used to specify a maximum number of threads. For example,
export OPENBLAS_NUM_THREADS=4
export GOTO_NUM_THREADS=4
export OMP_NUM_THREADS=4
The priorities are OPENBLAS_NUM_THREADS
> GOTO_NUM_THREADS
> OMP_NUM_THREADS
.
If you compile this library with USE_OPENMP=1
, you should set the OMP_NUM_THREADS
environment variable; OpenBLAS ignores OPENBLAS_NUM_THREADS
and GOTO_NUM_THREADS
when
compiled with USE_OPENMP=1
.
We provide the following functions to control the number of threads at runtime:
void goto_set_num_threads(int num_threads);
void openblas_set_num_threads(int num_threads);
Note that these are only used once at library initialization, and are not available for
fine-tuning thread numbers in individual BLAS calls.
If you compile this library with USE_OPENMP=1
, you should use the above functions too.
Please submit an issue in https://github.com/xianyi/OpenBLAS/issues.
Please see Changelog.txt to view the differences between OpenBLAS and GotoBLAS2 1.13 BSD version.
x86_64
(amd64
),
there is experimental support for up to 1024 CPUs/cores and 128 numa nodes if you build
the library with BIGNUMA=1
.NO_AFFINITY=1
in
Makefile.rule. However, note that this may cause
a conflict with R parallel.make test
may fail with a pthread_create
error (EAGAIN
).
However, it will be okay when you run the same test case on the shell.CONTRIBUTORS.md
.Please read this wiki page.
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。