OpenBLAS

http://www.openmathlib.org/OpenBLAS/docs
Admin
OpenBLAS is an optimized Basic Linear Algebra Subprograms (BLAS) library based on GotoBLAS2. It...
Tokens:31,104
Snippets:132
Trust Score:4.4
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install OpenBLAS to Specific Directory

Installs OpenBLAS to a specified directory using the 'make install' command with the PREFIX flag. The default installation path is '/opt/OpenBLAS'. Ensure build flags used during compilation are also passed to 'make install'.

```shell
make install PREFIX=/path/to/installation/directory
```

--------------------------------

### OpenBLAS Threading and Configuration Example

Demonstrates how to query OpenBLAS build configurations using pkg-config and shows an example of an OpenBLAS .pc file detailing build options like threading model and maximum threads.

```bash
$ pkg-config --libs openblas
-fopenmp -lopenblas
```

```config
openblas_config= ... USE_OPENMP=0 MAX_THREADS=24
```

--------------------------------

### Install ILP64 OpenBLAS with Make

Installs the OpenBLAS ILP64 build generated by Make to a specified prefix. This command demonstrates how to deploy the libraries and configuration files, resulting in files like libopenblas64_.so, libopenblas64_.a, and openblas64.pc.

```make
make install PREFIX=$PWD/../openblas/make64 INTERFACE64=1 SYMBOLSUFFIX=64_
```

--------------------------------

### Install OpenBLAS

Installs the built OpenBLAS library and associated files to a specified prefix directory (e.g., `c:\opt`). This step copies headers, libraries (static and dynamic), and support files into organized subdirectories, making them ready for use in other projects.

```shell
cmake --install . --prefix c:\opt -v
```

--------------------------------

### Build and Install OpenBLAS with DYNAMIC_ARCH

Commands to clean, build, and install a custom-built OpenBLAS library with dynamic architecture support. This is typically done after ensuring the build environment is correctly configured.

```shell
$ make clean
$ make DYNAMIC_ARCH=1
$ sudo make DYNAMIC_ARCH=1 install
```

--------------------------------

### Install OpenBLAS on openSUSE/SLE

Installs the OpenBLAS library and development files on openSUSE/SLE systems using zypper. This command ensures both the library and development headers are installed.

```bash
sudo zypper refresh
sudo zypper install openblas-devel
```

--------------------------------

### Install OpenBLAS with vcpkg (Windows)

Installs OpenBLAS using the vcpkg package manager on Windows. Supports both classic and manifest modes for integration into projects.

```powershell
# In classic mode:
vcpkg install openblas

# Or in manifest mode:
vcpkg add port openblas
```

--------------------------------

### Run dgemm_ C example

Execute the compiled C program to test the dgemm_ Fortran interface. Provide the matrix dimensions m, n, and k as command-line arguments.

```shell
./time_dgemm <m> <n> <k>
```

--------------------------------

### Adding Support for New Architectures

Guidance on adding support for entirely new CPU architectures, recommending cloning existing structures like ARMv5 as a starting point.

```text
# Clone support structure for a similar architecture (e.g., ARMv5 for new ARM variants).
# Refer to pull request #1526 for an example shopping list.
# Ensure all necessary C kernels, Makefiles, and configuration files are adapted.
```

--------------------------------

### Compile OpenBLAS with Make (Basic)

A basic command to compile OpenBLAS using make, specifying the target architecture and C compiler flags. This is a starting point for building the library.

```make
make TARGET=ARMV8 ONLY_CBLAS=1 AR=ar CC="clang ${CLANG_FLAGS}" HOSTCC=gcc -j4
```

--------------------------------

### Install OpenBLAS on Debian/Ubuntu/Mint/Kali

Installs the OpenBLAS library and development files on Debian-based Linux distributions using apt. This includes the library itself and necessary headers/config files for development.

```bash
sudo apt update
sudo apt install libopenblas-dev
```

--------------------------------

### Install OpenBLAS with Homebrew (macOS)

Installs OpenBLAS on macOS using the Homebrew package manager. This command fetches and installs the OpenBLAS package.

```bash
% brew install openblas
```

--------------------------------

### Install OpenBLAS on FreeBSD

