# Copyright 2013-2020 The Meson development team # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import functools import os from pathlib import Path import platform import re import subprocess import sys import typing as T from .. import mlog from .. import mesonlib from ..mesonlib import MachineChoice from ..options import OptionKey from .base import DependencyMethods, SystemDependency, DependencyException from .cmake import CMakeDependency from .detect import packages from .factory import DependencyFactory, factory_methods from .pkgconfig import PkgConfigDependency if T.TYPE_CHECKING: from ..environment import Environment from . factory import DependencyGenerator """ TODO: how to select BLAS interface layer (LP64, ILP64)? LP64 is the 32-bit interface (confusingly, despite the "64") ILP64 is the 64-bit interface OpenBLAS library names possible: - libopenblas - libopenblas64_ # or nonstandard suffix (see OpenBLAS Makefile) - let's not deal with that TODO: do we care here about whether OpenBLAS is compiled with pthreads or OpenMP? MKL has separate .pc files for this (_seq vs. _iomp), OpenBLAS does not TODO: what about blas/lapack vs. cblas/clapack? See http://nicolas.limare.net/pro/notes/2014/10/31_cblas_clapack_lapacke/ for details NOTE: we ignore static libraries for now Other Notes: - OpenBLAS can be built with NOFORTRAN, in that case it's CBLAS + f2c'd LAPACK - OpenBLAS can be built without LAPACK support, Arch Linux currently does this (see https://github.com/scipy/scipy/issues/17465) - OpenBLAS library can be renamed with an option in its Makefile - Build options: - conda-forge: https://github.com/conda-forge/openblas-feedstock/blob/49ca08fc9d1ff220804aa9b894b9a6fe5db45057/recipe/conda_build_config.yaml - Spack: https://github.com/spack/spack/blob/develop/var/spack/repos/builtin/packages/openblas/package.py#L52 - vendored into NumPy/SciPy wheels: https://github.com/MacPython/openblas-libs/blob/master/tools/build_openblas.sh#L53 Conda-forge library names and pkg-config output ----------------------------------------------- (lp64) $ ls lib/libopenblas* lib/libopenblas.a lib/libopenblasp-r0.3.21.a lib/libopenblasp-r0.3.21.so lib/libopenblas.so lib/libopenblas.so.0 (lp64) $ ls include/ cblas.h f77blas.h lapacke_config.h lapacke.h lapacke_mangling.h lapacke_utils.h lapack.h openblas_config.h (ilp64) $ ls lib/libopenblas* lib/libopenblas64_.a lib/libopenblas64_p-r0.3.21.a lib/libopenblas64_p-r0.3.21.so lib/libopenblas64_.so lib/libopenblas64_.so.0 (ilp64) $ ls include/ cblas.h f77blas.h lapacke_config.h lapacke.h lapacke_mangling.h lapacke_utils.h lapack.h openblas_config.h (lp64) $ pkg-config --cflags openblas -I/path/to/env/include (lp64) $ pkg-config --libs openblas -L/path/to/env/lib -lopenblas (ilp64) $ pkg-config --cflags openblas -I/path/to/env/include ilp64) $ pkg-config --libs openblas -L/path/to/envlib -lopenblas LP64 vs ILP64 interface and symbol names ---------------------------------------- Relevant discussions: - For OpenBLAS, see https://github.com/xianyi/OpenBLAS/issues/646 for standardized agreement on shared library name and symbol suffix. - PRs that added support for ILP64 to `numpy.distutils`: - with `64_` symbol suffix: https://github.com/numpy/numpy/pull/15012 - generalized to non-suffixed build: https://github.com/numpy/numpy/pull/15069 - PR that added support for ILP64 to SciPy: https://github.com/scipy/scipy/pull/11302 - Note to self: when SciPy uses ILP64, it also still requires LP64, because not all submodules support ILP64. Not for the same extensions though. $ objdump -t lp64/lib/libopenblas.so | grep -E "scopy*" # output cleaned up cblas_scopy scopy_ $ objdump -t ilp64/lib/libopenblas64_.so | grep -E "scopy*" cblas_scopy64_ scopy_64_ What should be implemented in Meson, and what should be left to users? Thoughts: 1. Meson should support a keyword to select the desired interface (`interface : 'ilp64'`), defaulting to `'lp64'` because that is what reference BLAS/LAPACK provide and what is typically expected. 2. The dependency object returned by `dependency('openblas')` or similar should be query-able for what the interface is. 3. For OpenBLAS, Meson should look for `libopenblas64_.so` for ILP64. 4. For Fortran, should Meson automatically set the required compile flag `-fdefault-integer-8`? - Note: this flag is specific to gfortran and Clang; For Intel compilers it is `-integer-size 64`(Linux/macOS), `/integer-size: 64` (Windows). - This is almost always the right thing to do; however for integer variables that reference an external non-BLAS/LAPACK interface and must not be changed to 64-bit, those should then be explicitly `integer*4` in the user code. 5. Users are responsible for implementing name mangling. I.e., appending `64_` to BLAS/LAPACK symbols when they are requesting ILP64, and also using portable integer types in their code if they want to be able to build with both LP64 and ILP64. This typically looks something like: ```C #ifdef HAVE_CBLAS64_ #define CBLAS_FUNC(name) name ## 64_ #else #define CBLAS_FUNC(name) name #endif CBLAS_FUNC(cblas_dgemm)(...); ``` 6. Users are responsible for implementing a build option (e.g., in `meson_options.txt`) if they want to allow switching between LP64 and ILP64. 7. Meson doesn't know anything about f2py; users have to instruct f2py to use 64-bit integers with `--f2cmap` or similar. See `get_f2py_int64_options` in SciPy for details. 8. When mixing C and Fortran code, the C code typically needs mangling because Fortran expects a trailing underscore. This is up to the user to implement. 9. TBD: `numpy.distutils` does a symbol prefix/suffix check and provides the result to its users, it could be helpful if Meson did this. See https://github.com/numpy/numpy/blob/6094eff9/numpy/distutils/system_info.py#L2271-L2278. CBLAS ----- Initial rough notes: - Not all implementations provide CBLAS, - The header is typically named `cblas.h`, however MKL calls it `mkl_cblas.h`, - OpenBLAS can be built without a Fortran compiler, in that case it's CBLAS + f2c'd LAPACK, - It would be useful if the dependency objects that Meson returned can be queried for whether CBLAS is present or not. - numpy.distutils detects CBLAS and defines `HAVE_CBLAS` if it's found. - BLIS doesn't build the CBLAS interface by default. To build it, define `BLIS_ENABLE_CBLAS`. - NumPy requires CBLAS, it's not optional. MKL --- MKL docs: https://www.intel.com/content/www/us/en/develop/documentation/onemkl-windows-developer-guide/top/linking-your-application-with-onemkl/linking-in-detail/linking-with-interface-libraries/using-the-ilp64-interface-vs-lp64-interface.html MKL link line advisor: https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl-link-line-advisor.html $ cd /opt/intel/oneapi/mkl/latest/lib # from recommended Intel installer $ ls pkgconfig/ mkl-dynamic-ilp64-iomp.pc mkl-dynamic-lp64-iomp.pc mkl-static-ilp64-iomp.pc mkl-static-lp64-iomp.pc mkl-dynamic-ilp64-seq.pc mkl-dynamic-lp64-seq.pc mkl-static-ilp64-seq.pc mkl-static-lp64-seq.pc $ pkg-config --libs mkl-dynamic-ilp64-seq -L/opt/intel/oneapi/mkl/latest/lib/pkgconfig/../../lib/intel64 -lmkl_intel_ilp64 -lmkl_sequential -lmkl_core -lpthread -lm -ldl $ pkg-config --cflags mkl-dynamic-ilp64-seq -DMKL_ILP64 -I/opt/intel/oneapi/mkl/latest/lib/pkgconfig/../../include $ ls intel64/libmkl* intel64/libmkl_avx2.so.2 intel64/libmkl_cdft_core.so.2 intel64/libmkl_intel_lp64.so.2 intel64/libmkl_sequential.a intel64/libmkl_avx512.so.2 intel64/libmkl_core.a intel64/libmkl_intel_thread.a intel64/libmkl_sequential.so intel64/libmkl_avx.so.2 intel64/libmkl_core.so intel64/libmkl_intel_thread.so intel64/libmkl_sequential.so.2 intel64/libmkl_blacs_intelmpi_ilp64.a intel64/libmkl_core.so.2 intel64/libmkl_intel_thread.so.2 intel64/libmkl_sycl.a intel64/libmkl_blacs_intelmpi_ilp64.so intel64/libmkl_def.so.2 intel64/libmkl_lapack95_ilp64.a intel64/libmkl_sycl.so intel64/libmkl_blacs_intelmpi_ilp64.so.2 intel64/libmkl_gf_ilp64.a intel64/libmkl_lapack95_lp64.a intel64/libmkl_sycl.so.2 intel64/libmkl_blacs_intelmpi_lp64.a intel64/libmkl_gf_ilp64.so intel64/libmkl_mc3.so.2 intel64/libmkl_tbb_thread.a intel64/libmkl_blacs_intelmpi_lp64.so intel64/libmkl_gf_ilp64.so.2 intel64/libmkl_mc.so.2 intel64/libmkl_tbb_thread.so intel64/libmkl_blacs_intelmpi_lp64.so.2 intel64/libmkl_gf_lp64.a intel64/libmkl_pgi_thread.a intel64/libmkl_tbb_thread.so.2 intel64/libmkl_blacs_openmpi_ilp64.a intel64/libmkl_gf_lp64.so intel64/libmkl_pgi_thread.so intel64/libmkl_vml_avx2.so.2 intel64/libmkl_blacs_openmpi_ilp64.so intel64/libmkl_gf_lp64.so.2 intel64/libmkl_pgi_thread.so.2 intel64/libmkl_vml_avx512.so.2 intel64/libmkl_blacs_openmpi_ilp64.so.2 intel64/libmkl_gnu_thread.a intel64/libmkl_rt.so intel64/libmkl_vml_avx.so.2 intel64/libmkl_blacs_openmpi_lp64.a intel64/libmkl_gnu_thread.so intel64/libmkl_rt.so.2 intel64/libmkl_vml_cmpt.so.2 intel64/libmkl_blacs_openmpi_lp64.so intel64/libmkl_gnu_thread.so.2 intel64/libmkl_scalapack_ilp64.a intel64/libmkl_vml_def.so.2 # intel64/libmkl_blacs_openmpi_lp64.so.2 intel64/libmkl_intel_ilp64.a intel64/libmkl_scalapack_ilp64.so intel64/libmkl_vml_mc2.so.2 # intel64/libmkl_blas95_ilp64.a intel64/libmkl_intel_ilp64.so intel64/libmkl_scalapack_ilp64.so.2 intel64/libmkl_vml_mc3.so.2 # intel64/libmkl_blas95_lp64.a intel64/libmkl_intel_ilp64.so.2 intel64/libmkl_scalapack_lp64.a intel64/libmkl_vml_mc.so.2 intel64/libmkl_cdft_core.a intel64/libmkl_intel_lp64.a intel64/libmkl_scalapack_lp64.so intel64/libmkl_cdft_core.so intel64/libmkl_intel_lp64.so intel64/libmkl_scalapack_lp64.so.2 $ objdump -t intel64/libmkl_intel_ilp64.so | grep scopy # cleaned up output: 0000000000000000 *UND* 0000000000000000 mkl_blas_scopy 0000000000323000 g F .text 0000000000000030 cblas_scopy_64 00000000002cecf0 g F .text 0000000000000030 cblas_scopy 000000000025aca0 g F .text 00000000000001d0 mkl_blas__scopy 000000000025aca0 g F .text 00000000000001d0 scopy_64_ 000000000025aca0 g F .text 00000000000001d0 scopy_64 000000000025aca0 g F .text 00000000000001d0 scopy_ 000000000025aca0 g F .text 00000000000001d0 scopy tl;dr: for MKL there's 8 pkg-config file, so you choose lp64/ilp64, dynamic/static, and pthreads/openmp; after that you can pick whatever symbols you like, they all exist and are aliases. A test with SciPy & MKL: $ # No pkg-config files for MKL in conda-forge yet, so use the Intel installer: $ export PKG_CONFIG_PATH=/opt/intel/oneapi/mkl/latest/lib/pkgconfig/ $ meson setup build --prefix=$PWD/build-install -Dblas=mkl-dynamic-ilp64-seq -Dlapack=mkl-dynamic-ilp64-seq $ python dev.py build $ ldd build/scipy/linalg/_flapack.cpython-310-x86_64-linux-gnu.so linux-vdso.so.1 (0x00007ffe2cd14000) libmkl_intel_ilp64.so.2 => /opt/intel/oneapi/mkl/latest/lib/intel64/libmkl_intel_ilp64.so.2 (0x00007f75a5000000) libmkl_sequential.so.2 => /opt/intel/oneapi/mkl/latest/lib/intel64/libmkl_sequential.so.2 (0x00007f75a3400000) libmkl_core.so.2 => /opt/intel/oneapi/mkl/latest/lib/intel64/libmkl_core.so.2 (0x00007f759f000000) libm.so.6 => /usr/lib/libm.so.6 (0x00007f75a62e2000) libc.so.6 => /usr/lib/libc.so.6 (0x00007f759ee19000) /usr/lib64/ld-linux-x86-64.so.2 (0x00007f75a63e8000) libdl.so.2 => /usr/lib/libdl.so.2 (0x00007f75a62db000) libpthread.so.0 => /usr/lib/libpthread.so.0 (0x00007f75a62d6000 $ # Due to RPATH stripping on install, this doesn't actually work unless we put MKL into our conda env: $ ldd build-install/lib/python3.10/site-packages/scipy/linalg/_flapack.cpython-310-x86_64-linux-gnu.so linux-vdso.so.1 (0x00007ffdf6bc6000) libmkl_intel_ilp64.so.2 => not found libmkl_sequential.so.2 => not found libmkl_core.so.2 => not found libm.so.6 => /usr/lib/libm.so.6 (0x00007f7e35318000) libc.so.6 => /usr/lib/libc.so.6 (0x00007f7e35131000) /usr/lib64/ld-linux-x86-64.so.2 (0x00007f7e356e5000) Also need to remember that MKL uses a g77 ABI (Accelerate too), while OpenBLAS and most other BLAS libraries will be using the gfortran ABI. See the `use-g77-abi` option in SciPy's meson_options.txt. ArmPL ----- Pkg-config file names for ArmPL to use (from https://github.com/spack/spack/pull/34979#discussion_r1073213319): armpl-dynamic-ilp64-omp armpl-Fortran-static-ilp64-omp armpl-dynamic-ilp64-omp.pc armpl-Fortran-static-ilp64-omp.pc armpl-dynamic-ilp64-seq armpl-Fortran-static-ilp64-seq armpl-dynamic-ilp64-seq.pc armpl-Fortran-static-ilp64-seq.pc armpl-dynamic-lp64-omp armpl-Fortran-static-lp64-omp armpl-dynamic-lp64-omp.pc armpl-Fortran-static-lp64-omp.pc armpl-dynamic-lp64-seq armpl-Fortran-static-lp64-seq armpl-dynamic-lp64-seq.pc armpl-Fortran-static-lp64-seq.pc armpl-Fortran-dynamic-ilp64-omp armpl-static-ilp64-omp armpl-Fortran-dynamic-ilp64-omp.pc armpl-static-ilp64-omp.pc armpl-Fortran-dynamic-ilp64-seq armpl-static-ilp64-seq armpl-Fortran-dynamic-ilp64-seq.pc armpl-static-ilp64-seq.pc armpl-Fortran-dynamic-lp64-omp armpl-static-lp64-omp armpl-Fortran-dynamic-lp64-omp.pc armpl-static-lp64-omp.pc armpl-Fortran-dynamic-lp64-seq armpl-static-lp64-seq armpl-Fortran-dynamic-lp64-seq.pc armpl-static-lp64-seq.pc Note that as of Jan'23, ArmPL ships the files without a `.pc` extension (that will hopefully be fixed), and Spack renames then so adds the `.pc` copies of the original files. Apple Accelerate ---------------- In macOS >=13.3, two LP64 and one ILP64 build of vecLib are shipped. Due to compatibility, the legacy interfaces (providing LAPACK 3.2.1) will be used by default. To use the new interfaces (providing LAPACK 3.9.1), including ILP64, it is necessary to set some #defines before including Accelerate / vecLib headers: - `-DACCELERATE_NEW_LAPACK`: use the new interfaces - `-DACCELERATE_LAPACK_ILP64`: use new ILP64 interfaces (note this requires `-DACCELERATE_NEW_LAPACK` to be set as well) The normal F77 symbols will remain as the legacy implementation. The newer interfaces have separate symbols with suffixes `$NEWLAPACK` or `$NEWLAPACK$ILP64`. Example binary symbols: - `_dgemm_`: this is the legacy implementation - `_dgemm$NEWLAPACK`: this is the new implementation - `_dgemm$NEWLAPACK$ILP64`: this is the new ILP64 implementaion If you use Accelerate / vecLib headers with the above defines, you don't need to worry about the symbol names. They'll get aliased correctly. For headers and linker flags, check if these directories exist before using them: 1. `-I/System/Library/Frameworks/vecLib.framework/Headers`, flags: ['-Wl,-framework', '-Wl,Accelerate'] 2. `-I/System/Library/Frameworks/vecLib.framework/Headers`, flags: ['-Wl,-framework', '-Wl,vecLib'] Note that the dylib's are no longer physically present, they're provided in the shared linker cache. """ def check_blas_machine_file(name: str, props: dict) -> T.Tuple[bool, T.List[str]]: # TBD: do we need to support multiple extra dirs? incdir = props.get(f'{name}_includedir') assert incdir is None or isinstance(incdir, str) libdir = props.get(f'{name}_librarydir') assert libdir is None or isinstance(libdir, str) if incdir and libdir: has_dirs = True if not Path(incdir).is_absolute() or not Path(libdir).is_absolute(): raise mesonlib.MesonException('Paths given for openblas_includedir and ' 'openblas_librarydir in machine file must be absolute') return has_dirs, [libdir, incdir] elif incdir or libdir: raise mesonlib.MesonException('Both openblas_includedir *and* openblas_librarydir ' 'have to be set in your machine file (one is not enough)') else: raise mesonlib.MesonBugException('issue with openblas dependency detection, should not ' 'be possible to reach this else clause') return (False, []) class BLASLAPACKMixin(): def parse_modules(self, kwargs: T.Dict[str, T.Any]) -> None: modules: T.List[str] = mesonlib.extract_as_list(kwargs, 'modules') valid_modules = ['interface: lp64', 'interface: ilp64', 'cblas', 'lapack', 'lapacke'] for module in modules: if module not in valid_modules: raise mesonlib.MesonException(f'Unknown modules argument: {module}') interface = [s for s in modules if s.startswith('interface')] if interface: if len(interface) > 1: raise mesonlib.MesonException(f'Only one interface must be specified, found: {interface}') self.interface = interface[0].split(' ')[1] else: self.interface = 'lp64' self.needs_cblas = 'cblas' in modules self.needs_lapack = 'lapack' in modules self.needs_lapacke = 'lapacke' in modules def check_symbols(self, compile_args, suffix=None, check_cblas=True, check_lapacke=True, lapack_only=False) -> None: # verify that we've found the right LP64/ILP64 interface symbols = [] if not lapack_only: symbols += ['dgemm_'] if check_cblas and self.needs_cblas: symbols += ['cblas_dgemm'] if self.needs_lapack: symbols += ['zungqr_'] if check_lapacke and self.needs_lapacke: symbols += ['LAPACKE_zungqr'] if suffix is None: suffix = self.get_symbol_suffix() prototypes = "".join(f"void {symbol}{suffix}();\n" for symbol in symbols) calls = " ".join(f"{symbol}{suffix}();\n" for symbol in symbols) code = (f"{prototypes}" "int main(int argc, const char *argv[])\n" "{\n" f" {calls}" " return 0;\n" "}" ) code = '''#ifdef __cplusplus extern "C" { #endif ''' + code + ''' #ifdef __cplusplus } #endif ''' return self.clib_compiler.links(code, self.env, extra_args=compile_args)[0] def get_variable(self, **kwargs: T.Dict[str, T.Any]) -> str: # TODO: what's going on with `get_variable`? Need to pick from # cmake/pkgconfig/internal/..., but not system? varname = kwargs['pkgconfig'] if varname == 'interface': return self.interface elif varname == 'symbol_suffix': return self.get_symbol_suffix() return super().get_variable(**kwargs) class OpenBLASMixin(): def get_symbol_suffix(self) -> str: return '' if self.interface == 'lp64' else self._ilp64_suffix def probe_symbols(self, compile_args) -> bool: """There are two common ways of building ILP64 BLAS, check which one we're dealing with""" if self.interface == 'lp64': return self.check_symbols(compile_args) if self.check_symbols(compile_args, '64_'): self._ilp64_suffix = '64_' elif self.check_symbols(compile_args, ''): self._ilp64_suffix = '' else: return False return True class OpenBLASSystemDependency(BLASLAPACKMixin, OpenBLASMixin, SystemDependency): def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: super().__init__(name, environment, kwargs) self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) # First, look for paths specified in a machine file props = self.env.properties[self.for_machine].properties if any(x in props for x in ['openblas_includedir', 'openblas_librarydir']): self.detect_openblas_machine_file(props) # Then look in standard directories by attempting to link if not self.is_found: extra_libdirs: T.List[str] = [] self.detect(extra_libdirs) if self.is_found: self.version = self.detect_openblas_version() def detect(self, lib_dirs: T.Optional[T.List[str]] = None, inc_dirs: T.Optional[T.List[str]] = None) -> None: if lib_dirs is None: lib_dirs = [] if inc_dirs is None: inc_dirs = [] if self.interface == 'lp64': libnames = ['openblas'] elif self.interface == 'ilp64': libnames = ['openblas64', 'openblas_ilp64', 'openblas'] for libname in libnames: link_arg = self.clib_compiler.find_library(libname, self.env, lib_dirs) if link_arg: incdir_args = [f'-I{inc_dir}' for inc_dir in inc_dirs] for hdr in ['openblas_config.h', 'openblas/openblas_config.h']: found_header, _ = self.clib_compiler.has_header(hdr, '', self.env, dependencies=[self], extra_args=incdir_args) if found_header: self._openblas_config_header = hdr break if link_arg and found_header: if not self.probe_symbols(link_arg): continue self.is_found = True self.link_args += link_arg self.compile_args += incdir_args break def detect_openblas_machine_file(self, props: dict) -> None: has_dirs, _dirs = check_blas_machine_file('openblas', props) if has_dirs: libdir, incdir = _dirs self.detect([libdir], [incdir]) def detect_openblas_version(self) -> str: v, _ = self.clib_compiler.get_define('OPENBLAS_VERSION', f'#include <{self._openblas_config_header}>', self.env, [], [self]) m = re.search(r'\d+(?:\.\d+)+', v) if not m: mlog.debug('Failed to extract openblas version information') return None return m.group(0) class OpenBLASPkgConfigDependency(BLASLAPACKMixin, OpenBLASMixin, PkgConfigDependency): def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) if self.interface == 'lp64' and name != 'openblas': # Check only for 'openblas' for LP64 (there are multiple names for ILP64) self.is_found = False return None super().__init__(name, env, kwargs) if self.is_found and not self.probe_symbols(self.link_args): self.is_found = False class OpenBLASCMakeDependency(BLASLAPACKMixin, OpenBLASMixin, CMakeDependency): def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None, force_use_global_compilers: bool = False) -> None: super().__init__('OpenBLAS', env, kwargs, language, force_use_global_compilers) self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) if self.interface == 'ilp64': self.is_found = False elif self.is_found and not self.probe_symbols(self.link_args): self.is_found = False class NetlibMixin(): def get_symbol_suffix(self) -> str: self._ilp64_suffix = '' # Handle `64_` suffix, or custom suffixes? return '' if self.interface == 'lp64' else self._ilp64_suffix def probe_symbols(self, compile_args, check_cblas=True, check_lapacke=True, lapack_only=False) -> bool: """Most ILP64 BLAS builds will not use a suffix, but the new standard will be _64 (see Reference-LAPACK/lapack#666). Check which one we're dealing with""" if self.interface == 'lp64': return self.check_symbols(compile_args, check_cblas=check_cblas, check_lapacke=check_lapacke, lapack_only=lapack_only) if self.check_symbols(compile_args, '_64', check_cblas=check_cblas, check_lapacke=check_lapacke, lapack_only=lapack_only): self._ilp64_suffix = '_64' elif self.check_symbols(compile_args, '', check_cblas=check_cblas, check_lapacke=check_lapacke, lapack_only=lapack_only): self._ilp64_suffix = '' else: return False return True class NetlibBLASPkgConfigDependency(BLASLAPACKMixin, NetlibMixin, PkgConfigDependency): def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: # TODO: add ILP64 - needs factory function like for OpenBLAS super().__init__(name, env, kwargs) self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) if self.is_found: if self.needs_cblas: # `name` may be 'blas' or 'blas64'; CBLAS library naming should be consistent # with BLAS library naming, so just prepend 'c' and try to detect it. try: cblas_pc = PkgConfigDependency('c'+name, env, kwargs) if cblas_pc.found(): self.link_args += cblas_pc.link_args self.compile_args += cblas_pc.compile_args except DependencyException: pass if not self.probe_symbols(self.link_args): self.is_found = False class NetlibBLASSystemDependency(BLASLAPACKMixin, NetlibMixin, SystemDependency): def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: super().__init__(name, environment, kwargs) self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) # First, look for paths specified in a machine file props = self.env.properties[self.for_machine].properties if any(x in props for x in ['blas_includedir', 'blas_librarydir']): self.detect_blas_machine_file(props) # Then look in standard directories by attempting to link if not self.is_found: extra_libdirs: T.List[str] = [] self.detect(extra_libdirs) if self.is_found: self.version = 'unknown' # no way to derive this from standard headers def detect(self, lib_dirs: T.Optional[T.List[str]] = None, inc_dirs: T.Optional[T.List[str]] = None) -> None: if lib_dirs is None: lib_dirs = [] if inc_dirs is None: inc_dirs = [] if self.interface == 'lp64': libnames = ['blas'] cblas_headers = ['cblas.h'] elif self.interface == 'ilp64': libnames = ['blas64', 'blas'] cblas_headers = ['cblas_64.h', 'cblas.h'] for libname in libnames: link_arg = self.clib_compiler.find_library(libname, self.env, lib_dirs) if not link_arg: continue # libblas may include CBLAS symbols (Debian builds it like this), # but more often than not there's a separate libcblas library. Handle both cases. if not self.probe_symbols(link_arg, check_cblas=False): continue if self.needs_cblas: cblas_in_blas = self.probe_symbols(link_arg, check_cblas=True) if self.needs_cblas and not cblas_in_blas: # We found libblas and it does not contain CBLAS symbols, so we need libcblas cblas_libname = 'c' + libname link_arg_cblas = self.clib_compiler.find_library(cblas_libname, self.env, lib_dirs) if link_arg_cblas: link_arg.extend(link_arg_cblas) else: # We didn't find CBLAS continue self.is_found = True self.link_args += link_arg if self.needs_cblas: incdir_args = [f'-I{inc_dir}' for inc_dir in inc_dirs] for hdr in cblas_headers: found_header, _ = self.clib_compiler.has_header(hdr, '', self.env, dependencies=[self], extra_args=incdir_args) if found_header: # If we don't get here, we found the library but not the header - this may # be okay, since projects may ship their own CBLAS header for portability) self.compile_args += incdir_args break def detect_blas_machine_file(self, props: dict) -> None: has_dirs, _dirs = check_blas_machine_file('blas', props) if has_dirs: libdir, incdir = _dirs self.detect([libdir], [incdir]) class NetlibLAPACKPkgConfigDependency(BLASLAPACKMixin, NetlibMixin, PkgConfigDependency): def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: # TODO: add ILP64 (needs factory function like for OpenBLAS) super().__init__(name, env, kwargs) self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) if self.is_found: if self.needs_lapacke: # Similar to CBLAS: there may be a separate liblapacke.so try: lapacke_pc = PkgConfigDependency(name+'e', env, kwargs) if lapacke_pc.found(): self.link_args += lapacke_pc.link_args self.compile_args += lapacke_pc.compile_args except DependencyException: pass if not self.probe_symbols(self.link_args, lapack_only=True): self.is_found = False class NetlibLAPACKSystemDependency(BLASLAPACKMixin, NetlibMixin, SystemDependency): def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: super().__init__(name, environment, kwargs) self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) # First, look for paths specified in a machine file props = self.env.properties[self.for_machine].properties if any(x in props for x in ['lapack_includedir', 'lapack_librarydir']): self.detect_lapack_machine_file(props) # Then look in standard directories by attempting to link if not self.is_found: extra_libdirs: T.List[str] = [] self.detect(extra_libdirs) if self.is_found: self.version = 'unknown' # no way to derive this from standard headers def detect(self, lib_dirs: T.Optional[T.List[str]] = None, inc_dirs: T.Optional[T.List[str]] = None) -> None: if lib_dirs is None: lib_dirs = [] if inc_dirs is None: inc_dirs = [] if self.interface == 'lp64': libnames = ['lapack'] lapacke_headers = ['lapacke.h'] elif self.interface == 'ilp64': libnames = ['lapack64', 'lapack'] lapacke_headers = ['lapacke_64.h', 'lapacke.h'] for libname in libnames: link_arg = self.clib_compiler.find_library(libname, self.env, lib_dirs) if not link_arg: continue if not self.probe_symbols(link_arg, check_lapacke=False, lapack_only=True): continue if self.needs_lapacke: lapacke_in_lapack = self.probe_symbols(link_arg, check_lapacke=True, lapack_only=True) if self.needs_lapacke and not lapacke_in_lapack: # We found liblapack and it does not contain LAPACKE symbols, so we need liblapacke lapacke_libname = libname + 'e' link_arg_lapacke = self.clib_compiler.find_library(lapacke_libname, self.env, lib_dirs) if link_arg_lapacke: link_arg.extend(link_arg_lapacke) else: # We didn't find LAPACKE continue self.is_found = True self.link_args += link_arg if self.needs_lapacke: incdir_args = [f'-I{inc_dir}' for inc_dir in inc_dirs] for hdr in lapacke_headers: found_header, _ = self.clib_compiler.has_header(hdr, '', self.env, dependencies=[self], extra_args=incdir_args) if found_header: # If we don't get here, we found the library but not the header - this may # be okay, since projects may ship their own LAPACKE header for portability) self.compile_args += incdir_args break def detect_lapack_machine_file(self, props: dict) -> None: has_dirs, _dirs = check_blas_machine_file('lapack', props) if has_dirs: libdir, incdir = _dirs self.detect([libdir], [incdir]) class AccelerateSystemDependency(BLASLAPACKMixin, SystemDependency): """ Accelerate is always installed on macOS, and not available on other OSes. We only support using Accelerate on macOS >=13.3, where Apple shipped a major update to Accelerate, fixed a lot of bugs, and bumped the LAPACK version from 3.2 to 3.9. The older Accelerate version is still available, and can be obtained as a standard Framework dependency with one of: dependency('Accelerate') dependency('appleframeworks', modules : 'Accelerate') """ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: super().__init__(name, environment, kwargs) self.feature_since = ('1.3.0', '') self.parse_modules(kwargs) for_machine = MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST if ( (environment.machines[for_machine].system == 'darwin' and self.check_macOS_recent_enough()) or (environment.machines[for_machine].system == 'ios' and self.check_iOS_recent_enough()) ): self.detect(kwargs) def check_macOS_recent_enough(self) -> bool: macos_version = platform.mac_ver()[0] deploy_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', macos_version) if not mesonlib.version_compare(deploy_target, '>=13.3'): return False # We also need the SDK to be >=13.3 (meaning at least XCode 14.3) cmd = ['xcrun', '-sdk', 'macosx', '--show-sdk-version'] sdk_version = subprocess.run(cmd, capture_output=True, check=True, text=True).stdout.strip() return mesonlib.version_compare(sdk_version, '>=13.3') def check_iOS_recent_enough(self) -> bool: ios_version = platform.ios_ver().system deploy_target = os.environ.get('IPHONEOS_DEPLOYMENT_TARGET', ios_version) if not mesonlib.version_compare(deploy_target, '>=16.4'): return False # We also need the SDK to be >=16.4 sdk = "iphonesimulator" if platform.ios_ver().is_simulator else "iphoneos" cmd = ['xcrun', '-sdk', sdk, '--show-sdk-version'] sdk_version = subprocess.run(cmd, capture_output=True, check=True, text=True).stdout.strip() return mesonlib.version_compare(sdk_version, '>=16.4') def detect(self, kwargs: T.Dict[str, T.Any]) -> None: from .framework import ExtraFrameworkDependency dep = ExtraFrameworkDependency('Accelerate', self.env, kwargs) self.is_found = dep.is_found if self.is_found: self.compile_args = dep.compile_args self.link_args = dep.link_args self.compile_args += ['-DACCELERATE_NEW_LAPACK'] if self.interface == 'ilp64': self.compile_args += ['-DACCELERATE_LAPACK_ILP64'] # We won't check symbols here, because Accelerate is built in a consistent fashion # with known symbol mangling, unlike OpenBLAS or Netlib BLAS/LAPACK. def get_symbol_suffix(self) -> str: return '$NEWLAPACK' if self.interface == 'lp64' else '$NEWLAPACK$ILP64' class MKLMixin(): def get_symbol_suffix(self) -> str: return '' if self.interface == 'lp64' else '_64' def parse_mkl_options(self, kwargs: T.Dict[str, T.Any]) -> None: """Parse `modules` and remove threading and SDL options from it if they are present. Removing 'threading: ' and 'sdl' from `modules` is needed to ensure those don't get to the generic parse_modules() method for all BLAS/LAPACK dependencies. """ modules: T.List[str] = mesonlib.extract_as_list(kwargs, 'modules') threading_module = [s for s in modules if s.startswith('threading')] sdl_module = [s for s in modules if s.startswith('sdl')] if not threading_module: self.threading = 'iomp' elif len(threading_module) > 1: raise mesonlib.MesonException(f'Multiple threading arguments: {threading_module}') else: # We have a single threading option specified - validate and process it opt = threading_module[0] if opt not in ['threading: ' + s for s in ('seq', 'iomp', 'gomp', 'tbb')]: raise mesonlib.MesonException(f'Invalid threading argument: {opt}') self.threading = opt.split(' ')[1] modules = [s for s in modules if not s == opt] kwargs['modules'] = modules if not sdl_module: self.use_sdl = 'auto' elif len(sdl_module) > 1: raise mesonlib.MesonException(f'Multiple sdl arguments: {threading_module}') else: # We have a single sdl option specified - validate and process it opt = sdl_module[0] if opt not in ['sdl: ' + s for s in ('true', 'false', 'auto')]: raise mesonlib.MesonException(f'Invalid sdl argument: {opt}') self.use_sdl = { 'false': False, 'true': True, 'auto': 'auto' }.get(opt.split(' ')[1]) modules = [s for s in modules if not s == opt] kwargs['modules'] = modules # Parse common BLAS/LAPACK options self.parse_modules(kwargs) # Check if we don't have conflicting options between SDL's defaults and interface/threading self.sdl_default_opts = self.interface == 'lp64' and self.threading == 'iomp' if self.use_sdl == 'auto' and not self.sdl_default_opts: self.use_sdl = False elif self.use_sdl and not self.sdl_default_opts: # If we're here, we got an explicit `sdl: 'true'` raise mesonlib.MesonException(f'Linking SDL implies using LP64 and Intel OpenMP, found ' f'conflicting options: {self.interface}, {self.threading}') class MKLPkgConfigDependency(BLASLAPACKMixin, MKLMixin, PkgConfigDependency): """ pkg-config files for MKL were fixed recently, and should work from 2023.0 onwards. Directly using a specific one like so should work: dependency('mkl-dynamic-ilp64-seq') The naming scheme is `mkl-libtype-interface-threading.pc`, with values: - libtype: dynamic/static - interface: lp64/ilp64 - threading: seq/iomp/gomp/tbb Furthermore there is a pkg-config file for the Single Dynamic Library (libmkl_rt.so) named `mkl-sdl.pc` (only added in 2023.0). Note that there is also an MKLPkgConfig dependency in scalapack.py, which has more manual fixes. """ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: self.feature_since = ('1.3.0', '') self.parse_mkl_options(kwargs) if self.use_sdl == 'auto': # Layered libraries are preferred, and .pc files for layered were # available before the .pc file for SDL self.use_sdl = False static_opt = kwargs.get('static', env.coredata.optstore.get_value_for(OptionKey('prefer_static'))) libtype = 'static' if static_opt else 'dynamic' if self.use_sdl: name = 'mkl-sdl' else: name = f'mkl-{libtype}-{self.interface}-{self.threading}' super().__init__(name, env, kwargs) class MKLSystemDependency(BLASLAPACKMixin, MKLMixin, SystemDependency): """This only detects MKL's Single Dynamic Library (SDL)""" def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None: super().__init__(name, environment, kwargs) self.feature_since = ('1.3.0', '') self.parse_mkl_options(kwargs) if self.use_sdl == 'auto': # Too complex to use layered here - only supported with pkg-config self.use_sdl = True if self.use_sdl: self.detect_sdl() def detect_sdl(self) -> None: # Use MKLROOT in addition to standard libdir(s) _m = os.environ.get('MKLROOT') mklroot = Path(_m).resolve() if _m else None lib_dirs = [] inc_dirs = [] if mklroot is not None: libdir = mklroot / 'lib' / 'intel64' if not libdir.exists(): # MKLROOT may be pointing at the prefix where MKL was installed from PyPI # or Conda (Intel supports those install methods, but dropped the `intel64` # part, libraries go straight into /lib libdir = mklroot / 'lib' incdir = mklroot / 'include' lib_dirs += [libdir] inc_dirs += [incdir] if not libdir.exists() or not incdir.exists(): mlog.warning(f'MKLROOT env var set to {mklroot}, but not pointing to an MKL install') link_arg = self.clib_compiler.find_library('mkl_rt', self.env, lib_dirs) if link_arg: incdir_args = [f'-I{inc_dir}' for inc_dir in inc_dirs] found_header, _ = self.clib_compiler.has_header('mkl_version.h', '', self.env, dependencies=[self], extra_args=incdir_args) if link_arg and found_header: self.is_found = True self.compile_args += incdir_args self.link_args += link_arg if sys.platform != 'win32': self.link_args += ['-lpthread', '-lm', '-ldl'] # Determine MKL version ver, _ = self.clib_compiler.get_define('INTEL_MKL_VERSION', '#include "mkl_version.h"', self.env, dependencies=[self], extra_args=incdir_args) if len(ver) == 8: year = ver[:4] minor = str(int(ver[4:6])) update = str(int(ver[6:])) # Note: this is the order as of 2023.2.0, but it looks the wrong way around # (INTEL_MKL_VERSION is defined as 20230002 in that release), could be swapped in the future perhaps self.version = f'{year}.{update}.{minor}' else: mlog.warning(f'MKL version detection issue, found {ver}') @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.CMAKE}) def openblas_factory(env: 'Environment', for_machine: 'MachineChoice', kwargs: T.Dict[str, T.Any], methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']: candidates: T.List['DependencyGenerator'] = [] if DependencyMethods.PKGCONFIG in methods: for pkg in ['openblas64', 'openblas_ilp64', 'openblas']: candidates.append(functools.partial( OpenBLASPkgConfigDependency, pkg, env, kwargs)) if DependencyMethods.SYSTEM in methods: candidates.append(functools.partial( OpenBLASSystemDependency, 'openblas', env, kwargs)) if DependencyMethods.CMAKE in methods: candidates.append(functools.partial( OpenBLASCMakeDependency, 'OpenBLAS', env, kwargs)) return candidates packages['openblas'] = openblas_factory packages['blas'] = netlib_factory = DependencyFactory( 'blas', [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM], pkgconfig_class=NetlibBLASPkgConfigDependency, system_class=NetlibBLASSystemDependency, ) packages['lapack'] = netlib_factory = DependencyFactory( 'lapack', [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM], pkgconfig_class=NetlibLAPACKPkgConfigDependency, system_class=NetlibLAPACKSystemDependency, ) packages['accelerate'] = accelerate_factory = DependencyFactory( 'accelerate', [DependencyMethods.SYSTEM], system_class=AccelerateSystemDependency, ) packages['mkl'] = mkl_factory = DependencyFactory( 'mkl', [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM], pkgconfig_class=MKLPkgConfigDependency, system_class=MKLSystemDependency, )