def prepare_step(self, *args, **kwargs):
"""Do the bundle prepare step to ensure any deps are loaded at a minimum."""
if self.cfg['generate_standalone_module']:
if self.cfg['name'] in ['GCC', 'GCCcore']:
EB_GCC.prepare_step(self, *args, **kwargs)
elif self.cfg['name'] in ['icc']:
EB_icc.prepare_step(self, *args, **kwargs)
elif self.cfg['name'] in ['ifort']:
EB_ifort.prepare_step(self, *args, **kwargs)
else:
raise EasyBuildError(
"I don't know how to do the prepare_step for %s",
self.cfg['name'])
else:
Bundle.prepare_step(self, *args, **kwargs)
def extra_options(extra_vars=None):
"""Easyconfig parameters specific to bundles of Python packages."""
if extra_vars is None:
extra_vars = {}
# combine custom easyconfig parameters of Bundle & PythonPackage
extra_vars = Bundle.extra_options(extra_vars)
return PythonPackage.extra_options(extra_vars)
def extra_options():
gfx_list_help_msg = "AMD GPU architectures to build for (if None, use defaults: %s)"
extra_vars = {
'gfx_list':
[None, gfx_list_help_msg % ', '.join(DEFAULT_GFX_ARCHS), CUSTOM],
}
return Bundle.extra_options(extra_vars)
def extra_options(extra_vars=None):
"""Easyconfig parameters specific to bundles of Python packages."""
if extra_vars is None:
extra_vars = {}
# combine custom easyconfig parameters of Bundle & PythonPackage
extra_vars = Bundle.extra_options(extra_vars)
return PythonPackage.extra_options(extra_vars)
def extra_options(extra_vars=None):
"""Easyconfig parameters specific to OpenSSL wrapper"""
extra_vars = Bundle.extra_options(extra_vars=extra_vars)
extra_vars.update({
'wrap_system_openssl': [True, 'Detect and wrap OpenSSL installation in host system', CUSTOM],
'minimum_openssl_version': [None, 'Minimum version of OpenSSL required in host system', CUSTOM],
})
return extra_vars
def extra_options():
extra_vars = {
'arch': [
None,
"Architecture to be used (em64t-unknown-linux-gnu%s)" %
', '.join([a for a in ['', '_smp', '_mpi']]), CUSTOM
],
}
return Bundle.extra_options(extra_vars)
def extra_options(extra_vars=None):
"""Easyconfig parameters specific to bundles of Python packages."""
#50 extra_vars = {
#51 'arch_name': [None, "Change julia's Project.toml pathname", CUSTOM],
#52 }
if extra_vars is None:
extra_vars = {}
# combine custom easyconfig parameters of Bundle & PythonPackage
extra_vars = Bundle.extra_options(extra_vars)
return JuliaPackage.extra_options(extra_vars)
def extra_options(extra_vars=None):
"""Easyconfig parameters specific to toolchains."""
if extra_vars is None:
extra_vars = {}
extra_vars.update({
'set_env_external_modules': [
False,
"Include setenv statements for toolchain components that use "
"an external module, based on available metadata", CUSTOM
],
})
return Bundle.extra_options(extra_vars=extra_vars)
def extra_options():
"""Add custom easyconfig parameters for SystemMPI easyblock."""
# Gather extra_vars from inherited classes, order matters to make sure bundle initialises correctly
extra_vars = ConfigureMake.extra_options()
extra_vars.update(EB_impi.extra_options())
extra_vars.update(Bundle.extra_options())
# Add an option to add all module path extensions to the resultant easyconfig
# This is useful if you are importing the MPI installation from a non-default path
extra_vars.update({
'generate_standalone_module': [False, "Add known path extensions and environment variables for the MPI "
"installation to the final module", CUSTOM],
})
return extra_vars
def extra_options():
"""Add custom easyconfig parameters for SystemMPI easyblock."""
# Gather extra_vars from inherited classes, order matters to make sure bundle initialises correctly
extra_vars = ConfigureMake.extra_options()
extra_vars.update(EB_impi.extra_options())
extra_vars.update(Bundle.extra_options())
# Add an option to add all module path extensions to the resultant easyconfig
# This is useful if you are importing the MPI installation from a non-default path
extra_vars.update({
'generate_standalone_module': [False, "Add known path extensions and environment variables for the MPI "
"installation to the final module", CUSTOM],
})
return extra_vars
def extra_options():
"""Add custom easyconfig parameters for SystemCompiler easyblock."""
# Gather extra_vars from inherited classes, order matters here to make this work without problems in __init__
extra_vars = EB_GCC.extra_options()
extra_vars.update(EB_icc.extra_options())
extra_vars.update(EB_ifort.extra_options())
extra_vars.update(Bundle.extra_options())
# Add an option to add all module path extensions to the resultant easyconfig
# This is useful if you are importing a compiler from a non-default path
extra_vars.update({
'generate_standalone_module': [
False,
"Add known path/library extensions and environment variables for the compiler to the final module",
CUSTOM
],
})
return extra_vars
def extra_options():
"""Add custom easyconfig parameters for SystemCompiler easyblock."""
# Gather extra_vars from inherited classes, order matters here to make this work without problems in __init__
extra_vars = EB_GCC.extra_options()
extra_vars.update(EB_icc.extra_options())
extra_vars.update(EB_ifort.extra_options())
extra_vars.update(Bundle.extra_options())
# Add an option to add all module path extensions to the resultant easyconfig
# This is useful if you are importing a compiler from a non-default path
extra_vars.update({
'generate_standalone_module': [
False,
"Add known path/library extensions and environment variables for the compiler to the final module",
CUSTOM
],
})
return extra_vars
def extra_options():
"""Custom easyconfig parameters for CrayPEToolchain"""
extra_vars = {
'PrgEnv': [
None,
'PrgEnv module to load, e.g., cray to load PrgEnv-cray, or None for automatic determination',
CUSTOM
],
'PrgEnv_load': [
True,
'Load the PrgEnv module (if True) or just set the corresponding environment variable (if False)',
CUSTOM
],
'PrgEnv_family': [
None,
'Declare to be a member of the PrgEnv family (if \'PrgEnv\), of the cpeToolchain family (if \'cpeToolchain\') or manually unload all known PrgEnv and cpe* modules (if None, needed when LMOD is not used)',
CUSTOM
],
'CPE_compiler': [
None,
'Versionless compiler module to load, or None for automatic determination',
CUSTOM
],
'CPE_version': [
None,
'Version of the CPE, if different from the version of the module',
CUSTOM
],
'CPE_load': [
'first',
'First load the cpe module (if \'first\'), after the PrgEnv module (if \'after\'), load it at the end (if \'last\'), or do not load the cpe module (if None)',
CUSTOM
],
'cray_targets': [[], 'Targetting modules to load', CUSTOM],
#'optional_example_param': [None, "Example optional custom parameter", CUSTOM],
}
return Bundle.extra_options(extra_vars)
def prepare_step(self, *args, **kwargs):
"""Load all dependencies, determine system MPI version, prefix and any associated envvars."""
# Do the bundle prepare step to ensure any deps are loaded (no need to worry about licences for Intel MPI)
Bundle.prepare_step(self, *args, **kwargs)
# Prepare additional parameters: determine system MPI version, prefix and any associated envvars.
mpi_name = self.cfg['name'].lower()
# Determine MPI wrapper path (real path, with resolved symlinks) to ensure it exists
if mpi_name == 'impi':
# For impi the version information is only found in *some* of the wrappers it ships, in particular it is
# not in mpicc
mpi_c_wrapper = 'mpiicc'
path_to_mpi_c_wrapper = which(mpi_c_wrapper)
if not path_to_mpi_c_wrapper:
mpi_c_wrapper = 'mpigcc'
path_to_mpi_c_wrapper = which(mpi_c_wrapper)
if not path_to_mpi_c_wrapper:
raise EasyBuildError(
"Could not find suitable MPI wrapper to extract version for impi"
)
else:
mpi_c_wrapper = 'mpicc'
path_to_mpi_c_wrapper = which(mpi_c_wrapper)
if path_to_mpi_c_wrapper:
path_to_mpi_c_wrapper = resolve_path(path_to_mpi_c_wrapper)
self.log.info(
"Found path to MPI implementation '%s' %s compiler (with symlinks resolved): %s",
mpi_name, mpi_c_wrapper, path_to_mpi_c_wrapper)
else:
raise EasyBuildError("%s not found in $PATH", mpi_c_wrapper)
# Determine MPI version, installation prefix and underlying compiler
if mpi_name in ('openmpi', 'spectrummpi'):
# Spectrum MPI is based on Open MPI so is also covered by this logic
output_of_ompi_info, _ = run_cmd("ompi_info", simple=False)
# Extract the version of the MPI implementation
if mpi_name == 'spectrummpi':
mpi_version_string = 'Spectrum MPI'
else:
mpi_version_string = 'Open MPI'
self.mpi_version = self.extract_ompi_setting(
mpi_version_string, output_of_ompi_info)
# Extract the installation prefix
self.mpi_prefix = self.extract_ompi_setting(
"Prefix", output_of_ompi_info)
# Extract any OpenMPI environment variables in the current environment and ensure they are added to the
# final module
self.mpi_env_vars = dict((key, value)
for key, value in os.environ.items()
if key.startswith('OMPI_'))
# Extract the C compiler used underneath the MPI implementation, check for the definition of OMPI_MPICC
self.mpi_c_compiler = self.extract_ompi_setting(
"C compiler", output_of_ompi_info)
elif mpi_name == 'impi':
# Extract the version of IntelMPI
# The prefix in the the mpiicc (or mpigcc) script can be used to extract the explicit version
contents_of_mpixcc = read_file(path_to_mpi_c_wrapper)
prefix_regex = re.compile(
r'(?<=compilers_and_libraries_)(.*)(?=/linux/mpi)', re.M)
self.mpi_version = None
res = prefix_regex.search(contents_of_mpixcc)
if res:
self.mpi_version = res.group(1)
else:
# old iimpi version
prefix_regex = re.compile(r'^prefix=(.*)$', re.M)
res = prefix_regex.search(contents_of_mpixcc)
if res:
self.mpi_version = res.group(1).split('/')[-1]
if self.mpi_version is None:
raise EasyBuildError("No version found for system Intel MPI")
else:
self.log.info("Found Intel MPI version %s for system MPI" %
self.mpi_version)
# Extract the installation prefix, if I_MPI_ROOT is defined, let's use that
i_mpi_root = os.environ.get('I_MPI_ROOT')
if i_mpi_root:
self.mpi_prefix = i_mpi_root
else:
# Else just go up three directories from where mpiicc is found
# (it's 3 because bin64 is a symlink to intel64/bin and we are assuming 64 bit)
self.mpi_prefix = os.path.dirname(
os.path.dirname(os.path.dirname(path_to_mpi_c_wrapper)))
# Extract any IntelMPI environment variables in the current environment and ensure they are added to the
# final module
self.mpi_env_vars = {}
for key, value in os.environ.items():
i_mpi_key = key.startswith('I_MPI_') or key.startswith(
'MPICH_')
mpi_profile_key = key.startswith('MPI') and key.endswith(
'PROFILE')
if i_mpi_key or mpi_profile_key:
self.mpi_env_vars[key] = value
# Extract the C compiler used underneath Intel MPI
compile_info, exit_code = run_cmd("%s -compile-info" %
mpi_c_wrapper,
simple=False)
if exit_code == 0:
self.mpi_c_compiler = compile_info.split(' ', 1)[0]
else:
raise EasyBuildError(
"Could not determine C compiler underneath Intel MPI, '%s -compiler-info' "
"returned %s", mpi_c_wrapper, compile_info)
else:
raise EasyBuildError("Unrecognised system MPI implementation %s",
mpi_name)
# Ensure install path of system MPI actually exists
if not os.path.exists(self.mpi_prefix):
raise EasyBuildError(
"Path derived for system MPI (%s) does not exist: %s!",
mpi_name, self.mpi_prefix)
self.log.debug(
"Derived version/install prefix for system MPI %s: %s, %s",
mpi_name, self.mpi_version, self.mpi_prefix)
# For the version of the underlying C compiler need to explicitly extract (to be certain)
self.c_compiler_version = extract_compiler_version(self.mpi_c_compiler)
self.log.debug(
"Derived compiler/version for C compiler underneath system MPI %s: %s, %s",
mpi_name, self.mpi_c_compiler, self.c_compiler_version)
# If EasyConfig specified "real" version (not 'system' which means 'derive automatically'), check it
if self.cfg['version'] == 'system':
self.log.info(
"Found specified version '%s', going with derived MPI version '%s'",
self.cfg['version'], self.mpi_version)
elif self.cfg['version'] == self.mpi_version:
self.log.info("Specified MPI version %s matches found version" %
self.mpi_version)
else:
raise EasyBuildError(
"Specified version (%s) does not match version reported by MPI (%s)",
self.cfg['version'], self.mpi_version)
def prepare_step(self, *args, **kwargs):
"""Do compiler appropriate prepare step, determine system compiler version and prefix."""
if self.cfg['generate_standalone_module']:
if self.cfg['name'] in ['GCC', 'GCCcore']:
EB_GCC.prepare_step(self, *args, **kwargs)
elif self.cfg['name'] in ['icc']:
EB_icc.prepare_step(self, *args, **kwargs)
elif self.cfg['name'] in ['ifort']:
EB_ifort.prepare_step(self, *args, **kwargs)
else:
raise EasyBuildError(
"I don't know how to do the prepare_step for %s",
self.cfg['name'])
else:
Bundle.prepare_step(self, *args, **kwargs)
# Determine compiler path (real path, with resolved symlinks)
compiler_name = self.cfg['name'].lower()
if compiler_name == 'gcccore':
compiler_name = 'gcc'
path_to_compiler = which(compiler_name)
if path_to_compiler:
path_to_compiler = resolve_path(path_to_compiler)
self.log.info(
"Found path to compiler '%s' (with symlinks resolved): %s",
compiler_name, path_to_compiler)
else:
raise EasyBuildError("%s not found in $PATH", compiler_name)
# Determine compiler version
self.compiler_version = extract_compiler_version(compiler_name)
# Determine installation prefix
if compiler_name == 'gcc':
# strip off 'bin/gcc'
self.compiler_prefix = os.path.dirname(
os.path.dirname(path_to_compiler))
elif compiler_name in ['icc', 'ifort']:
intelvars_fn = path_to_compiler + 'vars.sh'
if os.path.isfile(intelvars_fn):
self.log.debug(
"Trying to determine compiler install prefix from %s",
intelvars_fn)
intelvars_txt = read_file(intelvars_fn)
prod_dir_regex = re.compile(r'^PROD_DIR=(.*)$', re.M)
res = prod_dir_regex.search(intelvars_txt)
if res:
self.compiler_prefix = res.group(1)
else:
raise EasyBuildError(
"Failed to determine %s installation prefix from %s",
compiler_name, intelvars_fn)
else:
# strip off 'bin/intel*/icc'
self.compiler_prefix = os.path.dirname(
os.path.dirname(os.path.dirname(path_to_compiler)))
# For versions 2016+ of Intel compilers they changed the installation path so must shave off 2 more
# directories from result of the above
if LooseVersion(self.compiler_version) >= LooseVersion('2016'):
self.compiler_prefix = os.path.dirname(
os.path.dirname(self.compiler_prefix))
else:
raise EasyBuildError("Unknown system compiler %s" %
self.cfg['name'])
if not os.path.exists(self.compiler_prefix):
raise EasyBuildError(
"Path derived for system compiler (%s) does not exist: %s!",
compiler_name, self.compiler_prefix)
self.log.debug(
"Derived version/install prefix for system compiler %s: %s, %s",
compiler_name, self.compiler_version, self.compiler_prefix)
# If EasyConfig specified "real" version (not 'system' which means 'derive automatically'), check it
if self.cfg['version'] == 'system':
self.log.info(
"Found specified version '%s', going with derived compiler version '%s'",
self.cfg['version'], self.compiler_version)
elif self.cfg['version'] != self.compiler_version:
raise EasyBuildError(
"Specified version (%s) does not match version reported by compiler (%s)"
% (self.cfg['version'], self.compiler_version))
def prepare_step(self, *args, **kwargs):
"""Do the bundle prepare step to ensure any deps are loaded. No need to worry about licences for Intel MPI"""
Bundle.prepare_step(self, *args, **kwargs)
def prepare_step(self, *args, **kwargs):
"""Load all dependencies, determine system MPI version, prefix and any associated envvars."""
# Do the bundle prepare step to ensure any deps are loaded (no need to worry about licences for Intel MPI)
Bundle.prepare_step(self, *args, **kwargs)
# Prepare additional parameters: determine system MPI version, prefix and any associated envvars.
mpi_name = self.cfg['name'].lower()
# Determine MPI wrapper path (real path, with resolved symlinks) to ensure it exists
if mpi_name == 'impi':
# For impi the version information is only found in *some* of the wrappers it ships, in particular it is
# not in mpicc
mpi_c_wrapper = 'mpiicc'
path_to_mpi_c_wrapper = which(mpi_c_wrapper)
if not path_to_mpi_c_wrapper:
mpi_c_wrapper = 'mpigcc'
path_to_mpi_c_wrapper = which(mpi_c_wrapper)
if not path_to_mpi_c_wrapper:
raise EasyBuildError("Could not find suitable MPI wrapper to extract version for impi")
else:
mpi_c_wrapper = 'mpicc'
path_to_mpi_c_wrapper = which(mpi_c_wrapper)
if path_to_mpi_c_wrapper:
path_to_mpi_c_wrapper = resolve_path(path_to_mpi_c_wrapper)
self.log.info("Found path to MPI implementation '%s' %s compiler (with symlinks resolved): %s",
mpi_name, mpi_c_wrapper, path_to_mpi_c_wrapper)
else:
raise EasyBuildError("%s not found in $PATH", mpi_c_wrapper)
# Determine MPI version, installation prefix and underlying compiler
if mpi_name in ('openmpi', 'spectrummpi'):
# Spectrum MPI is based on Open MPI so is also covered by this logic
output_of_ompi_info, _ = run_cmd("ompi_info", simple=False)
# Extract the version of the MPI implementation
if mpi_name == 'spectrummpi':
mpi_version_string = 'Spectrum MPI'
else:
mpi_version_string = 'Open MPI'
self.mpi_version = self.extract_ompi_setting(mpi_version_string, output_of_ompi_info)
# Extract the installation prefix
self.mpi_prefix = self.extract_ompi_setting("Prefix", output_of_ompi_info)
# Extract any OpenMPI environment variables in the current environment and ensure they are added to the
# final module
self.mpi_env_vars = dict((key, value) for key, value in os.environ.iteritems() if key.startswith("OMPI_"))
# Extract the C compiler used underneath the MPI implementation, check for the definition of OMPI_MPICC
self.mpi_c_compiler = self.extract_ompi_setting("C compiler", output_of_ompi_info)
elif mpi_name == 'impi':
# Extract the version of IntelMPI
# The prefix in the the mpiicc (or mpigcc) script can be used to extract the explicit version
contents_of_mpixcc = read_file(path_to_mpi_c_wrapper)
prefix_regex = re.compile(r'(?<=compilers_and_libraries_)(.*)(?=/linux/mpi)', re.M)
self.mpi_version = None
res = prefix_regex.search(contents_of_mpixcc)
if res:
self.mpi_version = res.group(1)
else:
# old iimpi version
prefix_regex = re.compile(r'^prefix=(.*)$', re.M)
res = prefix_regex.search(contents_of_mpixcc)
if res:
self.mpi_version = res.group(1).split('/')[-1]
if self.mpi_version is None:
raise EasyBuildError("No version found for system Intel MPI")
else:
self.log.info("Found Intel MPI version %s for system MPI" % self.mpi_version)
# Extract the installation prefix, if I_MPI_ROOT is defined, let's use that
i_mpi_root = os.environ.get('I_MPI_ROOT')
if i_mpi_root:
self.mpi_prefix = i_mpi_root
else:
# Else just go up three directories from where mpiicc is found
# (it's 3 because bin64 is a symlink to intel64/bin and we are assuming 64 bit)
self.mpi_prefix = os.path.dirname(os.path.dirname(os.path.dirname(path_to_mpi_c_wrapper)))
# Extract any IntelMPI environment variables in the current environment and ensure they are added to the
# final module
self.mpi_env_vars = {}
for key, value in os.environ.iteritems():
i_mpi_key = key.startswith('I_MPI_') or key.startswith('MPICH_')
mpi_profile_key = key.startswith('MPI') and key.endswith('PROFILE')
if i_mpi_key or mpi_profile_key:
self.mpi_env_vars[key] = value
# Extract the C compiler used underneath Intel MPI
compile_info, exit_code = run_cmd("%s -compile-info" % mpi_c_wrapper, simple=False)
if exit_code == 0:
self.mpi_c_compiler = compile_info.split(' ', 1)[0]
else:
raise EasyBuildError("Could not determine C compiler underneath Intel MPI, '%s -compiler-info' "
"returned %s", mpi_c_wrapper, compile_info)
else:
raise EasyBuildError("Unrecognised system MPI implementation %s", mpi_name)
# Ensure install path of system MPI actually exists
if not os.path.exists(self.mpi_prefix):
raise EasyBuildError("Path derived for system MPI (%s) does not exist: %s!", mpi_name, self.mpi_prefix)
self.log.debug("Derived version/install prefix for system MPI %s: %s, %s",
mpi_name, self.mpi_version, self.mpi_prefix)
# For the version of the underlying C compiler need to explicitly extract (to be certain)
self.c_compiler_version = extract_compiler_version(self.mpi_c_compiler)
self.log.debug("Derived compiler/version for C compiler underneath system MPI %s: %s, %s",
mpi_name, self.mpi_c_compiler, self.c_compiler_version)
# If EasyConfig specified "real" version (not 'system' which means 'derive automatically'), check it
if self.cfg['version'] == 'system':
self.log.info("Found specified version '%s', going with derived MPI version '%s'",
self.cfg['version'], self.mpi_version)
elif self.cfg['version'] == self.mpi_version:
self.log.info("Specified MPI version %s matches found version" % self.mpi_version)
else:
raise EasyBuildError("Specified version (%s) does not match version reported by MPI (%s)",
self.cfg['version'], self.mpi_version)
def prepare_step(self, *args, **kwargs):
"""Do compiler appropriate prepare step, determine system compiler version and prefix."""
if self.cfg['generate_standalone_module']:
if self.cfg['name'] in ['GCC', 'GCCcore']:
EB_GCC.prepare_step(self, *args, **kwargs)
elif self.cfg['name'] in ['icc']:
EB_icc.prepare_step(self, *args, **kwargs)
elif self.cfg['name'] in ['ifort']:
EB_ifort.prepare_step(self, *args, **kwargs)
else:
raise EasyBuildError("I don't know how to do the prepare_step for %s", self.cfg['name'])
else:
Bundle.prepare_step(self, *args, **kwargs)
# Determine compiler path (real path, with resolved symlinks)
compiler_name = self.cfg['name'].lower()
if compiler_name == 'gcccore':
compiler_name = 'gcc'
path_to_compiler = which(compiler_name)
if path_to_compiler:
path_to_compiler = resolve_path(path_to_compiler)
self.log.info("Found path to compiler '%s' (with symlinks resolved): %s", compiler_name, path_to_compiler)
else:
raise EasyBuildError("%s not found in $PATH", compiler_name)
# Determine compiler version
self.compiler_version = extract_compiler_version(compiler_name)
# Determine installation prefix
if compiler_name == 'gcc':
# strip off 'bin/gcc'
self.compiler_prefix = os.path.dirname(os.path.dirname(path_to_compiler))
elif compiler_name in ['icc', 'ifort']:
intelvars_fn = path_to_compiler + 'vars.sh'
if os.path.isfile(intelvars_fn):
self.log.debug("Trying to determine compiler install prefix from %s", intelvars_fn)
intelvars_txt = read_file(intelvars_fn)
prod_dir_regex = re.compile(r'^PROD_DIR=(.*)$', re.M)
res = prod_dir_regex.search(intelvars_txt)
if res:
self.compiler_prefix = res.group(1)
else:
raise EasyBuildError("Failed to determine %s installation prefix from %s",
compiler_name, intelvars_fn)
else:
# strip off 'bin/intel*/icc'
self.compiler_prefix = os.path.dirname(os.path.dirname(os.path.dirname(path_to_compiler)))
# For versions 2016+ of Intel compilers they changed the installation path so must shave off 2 more
# directories from result of the above
if LooseVersion(self.compiler_version) >= LooseVersion('2016'):
self.compiler_prefix = os.path.dirname(os.path.dirname(self.compiler_prefix))
else:
raise EasyBuildError("Unknown system compiler %s" % self.cfg['name'])
if not os.path.exists(self.compiler_prefix):
raise EasyBuildError("Path derived for system compiler (%s) does not exist: %s!",
compiler_name, self.compiler_prefix)
self.log.debug("Derived version/install prefix for system compiler %s: %s, %s",
compiler_name, self.compiler_version, self.compiler_prefix)
# If EasyConfig specified "real" version (not 'system' which means 'derive automatically'), check it
if self.cfg['version'] == 'system':
self.log.info("Found specified version '%s', going with derived compiler version '%s'",
self.cfg['version'], self.compiler_version)
elif self.cfg['version'] != self.compiler_version:
raise EasyBuildError("Specified version (%s) does not match version reported by compiler (%s)" %
(self.cfg['version'], self.compiler_version))