Installs the OpenBLAS library on FreeBSD using the pkg package manager. This command installs the pre-compiled OpenBLAS package from the FreeBSD ports collection.

```bash
pkg install openblas
```

--------------------------------

### Installing OpenBLAS Headers

When including cblas.h, ensure you use the version installed by `make install`, not a copied source file. This command installs necessary headers and modified cblas.h to the include path.

```shell
make install
```

--------------------------------

### ILP64 Convention Naming Examples

Illustrates the mapping between base API names, binary symbol names, and how they are called from Fortran and C code under the upcoming standardized ILP64 convention using the '_64' suffix.

```text
base API name | binary symbol name | call from Fortran code | call from C code
---|---|---|---
`dgemm` | `dgemm_64_` | `dgemm_64(...)` | `dgemm_64_(...)`
`cblas_dgemm` | `cblas_dgemm_64` | n/a | `cblas_dgemm_64(...)`
```

--------------------------------

### Manage BLAS/LAPACK alternatives with update-alternatives

Demonstrates how to install and remove system alternatives for BLAS and LAPACK libraries. This allows redirecting calls to the newly built OpenBLAS library, replacing the system's default BLAS implementation.

```shell
$ sudo apt install libblas-dev liblapack-dev
$ sudo update-alternatives --install /usr/lib/libblas.so.3 libblas.so.3 /opt/OpenBLAS/lib/libopenblas.so.0 41 \
   --slave /usr/lib/liblapack.so.3 liblapack.so.3 /opt/OpenBLAS/lib/libopenblas.so.0
$ sudo update-alternatives --remove libblas.so.3 /opt/OpenBLAS/lib/libopenblas.so.0
```

--------------------------------

### Compile C code with OpenBLAS

This command shows how to compile the C example that calls the BLAS Fortran interface. It links against the OpenBLAS static library and the pthread library. Ensure the path to libopenblas.a is correct.

```shell
gcc -o time_dgemm time_dgemm.c /your/path/libopenblas.a -lpthread
```

--------------------------------

### Install OpenBLAS on Arch/Manjaro/Antergos

Installs the OpenBLAS library on Arch Linux and its derivatives using pacman. This command installs the core OpenBLAS package.

```bash
sudo pacman -S openblas
```

--------------------------------

### Compile C code with CBLAS and OpenBLAS

Command to compile the C example code that calls the CBLAS interface. It specifies the output executable name, source file, include paths, library paths, runtime path, the OpenBLAS library, and necessary threading/Fortran libraries.

```shell
gcc -o test_cblas_open test_cblas_dgemm.c -I/your_path/OpenBLAS/include/ -L/your_path/OpenBLAS/lib -lopenblas -lpthread -lgfortran
```

--------------------------------

### Install FlexiBLAS on Fedora

Installs FlexiBLAS development files on Fedora, which is recommended as Fedora does not ship pkg-config files for OpenBLAS directly. FlexiBLAS uses OpenBLAS as its default backend.

```bash
dnf install flexiblas-devel
```

--------------------------------

### Install OpenBLAS on Fedora/CentOS/RHEL

Installs the OpenBLAS library and development files on Fedora, CentOS, or RHEL systems using dnf. For CentOS/RHEL, the EPEL repository must be enabled first.

```bash
dnf check-update
dnf install openblas-devel
```

--------------------------------

### Build OpenBLAS on Linux/macOS

Compile the OpenBLAS library on Linux and macOS systems. This process requires C and Fortran compilers to be installed. The standard `make` command is used to initiate the build.

```makefile
make
```

--------------------------------

### Install devtoolset-3 binutils for RHEL/CentOS 6

Installs the necessary binutils package from the Software Collections repository to support newer instruction sets like AVX2, which are not present in the default RHEL 6 binutils. This is crucial for building OpenBLAS with advanced CPU features.

```shell
$ yum search devtoolset-\\?-binutils
$ sudo yum install devtoolset-3-binutils
```

--------------------------------

### Install ILP64 OpenBLAS with CMake

Installs the OpenBLAS ILP64 build generated by CMake to a specified prefix. This process deploys the libraries and configuration files, including CMake targets and pkg-config files, typically resulting in library names like libopenblas_64.so and libopenblas_64.a.

