| # SPDX-License-Identifier: Apache-2.0 |
| # Copyright 2013-2019 The Meson development team |
| |
| from __future__ import annotations |
| |
| import functools |
| import typing as T |
| import os |
| import re |
| |
| from ..environment import detect_cpu_family |
| from ..mesonlib import Popen_safe |
| from .base import DependencyException, DependencyMethods, detect_compiler, SystemDependency |
| from .configtool import ConfigToolDependency |
| from .detect import packages |
| from .factory import factory_methods |
| from .pkgconfig import PkgConfigDependency |
| |
| if T.TYPE_CHECKING: |
| from .factory import DependencyGenerator |
| from ..environment import Environment |
| from ..mesonlib import MachineChoice |
| |
| |
| @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.SYSTEM}) |
| def mpi_factory(env: 'Environment', |
| for_machine: 'MachineChoice', |
| kwargs: T.Dict[str, T.Any], |
| methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']: |
| language = kwargs.get('language') |
| if language is None: |
| language = 'c' |
| if language not in {'c', 'cpp', 'fortran'}: |
| # OpenMPI doesn't work without any other languages |
| return [] |
| |
| candidates: T.List['DependencyGenerator'] = [] |
| compiler = detect_compiler('mpi', env, for_machine, language) |
| if not compiler: |
| return [] |
| compiler_is_intel = compiler.get_id() in {'intel', 'intel-cl'} |
| |
| if DependencyMethods.CONFIG_TOOL in methods: |
| nwargs = kwargs.copy() |
| |
| # We try the environment variables for the tools first, but then |
| # fall back to the hardcoded names |
| |
| if language == 'c': |
| env_vars = ['MPICC'] |
| elif language == 'cpp': |
| env_vars = ['MPICXX'] |
| elif language == 'fortran': |
| env_vars = ['MPIFC', 'MPIF90', 'MPIF77'] |
| |
| tool_names = [os.environ.get(env_name) for env_name in env_vars] |
| tool_names = [t for t in tool_names if t] # remove empty environment variables |
| |
| if compiler_is_intel: |
| if env.machines[for_machine].is_windows(): |
| nwargs['returncode_value'] = 3 |
| |
| if language == 'c': |
| tool_names.append('mpiicc') |
| elif language == 'cpp': |
| tool_names.append('mpiicpc') |
| elif language == 'fortran': |
| tool_names.append('mpiifort') |
| |
| # even with intel compilers, mpicc has to be considered |
| if language == 'c': |
| tool_names.append('mpicc') |
| elif language == 'cpp': |
| tool_names.extend(['mpic++', 'mpicxx', 'mpiCC']) |
| elif language == 'fortran': |
| tool_names.extend(['mpifort', 'mpif90', 'mpif77']) |
| |
| nwargs['tools'] = tool_names |
| candidates.append(functools.partial( |
| MPIConfigToolDependency, tool_names[0], env, nwargs, language=language)) |
| |
| if DependencyMethods.SYSTEM in methods and env.machines[for_machine].is_windows(): |
| candidates.append(functools.partial( |
| MSMPIDependency, 'msmpi', env, kwargs, language=language)) |
| |
| # Only OpenMPI has pkg-config, and it doesn't work with the intel compilers |
| # for MPI, environment variables and commands like mpicc should have priority |
| if DependencyMethods.PKGCONFIG in methods and not compiler_is_intel: |
| pkg_name = None |
| if language == 'c': |
| pkg_name = 'ompi-c' |
| elif language == 'cpp': |
| pkg_name = 'ompi-cxx' |
| elif language == 'fortran': |
| pkg_name = 'ompi-fort' |
| candidates.append(functools.partial( |
| PkgConfigDependency, pkg_name, env, kwargs, language=language)) |
| |
| return candidates |
| |
| packages['mpi'] = mpi_factory |
| |
| |
| class MPIConfigToolDependency(ConfigToolDependency): |
| """Wrapper around mpicc, Intel's mpiicc and friends.""" |
| |
| def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any], |
| language: T.Optional[str] = None): |
| super().__init__(name, env, kwargs, language=language) |
| if not self.is_found: |
| return |
| |
| # --showme for OpenMPI, -compile_info/-link_info for MPICH and IntelMPI |
| for comp, link in [('--showme:compile', '--showme:link'), ('-compile_info', '-link_info'), ('-show', None)]: |
| try: |
| c_args = self.get_config_value([comp], 'compile_args') |
| l_args = self.get_config_value([link], 'link_args') if link is not None else c_args |
| except DependencyException: |
| continue |
| else: |
| break |
| else: |
| self.is_found = False |
| return |
| |
| self.compile_args = self._filter_compile_args(c_args) |
| self.link_args = self._filter_link_args(l_args) |
| |
| def _filter_compile_args(self, args: T.List[str]) -> T.List[str]: |
| """ |
| MPI wrappers return a bunch of garbage args. |
| Drop -O2 and everything that is not needed. |
| """ |
| result = [] |
| multi_args: T.Tuple[str, ...] = ('-I', ) |
| if self.language == 'fortran': |
| fc = self.env.coredata.compilers[self.for_machine]['fortran'] |
| multi_args += fc.get_module_incdir_args() |
| |
| include_next = False |
| for f in args: |
| if f.startswith(('-D', '-f') + multi_args) or f == '-pthread' \ |
| or (f.startswith('-W') and f != '-Wall' and not f.startswith('-Werror')): |
| result.append(f) |
| if f in multi_args: |
| # Path is a separate argument. |
| include_next = True |
| elif include_next: |
| include_next = False |
| result.append(f) |
| return result |
| |
| def _filter_link_args(self, args: T.List[str]) -> T.List[str]: |
| """ |
| MPI wrappers return a bunch of garbage args. |
| Drop -O2 and everything that is not needed. |
| """ |
| result = [] |
| include_next = False |
| for f in args: |
| if self._is_link_arg(f): |
| result.append(f) |
| if f in {'-L', '-Xlinker'}: |
| include_next = True |
| elif include_next: |
| include_next = False |
| result.append(f) |
| return result |
| |
| def _is_link_arg(self, f: str) -> bool: |
| if self.clib_compiler.id == 'intel-cl': |
| return f == '/link' or f.startswith('/LIBPATH') or f.endswith('.lib') # always .lib whether static or dynamic |
| else: |
| return (f.startswith(('-L', '-l', '-Xlinker')) or |
| f == '-pthread' or |
| (f.startswith('-W') and f != '-Wall' and not f.startswith('-Werror'))) |
| |
| def _check_and_get_version(self, tool: T.List[str], returncode: int) -> T.Tuple[bool, T.Union[str, None]]: |
| p, out = Popen_safe(tool + ['--showme:version'])[:2] |
| valid = p.returncode == returncode |
| if valid: |
| # OpenMPI |
| v = re.search(r'\d+.\d+.\d+', out) |
| if v: |
| version = v.group(0) |
| else: |
| version = None |
| return valid, version |
| |
| # --version is not the same as -v |
| p, out = Popen_safe(tool + ['-v'])[:2] |
| valid = p.returncode == returncode |
| first_line = out.split('\n', maxsplit=1)[0] |
| |
| # cases like "mpicc for MPICH version 4.2.2" |
| v = re.search(r'\d+.\d+.\d+', first_line) |
| if v: |
| return valid, v.group(0) |
| |
| # cases like "mpigcc for Intel(R) MPI library 2021.13" |
| v = re.search(r'\d+.\d+', first_line) |
| if v: |
| return valid, v.group(0) |
| |
| # cases like "mpiifort for the Intel(R) MPI Library 2019 Update 9 for Linux*" |
| v = re.search(r'(\d{4}) Update (\d)', first_line) |
| if v: |
| return valid, f'{v.group(1)}.{v.group(2)}' |
| |
| return valid, None |
| |
| |
| class MSMPIDependency(SystemDependency): |
| |
| """The Microsoft MPI.""" |
| |
| def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any], |
| language: T.Optional[str] = None): |
| super().__init__(name, env, kwargs, language=language) |
| # MSMPI only supports the C API |
| if language not in {'c', 'fortran', None}: |
| self.is_found = False |
| return |
| # MSMPI is only for windows, obviously |
| if not self.env.machines[self.for_machine].is_windows(): |
| return |
| |
| incdir = os.environ.get('MSMPI_INC') |
| arch = detect_cpu_family(self.env.coredata.compilers.host) |
| libdir = None |
| if arch == 'x86': |
| libdir = os.environ.get('MSMPI_LIB32') |
| post = 'x86' |
| elif arch == 'x86_64': |
| libdir = os.environ.get('MSMPI_LIB64') |
| post = 'x64' |
| |
| if libdir is None or incdir is None: |
| self.is_found = False |
| return |
| |
| self.is_found = True |
| self.link_args = ['-l' + os.path.join(libdir, 'msmpi')] |
| self.compile_args = ['-I' + incdir, '-I' + os.path.join(incdir, post)] |
| if self.language == 'fortran': |
| self.link_args.append('-l' + os.path.join(libdir, 'msmpifec')) |