```cmake
cmake --install . --prefix $PWD/../../openblas/cmake64
```

--------------------------------

### DGEMM Call Tree Example

Illustrates the execution flow for the DGEMM (Double-precision General Matrix Multiply) function. It shows how calls progress from the interface layer, through the driver, to the specific assembly kernels optimized for different CPU architectures.

```Text
interface/gemm.c
        │
driver/level3/level3.c
        │
gemm assembly kernels at kernel/

```

--------------------------------

### Cross-Compile OpenBLAS with Make

Instructions for cross-compiling OpenBLAS, requiring the setup of C and Fortran cross-compilers via environment variables (CC, FC, HOSTCC) and specifying the target architecture (TARGET). Additional flags like BINARY, CROSS, and NO_LAPACKE can be used for specific build configurations.

```shell
# Compile the library for ARM Cortex-A9 linux on an x86-64 machine
# (note: install only `gnueabihf` versions of the cross toolchain)
make CC=arm-linux-gnueabihf-gcc FC=arm-linux-gnueabihf-gfortran HOSTCC=gcc TARGET=CORTEXA9
```

```shell
# Compile OpenBLAS for a loongson3a CPU on an x86-64 machine:
make BINARY=64 CC=mips64el-unknown-linux-gnu-gcc FC=mips64el-unknown-linux-gnu-gfortran HOSTCC=gcc TARGET=LOONGSON3A
```

```shell
# Compile OpenBLAS for loongson3a CPU with the `loongcc` compiler on an x86-64 machine:
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
```

--------------------------------

### Install Build Tools with Conda

Installs necessary build tools like CMake, Fortran compilers (flang), LLVM components, Perl, and Ninja using Conda. This command ensures all required dependencies are available in the environment.

```shell
conda update -n base conda
conda config --add channels conda-forge
conda install -y cmake flang clangdev perl libflang ninja
```

--------------------------------

### Linking and Runtime Library Loading

Guides on how to correctly link against OpenBLAS dynamic libraries and ensure the runtime loader finds the correct version. This involves using linker flags like -L and -Wl,rpath, or setting environment variables like LD_LIBRARY_PATH.

```shell
ldd /path/to/your/program
```

```shell
gcc your_program.c -o your_program -L /opt/OpenBLAS/lib -lopenblas -Wl,-rpath=/opt/OpenBLAS/lib
```

```shell
export LD_LIBRARY_PATH=/opt/OpenBLAS/lib:$LD_LIBRARY_PATH
./your_program
```

--------------------------------

### FreeBSD Build Command

Compiles OpenBLAS for FreeBSD using gmake, specifying the C compiler (gcc) and Fortran compiler (gfortran). This command assumes necessary development tools are installed via FreeBSD ports.

```makefile
gmake CC=gcc FC=gfortran
```

--------------------------------

### Compile OpenBLAS using Make

Standard procedure to build and install OpenBLAS from source using Make. It automatically detects the CPU architecture for optimization, but this can be overridden using the TARGET flag.

```shell
make
# add "-j4" to compile in parallel with 4 processes
make install
```

```shell
# `make TARGET=xxx` sets target CPU: e.g. for an Intel Nehalem CPU:
make TARGET=NEHALEM
```

--------------------------------

### Get OpenBLAS Link Flags with pkg-config

Uses the pkg-config tool to retrieve the necessary compiler and linker flags for OpenBLAS. This is a convenient way to ensure correct paths and library names are used when linking.

```shell
$ pkg-config --cflags openblas
-I/usr/local/include
$ pkg-config --libs openblas
-L/usr/local/lib -lopenblas
```

--------------------------------

### CBLAS Single-Precision GEMM Example

Demonstrates how to perform single-precision general matrix multiplication (GEMM) using the CBLAS interface in C. This requires including the cblas.h header and linking with the OpenBLAS library. The function signature includes parameters for matrix layout, transpose options, dimensions, alpha/beta scaling factors, and pointers to the matrices.

```C
#include <cblas.h>
...
cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, 1.0, A, K, B, N, 0.0, result, N);
```

--------------------------------

### Build System Configuration for New CPUs

Outlines necessary modifications to build system files for integrating new CPU support. Includes kernel configuration, parameter files, Makefiles, and target lists.

```makefile
# In the top-level Makefile or CMakeLists.txt:
# Add new CPU name to TargetList.txt
# Example: TARGET_x86_64 += MYCPU

# In the kernel directory Makefile/CMakeLists.txt:
# Define USE_TRMM if TRMM functions use a separate source file
# USE_TRMM = 1

# In param.h:
# Add or clone GEMM_UNROLL parameters for the new CPU
// #define GEMM_UNROLL_MYCPU { ... }
```

```text
# In Makefile.conf and config.h (generated by getarch):
# Ensure correct definitions are set based on the new CPU
# Failure to set these can lead to missing GEMM_UNROLL parameters.
```

--------------------------------

### Install OpenBLAS with MacPorts (macOS)

Installs OpenBLAS on macOS using the MacPorts package manager. This command installs the OpenBLAS-devel variant, which typically includes development files.

```bash
% sudo port install OpenBLAS-devel
```

--------------------------------

### Build OpenBLAS on Windows with Visual Studio

Instructions for building OpenBLAS on Windows using Microsoft Visual Studio. This method yields an OpenBLAS build that adheres to the Windows platform-native ABI.

```makefile
make
```

--------------------------------

### Clone and Checkout OpenBLAS Release

Steps to clone the OpenBLAS repository from GitHub and checkout a specific release tag (e.g., v0.3.28) for building.

```shell
git clone https://github.com/OpenMathLib/OpenBLAS.git
cd OpenBLAS
git checkout v0.3.28
```

--------------------------------

### Install OpenBLAS with Conda (Windows/macOS/Linux)

Installs OpenBLAS using the Conda package manager, commonly from the conda-forge channel. This method is cross-platform and integrates well with Conda environments.

```bash
conda install openblas
```

--------------------------------

### Build OpenBLAS on Windows with MinGW

Instructions for building OpenBLAS on Windows using the MinGW compiler. This method results in a build with a different Application Binary Interface (ABI) compared to builds using Visual Studio.

```makefile
make
```

--------------------------------

### Compiler and Build Configuration for AVX

Guidance on compiler versions and make flags required for specific hardware features like AVX. Includes instructions for GCC, Clang, and disabling AVX for compatibility.

```makefile
make CC=clang
```

```makefile
make NO_AVX=1
```

--------------------------------

### Link OpenBLAS Static Library

Links a static OpenBLAS library (.a file) to a C program by directly providing the path to the library file on the compile command line.

```shell
gcc -o test test.c /your/path/libopenblas.a
```

--------------------------------

### CBLAS Header Inclusion

How to include the CBLAS header file in Visual Studio when using the built OpenBLAS library. The header file is usually located in the include directory of the installation path.

```c
#include "cblas.h"
```

--------------------------------

### Prepare Def File for MSVC Import Library

Modifies the `libopenblas.def` file by prepending the `LIBRARY libopenblas.dll` line, which is necessary for generating an import library with MSVC's `lib.exe`.

```shell
cat <(echo "LIBRARY libopenblas.dll") libopenblas.def > libopenblas.def.1
mv libopenblas.def.1 libopenblas.def
```

--------------------------------

### Activate Visual Studio ARM64 Native Command Prompt

Command to launch the Visual Studio ARM64 Native Command Prompt, essential for building OpenBLAS on Windows on Arm.

```batch
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsarm64.bat
```

--------------------------------

### Switch Default BLAS Implementation with Conda

Demonstrates how to switch the default BLAS implementation to OpenBLAS within a Conda environment by installing a specific package version. Refer to Conda-forge documentation for details.

```bash
conda install libblas=*=*openblas
```

--------------------------------

### OpenBLAS Windows Binary Build Options

Specifies the build options used for the official OpenBLAS binaries distributed for Windows. These options define the architecture, threading, and compatibility settings.

```text
NUM_THREADS=64 TARGET=GENERIC DYNAMIC_ARCH=1 DYNAMIC_OLDER=1 CONSISTENT_FPCSR=1 INTERFACE=0
```

--------------------------------

### OpenBLAS Runtime Configuration Functions

Utility functions to query build-time options and runtime configuration of the OpenBLAS library.

```APIDOC
openblas_get_parallel()
  - Returns: Integer indicating parallelization type:
    - 0: Single-threaded
    - 1: Multithreading without OpenMP
    - 2: Multithreading with USE_OPENMP=1

openblas_get_config()
  - Returns: String containing build settings such as USE64BITINT, DYNAMIC_ARCH, and the detected or configured target CPU.
```

--------------------------------

### MIPS Build Commands with GNU Toolchains

Provides make commands for building OpenBLAS for various MIPS processors (I6400, P6600, P5600) using specific GNU toolchains. It includes configurations for different ABI variants (n32, n64) and specifies compiler/assembler/linker paths and flags.

```shell
IMG_TOOLCHAIN_DIR={full IMG GNU/Linux Toolchain path including "bin" directory -- for example, /opt/linux_toolchain/bin}
IMG_GCC_PREFIX=mips-img-linux-gnu
IMG_TOOLCHAIN=${IMG_TOOLCHAIN_DIR}/${IMG_GCC_PREFIX}
```

```makefile
# I6400 Build (n32):
make BINARY=32 BINARY32=1 CC=$IMG_TOOLCHAIN-gcc AR=$IMG_TOOLCHAIN-ar FC="$IMG_TOOLCHAIN-gfortran -EL -mabi=n32" RANLIB=$IMG_TOOLCHAIN-ranlib HOSTCC=gcc CFLAGS="-EL" FFLAGS=$CFLAGS LDFLAGS=$CFLAGS TARGET=I6400

# I6400 Build (n64):
make BINARY=64 BINARY64=1 CC=$IMG_TOOLCHAIN-gcc AR=$IMG_TOOLCHAIN-ar FC="$IMG_TOOLCHAIN-gfortran -EL" RANLIB=$IMG_TOOLCHAIN-ranlib HOSTCC=gcc CFLAGS="-EL" FFLAGS=$CFLAGS LDFLAGS=$CFLAGS TARGET=I6400

# P6600 Build (n32):
make BINARY=32 BINARY32=1 CC=$IMG_TOOLCHAIN-gcc AR=$IMG_TOOLCHAIN-ar FC="$IMG_TOOLCHAIN-gfortran -EL -mabi=n32" RANLIB=$IMG_TOOLCHAIN-ranlib HOSTCC=gcc CFLAGS="-EL" FFLAGS=$CFLAGS LDFLAGS=$CFLAGS TARGET=P6600

# P6600 Build (n64):
make BINARY=64 BINARY64=1 CC=$IMG_TOOLCHAIN-gcc AR=$IMG_TOOLCHAIN-ar FC="$IMG_TOOLCHAIN-gfortran -EL" RANLIB=$IMG_TOOLCHAIN-ranlib HOSTCC=gcc CFLAGS="-EL" FFLAGS="$CFLAGS" LDFLAGS="$CFLAGS" TARGET=P6600
```

```shell
MTI_TOOLCHAIN_DIR={full MTI GNU/Linux Toolchain path including "bin" directory -- for example, /opt/linux_toolchain/bin}
MTI_GCC_PREFIX=mips-mti-linux-gnu
MTI_TOOLCHAIN=${IMG_TOOLCHAIN_DIR}/${IMG_GCC_PREFIX}
```

```makefile
# P5600 Build:
make BINARY=32 BINARY32=1 CC=$MTI_TOOLCHAIN-gcc AR=$MTI_TOOLCHAIN-ar FC="$MTI_TOOLCHAIN-gfortran -EL"    RANLIB=$MTI_TOOLCHAIN-ranlib HOSTCC=gcc CFLAGS="-EL" FFLAGS=$CFLAGS LDFLAGS=$CFLAGS TARGET=P5600
```

--------------------------------

### OpenBLAS GEMM Kernel Implementation

Details on the implementation of Goto's algorithm for GEMM, including a naive 2x2 register blocking kernel. It suggests writing optimized assembly kernels and tuning cache block sizes.

```C
/*
 * The `driver/level3/level3.c` is the implementation of Goto's algorithm.
 * Meanwhile, you can look at `kernel/generic/gemmkernel_2x2.c`,
 * which is a naive `2x2` register blocking `gemm` kernel in C.
 */

// Example of a conceptual kernel file structure (not actual code from text):
// #include "../config.h"
// #include "../common.h"
// 
// void gemmkernel_2x2(int m, int n, int k, double alpha, double *A, int lda, double *B, int ldb, double *C, int ldc) {
//     // Naive 2x2 register blocking GEMM kernel implementation
//     // ... implementation details ...
// }
```

--------------------------------

### Call CBLAS Interface (dgemm)

Example C code demonstrating the use of the CBLAS interface, specifically the 'cblas_dgemm' function for matrix multiplication. It includes necessary headers and defines sample matrices for the operation.

```c
#include <cblas.h>
#include <stdio.h>

void main()
{
  int i=0;
  double A[6] = {1.0,2.0,1.0,-3.0,4.0,-1.0};
  double B[6] = {1.0,2.0,1.0,-3.0,4.0,-1.0};
  double C[9] = {.5,.5,.5,.5,.5,.5,.5,.5,.5};
  cblas_dgemm(CblasColMajor, CblasNoTrans, CblasTrans,3,3,2,1,A, 3, B, 3,2,C,3);

  for(i=0; i<9; i++)
    printf("%lf ", C[i]);
  printf("\n");
}

```

--------------------------------

### Build OpenBLAS Project

Builds the OpenBLAS project using CMake. This command compiles the source code and links it to create the OpenBLAS libraries, typically placing them in a 'lib' directory within the build folder.

```shell
cmake --build . --config Release
```

--------------------------------

### Creating Symbolic Links for OpenBLAS

Some programs may search for libblas.so and liblapack.so separately. This snippet shows how to create symbolic links from libopenblas.so to these expected names.

```shell
ln -s libopenblas.so libblas.so
ln -s libopenblas.so liblapack.so
```

--------------------------------

### OpenBLAS Configuration Parameters

Notes on CPU-specific parameters in `param.h` and their usage in OpenBLAS algorithms. Some parameters like DNUMOPT and SNUMOPT are not actively used, while others like SYMV_P and GEMV_UNROLL have specific usage contexts.

```C
/*
 * Note that not all of the CPU-specific parameters in `param.h` are actively used in algorithms.
 * DNUMOPT only appears as a scale factor in profiling output of the level3 `syrk` interface code,
 * while its counterpart `SNUMOPT` (aliased as `NUMOPT` in `common.h`) is not used anywhere at all.
 *
 * `SYMV_P` is only used in the generic kernels for the `symv` and `chemv`/`zhemv` functions -
 * at least some of those are usually overridden by CPU-specific implementations, so if you start
 * by cloning the existing implementation for a related CPU you need to check its `KERNEL` file
 * to see if tuning `SYMV_P` would have any effect at all.
 *
 * `GEMV_UNROLL` is only used by some older x86-64 kernels, so not all sections in `param.h` define it.
 * Similarly, not all of the CPU parameters like L2 or L3 cache sizes are necessarily used in current
 * kernels for a given model - by all indications the CPU identification code was imported from some
 * other project originally.
 */

// Example of param.h content (conceptual):
// #define DNUMOPT 1.0
// #define SYMV_P 4
// #define GEMV_UNROLL 8
```

--------------------------------

### OpenBLAS Build Issues: Undefined symbol 'gotoblas'

Addresses issues where a program complains about an 'undefined symbol gotoblas' after updating OpenBLAS. This usually means the dynamic linker cannot find the correct BLAS implementation, often due to installation path or environment variable issues.

```APIDOC
Program Error: Undefined symbol 'gotoblas'

This error message, 'undefined symbol gotoblas', typically appears when a program compiled against OpenBLAS cannot locate the necessary BLAS symbol at runtime. This often happens after updating OpenBLAS or when the dynamic linker path is not correctly configured.

Cause:

1.  **Incorrect Library Path**: The dynamic linker (`ld.so` on Linux) cannot find the `libopenblas.so` file in its search paths.
2.  **Environment Variables**: The `LD_LIBRARY_PATH` (on Linux/Unix) or `PATH` (on Windows) environment variable might not include the directory where `libopenblas.so` is installed.
3.  **Installation Issues**: OpenBLAS might not have been installed correctly, or the installation was incomplete.
4.  **Symbol Version Mismatch**: Less common, but possible if multiple BLAS implementations are present and the wrong one is being loaded.

Solutions:

1.  **Set `LD_LIBRARY_PATH`**: Ensure the directory containing `libopenblas.so` is in your `LD_LIBRARY_PATH` environment variable.
    ```bash
    export LD_LIBRARY_PATH=/path/to/openblas/lib:$LD_LIBRARY_PATH
    ```
    Replace `/path/to/openblas/lib` with the actual path to your OpenBLAS shared library.

2.  **Install `libopenblas.so` to Standard Location**: If you have root privileges, install OpenBLAS to a standard system library path (e.g., `/usr/local/lib`). After installation, run `sudo ldconfig` to update the dynamic linker cache.

3.  **Use `RPATH` during Compilation**: When compiling your program, embed the library path into the executable using the `RPATH` linker option.
    ```bash
    gcc your_program.c -o your_program -I/path/to/openblas/include -L/path/to/openblas/lib -lopenblas -Wl,-rpath,/path/to/openblas/lib
    ```

4.  **Check `ldconfig -p | grep openblas`**: On Linux, this command can help you see if the system's dynamic linker is aware of `libopenblas.so` and where it's located.

5.  **Reinstall OpenBLAS**: If you suspect an installation issue, try reinstalling OpenBLAS, ensuring all build steps complete successfully.

Troubleshooting Steps:

-   Verify the exact location of `libopenblas.so` on your system.
-   Check the contents of `LD_LIBRARY_PATH` before running your program.
-   Try running a simple test program that only links to OpenBLAS to isolate the issue.
```

--------------------------------

### Enable devtoolset-3 for OpenBLAS build

Enables the devtoolset-3 environment, which includes updated compilers and binutils, to build OpenBLAS with dynamic architecture support. This command prefixes the make process with the necessary shell redirection.

```shell
$ scl enable devtoolset-3 -- make DYNAMIC_ARCH=1
```

--------------------------------

### Build OpenBLAS with Make

Compiles OpenBLAS using the Make build system, specifying the C compiler (clang-cl), Fortran compiler (flang-new), archiver (llvm-ar), target architecture (ARMV8), ARM architecture (arm64), ranlib (llvm-ranlib), and Make utility.

```make
$ make CC=clang-cl FC=flang-new AR="llvm-ar" TARGET=ARMV8 ARCH=arm64 RANLIB="llvm-ranlib" MAKE=make
```

--------------------------------

### Benchmarking OpenBLAS with External Tools

Methods for benchmarking OpenBLAS performance, including local C benchmarks, benchmarks via Python/NumPy/SciPy/Octave/R, Codspeed for pull requests, and an Airspeed Velocity-based suite for cron jobs.

```Shell
# Run local C benchmarks
cd benchmark
make

# Benchmarks via Python/NumPy/SciPy/Octave/R (conceptual)
# python benchmark/scripts/run_numpy_bench.py
# Rscript benchmark/scripts/run_r_bench.R

# Codspeed results are viewed at:
# https://codspeed.io/OpenMathLib/OpenBLAS

# Airspeed Velocity-based benchmarks are run on cron jobs and published to:
# http://www.openmathlib.org/BLAS-Benchmarks/
```

--------------------------------

### Runtime CPU Detection

Explains the implementation of runtime CPU detection for architectures supporting DYNAMIC_ARCH builds. Covers specific files for x86 and other architectures.

```c
/* For x86, in driver/others/dynamic.c */
/* For other architectures, in driver/others/dynamic_<arch>.c */

// ... CPUID processing logic ...
// Example: Convert Linux /proc/cpuinfo model number to hexadecimal
// int model_hex = convert_to_hex(linux_model_number);
// int extended_model = (model_hex >> 4) & 0xF;
// int model = model_hex & 0xF;
// ... use these parts for detection ...
```

--------------------------------

### Configure OpenBLAS with CMake

Configures the OpenBLAS project using CMake. It sets up environment variables for library and include paths, creates a build directory, and specifies the generator (Ninja), C/C++/Fortran compilers, build type, and other options like static/shared libraries.

```shell
set "LIB=%CONDA_PREFIX%\Library\lib;%LIB%"
set "CPATH=%CONDA_PREFIX%\Library\include;%CPATH%"
mkdir build
cd build
cmake .. -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DCMAKE_Fortran_COMPILER=flang -DCMAKE_MT=mt -DBUILD_WITHOUT_LAPACK=no -DNOFORTRAN=0 -DDYNAMIC_ARCH=ON -DCMAKE_BUILD_TYPE=Release
```

--------------------------------

### Visual Studio Linking Instruction

Instruction for linking the OpenBLAS import library (`libopenblas.dll.a`) within a Visual Studio project. This is typically done in the project's linker settings.

```text
properties->Linker->Input
```

--------------------------------

### Link OpenBLAS Shared Library

Links a shared OpenBLAS library (e.g., libopenblas.so) to a C program. This command includes flags for include paths (-I), library paths (-L), runtime path (-Wl,-rpath), and the library itself (-lopenblas). Additional flags like -lpthread and -lgfortran may be needed depending on build configurations.

```shell
gcc -o test test.c -I/your_path/OpenBLAS/include/ -L/your_path/OpenBLAS/lib -Wl,-rpath,/your_path/OpenBLAS/lib -lopenblas
```

--------------------------------

### Generate MSVC Import Library

Generates the MSVC import library (`libopenblas.dll.a`) from the prepared `.def` file using the `dlltool` command. This library is required for linking with MSVC.

```shell
dlltool -d libopenblas.def -l libopenblas.dll.a
```

--------------------------------

### Makefile Dependency Graph

Visualizes the dependency structure of the OpenBLAS Makefiles. It illustrates how the main Makefile includes or triggers other Makefiles like Makefile.system, Makefile.prebuild, and architecture-specific files, outlining the build flow.

```flowchart
flowchart LR
    A[Makefile] -->|included by many of the Makefiles in the subdirectories!| B(Makefile.system)
        B -->|triggered, not included, once by Makefile.system, and runs before any of the actual library code is built. builds and runs the 'getarch' tool for cpu identification, runs the compiler detection scripts c_check/f_check| C{Makefile.prebuild}
            C -->|either this or Makefile_kernel.conf is generated| D[Makefile.conf]
            C -->|temporary Makefile.conf during DYNAMIC_ARCH builds| E[Makefile_kernel.conf]
        B -->|defaults for build options that can be given on the make command line| F[Makefile.rule]
        B -->|architecture-specific compiler options and OpenBLAS buffer size values| G[Makefile.$ARCH]
    A --> exports
    A -->|directories: test, ctest, utest, cpp_thread_test| H(test directories)
    A --> I($BLASDIRS)
        I --> interface
        I --> driver/level2
        I --> driver/level3
        I --> driver/others
    A -->|for each target in DYNAMIC_CORE if DYNAMIC_ARCH=1| kernel
    A -->|subdirs: timing, testing, testing/EIG, testing/LIN| J($NETLIB_LAPACK_DIR)
    A --> relapack
```

--------------------------------

### Configure OpenBLAS Multi-threading

Instructions on how to manage OpenBLAS multi-threading in applications. This includes setting environment variables, calling runtime functions, and configuring build options.

```shell
export OPENBLAS_NUM_THREADS=1
```

```c
openblas_set_num_threads(1);
```

```makefile
make USE_THREAD=0 USE_LOCKING=1
```

```makefile
make USE_OPENMP=1
```

--------------------------------

### Calling OpenBLAS Functions in C

Demonstrates how to call OpenBLAS functions from C code. This typically involves including the necessary headers and linking against the OpenBLAS library.

```C
#include <cblas.h>

int main() {
    // Example: Matrix multiplication C = alpha*A*B + beta*C
    // Assuming A, B, C are pre-initialized double precision matrices
    // and alpha, beta are scalar values.
    // cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, A, lda, B, ldb, beta, C, ldc);
    
    // Example: Vector addition y = alpha*x + y
    // Assuming x, y are pre-initialized double precision vectors
    // and alpha is a scalar value.
    // cblas_daxpy(N, alpha, x, incx, y, incy);
    
    return 0;
}
```
Tokens:
Raw