aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to 'eclass/mpi.eclass')
-rw-r--r--eclass/mpi.eclass636
1 files changed, 288 insertions, 348 deletions
diff --git a/eclass/mpi.eclass b/eclass/mpi.eclass
index 3692a0313..29d8629b1 100644
--- a/eclass/mpi.eclass
+++ b/eclass/mpi.eclass
@@ -2,351 +2,103 @@
# Distributed under the terms of the GNU General Public License v2
# $Header: $
-# Description: This eclass is used to allow for the separation of mpi
-# implementations and dependant programs/libraries in
-# /usr/lib/mpi/<implementation>.
-#
-# Author(s): Justin Bronder <jsbronder@gentoo.org>
-#
-# Basic idea is directly stolen from crossdev and hence really relies on using
-# sys-cluster/empi. EmergeMPI basically creates new categories, pulls in a
-# single MPI providing ebuild that uses this eclass and builds. This eclass
-# handles pushing the entire install to a save place, /usr/lib/mpi/<name>.
-# Packages that depend on MPI can also use this eclass to get installed to
-# the same place using the correct MPI implementation.
-
-# Currently only autotools-enabled packages are handled with any sort of
-# elegance, and dealing with the standard Makefile-style builds that
-# are typical in hpc probably can't be made much easier.
-
-# NOTE: If using this eclass to build an implementation, you need to define
-# MPI_ESELECT_FILE which is the path relative to FILESDIR where the eselect
-# definition file can be found.
-
-
-# FUNCTIONS, at least those that are worth caring about!
-
-# mpi_src_compile: For each implementation, set $S correctly and then run
-# through do_config and do_make. Finally restore $S
-
-# mpi_src_install: For each implementation, set $S correctly, run
-# do_make_install and restore $S.
-
-# mpi_pkg_deplist: Prints deps for mpi enabled packages. Basically if using
-# empi, then we dep on empi-enabled implementations,
-# otherwise, the dep is just on virtual/mpi
-
-# mpi_imp_deplist: Prints deps for mpi implementations. As empi guarantees
-# blockers cannot be installed at the same root, this deps
-# on eselect-mpi for empi builds. Otherwise, prints a list
-# of blockers (all other mpi implementations).
-
-# mpi_built_with: Get the ${PN} of the implementation that was used to get
-# mpicc etc.
-
-# get_mpi_dir: Given an implementation, returns the base directory to
-# that programs should install to. I.E. --prefix for
-# autoconf.
-
-# is_empi_build: Are we building with empi? [[ ${CATEGORY} == mpi-* ]] as
-# empi forces this just so we can do that.
-
-# FUNCTIONS, directly used by the above interesting ones.
-
-# mpi_set_env <imp>: For lack of a better name, just exports the following based
-# on the desired implementation: CC, CXX, F77, FC, PATH
-# Set $mpi_env to "mpi_none" to ensure that this function
-# is not called.
-
-# mpi_restore_env: Undo the above.
-
-# For the following functions and those that call them, I've used indirect
-# referencing to allow for a clean way to have both defaults and to allow
-# different actions to be taken per implementation. Preference is given first
-# to ${implementation}_${var}, then mpi_${var} and finally defaults will be
-# used. All variables also allow "mpi_none", which disables that action.
-#
-# *_conf_cmd: configure command, default: econf
-# *_conf_args: configure arguments, no default
-# HOWEVER, note that prefix, mandir, infodir and datadir are
-# set if ${S}/configure is executable. Pass "mpi_none" to
-# disable this.
-# *_make_cmd: make command, default emake
-# *_make_args: make arguments, no default
-# *_make_install_cmd: make install command, default emake
-# *_make_install_args: make install arguments, default 'DESTDIR=${D} install'
-
-
-
-# mpi_do_config: $S should be set correctly to some ${P}-${imp}. Changes to
-# that dir, calls mpi_set_env, $conf_cmd $conf_args, and
-# rcalls mpi_restore_env.
-
-# mpi_do_make: Same as above but for building.
-# mpi_do_make_install: Same as above but for installing.
-
-
-# Variables:
-# MPI_ESELECT_FILE: Name of the eselect file in ${FILESDIR}
-# MPI_NOEMPI_BLOCKERS: String of packages we should block against if not using
-# empi. See mpich2 and mpd.
-# MPI_EMPI_COMPAT: String of all base implementations that this package
-# works with. See __MPI_EMPI_COMPAT, this is a list of
-# [><=]${PN}-${PVR} put into DEPEND with ||.
-
-inherit multilib flag-o-matic
-
-__MPI_EMPI_COMPAT="
- >=openmpi-1.2.5-r1
- >=lam-mpi-7.1.4-r1
- >=openib-mvapich2-1.0.1-r1
- >=mpich2-1.0.8"
-MPI_ALL_IMPS="mpich mpich2 openmpi lam-mpi openib-mvapich2"
-
-MPI_EMPI_COMPAT="${MPI_EMPI_COMPAT:-${__MPI_EMPI_COMPAT}}"
-#TODO: doc
-mpi_pkg_deplist() {
- local i ver
- if [ -z "$(get_imp)" ]; then
- ver="virtual/mpi"
- for i in ${MPI_NOEMPI_BLOCKERS}; do
- ver="${ver} !${i}"
- done
- else
- for i in ${MPI_EMPI_COMPAT}; do
- ver="${ver} ${CATEGORY}/${i}"
- done
- ver="|| (${ver} ) app-admin/eselect-mpi"
- fi
- echo "${ver}"
-}
+inherit multilib
-mpi_imp_deplist() {
- local i ver
- if ! is_empi_imp_build; then
- for i in ${MPI_ALL_IMPS}; do
- [ "${i}" != "${PN}" ] && ver="${ver} !sys-cluster/${i}"
- done
- for i in ${MPI_NOEMPI_BLOCKERS}; do
- ver="${ver} !${i}"
- done
- else
- ver="app-admin/eselect-mpi"
- fi
- echo "${ver}"
-}
+# @ECLASS: mpi.eclass
+# @MAINTAINER:
+# Justin Bronder <jsbronder@gentoo.org>
+# @BLURB: Common functions for mpi-pkg.eclass and mpi-imp.eclass
-is_imp_build() { [[ ${MPI_ALL_IMPS} == *${PN}* ]]; }
-is_empi_build() { [[ ${CATEGORY} == mpi-* ]]; }
-is_empi_imp_build() { is_imp_build && is_empi_build; }
+# History: (Is there a standard for this?)
+# 2008-11-20 (jsbronder): Initial rewrite from old mpi.eclass
-get_imp() {
- [[ ${CATEGORY} == mpi-* ]] && echo "${CATEGORY}"
-}
+#####################
+# Private Variables #
+#####################
-get_mpi_dir() {
- if is_empi_build; then
- echo "/usr/$(get_libdir)/mpi/${MPI_IMP}"
- fi
-}
+# All known mpi implementations
+__MPI_ALL_IMPLEMENTATION_PNS="mpich mpich2 openmpi lam-mpi openib-mvapich2"
+# All mpi implentations that can be classed.
+__MPI_ALL_CLASSABLE_PNS="openmpi mpich2 lam-mpi"
-get_eselect_var() { echo "$(eselect mpi printvar ${MPI_IMP} ${1})"; }
-mpi_built_with() { echo "$(get_eselect_var MPI_BUILT_WITH)"; }
-# Internal use: Get out of messy functions if we're not using empi to build and
-# therefore avoid tons of file collisions.
-bail_if_not_empi() { [ -z "${MPI_IMP}" ] && return 0; }
-#TODO: There must be a better way?
-# Currently can be turned off with mpi_env="mpi_none"
-mpi_set_env() {
- local p
- [ -z "${MPI_IMP}" ] && return 0
- is_empi_imp_build && return 0
- [[ ${mpi_env} == mpi_none ]] && return 0
+###################################################################
+# Generic Functions that are used by Implementations and Packages #
+###################################################################
- p="$(get_mpi_dir)"
-
- oCC=$CC
- oCXX=$CXX
- oF77=$F77
- oFC=$FC
- oPATH=$PATH
- oLLP=${LD_LIBRARY_PATH}
- export CC=$(get_eselect_var MPI_CC)
- export CXX=$(get_eselect_var MPI_CXX)
- export F77=$(get_eselect_var MPI_F77)
- export FC=$(get_eselect_var MPI_F90)
- export PATH="$(get_eselect_var PATH):${PATH}"
- export LD_LIBRARY_PATH="$(get_eselect_var LD_LIBRARY_PATH):${LD_LIBRARY_PATH}"
-# Handled by the wrappers, at least it better be.
-# append-ldflags $(eselect mpi ldflags ${MPI_IMP})
-# append-flags $(eselect mpi cflags ${MPI_IMP})
-}
+# @ECLASS-VARIABLE: MPI_UNCLASSED_BLOCKERS
+# @DESCRIPTION: Packages that are blockers when not using a classed install.
-mpi_restore_env() {
- [ -z "${MPI_IMP}" ] && return 0
- is_empi_imp_build && return 0
- [[ ${mpi_env} == mpi_none ]] && return 0
-
- export CC=$oCC
- export CXX=$oCXX
- export F77=$oF77
- export FC=$oFC
- export PATH=$oPATH
- export LD_LIBRARY_PATH=$oLLP
+# @FUNCTION: mpi_classed
+# @USAGE:
+# @RETURN: True if this build is classed.
+mpi_classed() {
+ [[ ${CATEGORY} == mpi-* ]]
}
-
-# Here's what we try to get, in order.
-# ${IMP_BUILT_WITH}_${var}
-# mpi_${var}
-get_mpi_var() {
- local varname=${1}
- local t ret
-
- if is_imp_build; then
- t="${PN}_${varname}"
- elif is_empi_build; then
- t=$(mpi_built_with)
- t=${t%%-[0-9]*}
- t="${t}_${varname}"
- fi
- [ -n "${t}" ] && ret="${!t}"
-
- if [ -z "${ret}" ]; then
- t="mpi_${varname}"
- ret=${!t}
- fi
-
- if [ -z "${ret}" ]; then
- case ${varname} in
- conf_cmd)
- ret="econf"
- ;;
- make_cmd|make_install_cmd)
- ret="emake"
- ;;
- esac
- fi
- echo "${ret}"
+# @FUNCTION: mpi_class
+# @USAGE:
+# @RETURN: The name of the current class, or nothing if unclassed.
+mpi_class() {
+ mpi_classed && echo "${CATEGORY}"
}
-mpi_do_config() {
- local conf_cmd=$(get_mpi_var "conf_cmd")
- local conf_args=$(get_mpi_var "conf_args")
- local default_args rc d
-
- d="$(get_mpi_dir)"
- [[ "${conf_cmd}" == "mpi_none" ]] && return 0
- [[ -x ${S}/configure && -n "${MPI_IMP}" ]] \
- && default_args="--prefix=${d}/usr/
- --mandir=${d}/usr/share/man
- --infodir=${d}/usr/share/info
- --datadir=${d}/usr/share/
- --sysconfdir=/etc/${MPI_IMP}/
- --localstatedir=/var/lib/${MPI_IMP}"
- [[ "${conf_args}" == *mpi_none* ]] && default_args=""
-
- mpi_set_env
- ${conf_cmd} ${default_args} ${conf_args}; rc=$?
- mpi_restore_env
- return ${rc}
-}
-
-mpi_do_make() {
- local make_cmd=$(get_mpi_var "make_cmd")
- local make_args=$(get_mpi_var "make_args")
- local rc
-
- [[ "${make_cmd}" == "mpi_none" ]] && return 0
-
- mpi_set_env
- ${make_cmd} ${make_args}; rc=$?
- mpi_restore_env
- return ${rc}
-}
-
-
-mpi_do_make_install() {
- local make_cmd=$(get_mpi_var "make_install_cmd")
- local make_args=$(get_mpi_var "make_install_args")
- local default_args="DESTDIR=\"${D}\" install"
- local rc
-
- [[ "${make_cmd}" == "mpi_none" ]] && return 0
- [[ "${make_args}" == "mpi_none" ]] && default_args=""
-
- mpi_set_env
- ${make_cmd} ${default_args} ${make_args}; rc=$?
- mpi_restore_env
- return ${rc}
-}
-
-mpi_src_compile() {
- # Be nice and check at the earliest moment so the user doesn't watch
- # everything compile only to have the emerge blow up.
- if is_empi_imp_build && [ ! -f "${FILESDIR}"/${MPI_ESELECT_FILE} ]; then
- die "MPI_ESELECT_FILE is not defined/found. ${MPI_ESELECT_FILE}"
+# @FUNCTION: mpi_root
+# @USAGE:
+# @RETURN: The root path that packages should start installing to. In the end,
+# the majority of a package will will install to ${ROOT}$(mpi_root).
+mpi_root() {
+ if mpi_classed; then
+ echo "/usr/$(get_libdir)/mpi/$(mpi_class)/"
+ else
+ echo "/"
fi
-
- pushd "${S}" &>/dev/null
- mpi_do_config || die "mpi_src_compile: mpi_do_config failed."
- mpi_do_make || die "mpi_src_compile: mpi_do_make failed."
- popd &>/dev/null
}
-mpi_src_install() {
- pushd "${S}" &>/dev/null
- mpi_do_make_install \
- || die "mpi_src_install(${MPI_IMP}) mpi_do_make_install failed."
- popd &>/dev/null
-
- [ -z "${MPI_IMP}" ] && return 0
- if is_empi_imp_build; then
- mpi_add_eselect
+# @FUNCTION: mpi_econf_args
+# @USAGE:
+# @DESCRIPTION: If classed, returns a list of arguments for econf that sets the
+# default install locations correctly. Should be first in the list of arguments
+# to econf so that any unsuitable options can be overwritten.
+mpi_econf_args() {
+ if mpi_classed; then
+ local d=$(mpi_root)
+ local c=$(mpi_class)
+ local a="
+ --prefix=${d}usr
+ --mandir=${d}usr/share/man
+ --infodir=${d}usr/share/info
+ --datadir=${d}usr/share
+ --sysconfdir=/etc/${c}
+ --localstatedir=/var/lib/${c}"
+ echo "${a}"
fi
}
-mpi_pkg_setup() {
- # Make sure this eclass should be used.
- MPI_IMP=$(get_imp)
- [ -z "${MPI_IMP}" ] && return 0
-
- if [[ -z ${MPI_IMP} ]]; then
- die "Building without empi and bail_if_not_empi failed."
- fi
-
- if ! is_empi_imp_build; then
- einfo "mpi: Building against implementation ${MPI_IMP}."
- fi
-}
-
-mpi_add_eselect() {
- cp "${FILESDIR}"/${MPI_ESELECT_FILE} ${T}/${MPI_IMP}.eselect || die
- sed -i \
- -e "s|@ROOT@|$(get_mpi_dir)|g" \
- -e "s|@LIBDIR@|$(get_libdir)|g" \
- -e "s|@BUILT_WITH@|${PF}|g" \
- ${T}/${MPI_IMP}.eselect
-
- eselect mpi add "${T}"/${MPI_IMP}.eselect
-}
-
-
-
-# Handles all the mpi_{do,new} functions below.
-# Not handled because there is no good way:
-# doconfd doenvd domo doinitd
-mpi_do() {
+# @FUNCTION: _mpi_do
+# @USAGE: $1 - Standard ebuild command to replicate.
+# @DESCRIPTION: Large wrapping class for all of the {do,new}* commands that need
+# to respect the new root to install to. Works with unclassed builds as well.
+# Currently supports:
+# @CODE
+# dobin newbin dodoc newdoc
+# doexe newexe dohtml dolib
+# dolib.a newlib.a dolib.so newlib.so
+# dosbin newsbin doman newman
+# doinfo dodir dohard doins
+# dosym
+# @CODE
+
+_mpi_do() {
local rc prefix
local cmd=${1}
local ran=1
local slash=/
- local mdir="$(get_mpi_dir)/"
+ local mdir="$(mpi_root)"
- if ! is_empi_build; then
+ if ! mpi_classed; then
$*
return ${?}
fi
@@ -357,7 +109,7 @@ mpi_do() {
elif [ "${cmd#new}" != "${cmd}" ]; then
prefix="new"; cmd=${cmd#new}
else
- die "Unknown command passed to mpi_do: ${cmd}"
+ die "Unknown command passed to _mpi_do: ${cmd}"
fi
case ${cmd} in
bin|lib|lib.a|lib.so|sbin)
@@ -366,18 +118,26 @@ mpi_do() {
doc)
_E_DOCDESTTREE_="../../../../${mdir}usr/share/doc/${PF}/${_E_DOCDESTTREE_}" \
${prefix}${cmd} $*
- rc=$?;;
+ rc=$?
+ for d in "/share/doc/${P}" "/share/doc" "/share"; do
+ rmdir ${D}/usr${d} &>/dev/null
+ done
+ ;;
html)
_E_DOCDESTTREE_="../../../../${mdir}usr/share/doc/${PF}/www/${_E_DOCDESTTREE_}" \
${prefix}${cmd} $*
- rc=$?;;
+ rc=$?
+ for d in "/share/doc/${P}/html" "/share/doc/${P}" "/share/doc" "/share"; do
+ rmdir ${D}/usr${d} &>/dev/null
+ done
+ ;;
exe)
_E_EXEDESTTREE_="${mdir}${_E_EXEDESTTREE_}" ${prefix}${cmd} $*
rc=$?;;
man|info)
[ -d "${D}"usr/share/${cmd} ] && mv "${D}"usr/share/${cmd}{,-orig}
[ ! -d "${D}"${mdir}usr/share/${cmd} ] \
- && install -d "${D}"${mdir}usr/share/${cmd}
+ && install -d "${D}"${mdir}usr/share/${cmd}
ln -snf ../../${mdir}usr/share/${cmd} ${D}usr/share/${cmd}
${prefix}${cmd} $*
@@ -390,7 +150,7 @@ mpi_do() {
hard|sym)
${prefix}${cmd} "${mdir}$1" "${mdir}/$2"; rc=$?;;
ins)
- INSDESTTREE="${mdir}${INSTREE}" ${cmd}${prefix} $*; rc=$?;;
+ INSDESTTREE="${mdir}${INSTREE}" ${prefix}${cmd} $*; rc=$?;;
*)
rc=0;;
esac
@@ -398,27 +158,207 @@ mpi_do() {
[[ ${ran} -eq 0 ]] && die "mpi_do passed unknown command: ${cmd}"
return ${rc}
}
+mpi_dobin() { _mpi_do "dobin" $*; }
+mpi_newbin() { _mpi_do "newbin" $*; }
+mpi_dodoc() { _mpi_do "dodoc" $*; }
+mpi_newdoc() { _mpi_do "newdoc" $*; }
+mpi_doexe() { _mpi_do "doexe" $*; }
+mpi_newexe() { _mpi_do "newexe" $*; }
+mpi_dohtml() { _mpi_do "dohtml" $*; }
+mpi_dolib() { _mpi_do "dolib" $*; }
+mpi_dolib.a() { _mpi_do "dolib.a" $*; }
+mpi_newlib.a() { _mpi_do "newlib.a" $*; }
+mpi_dolib.so() { _mpi_do "dolib.so" $*; }
+mpi_newlib.so() { _mpi_do "newlib.so" $*; }
+mpi_dosbin() { _mpi_do "dosbin" $*; }
+mpi_newsbin() { _mpi_do "newsbin" $*; }
+mpi_doman() { _mpi_do "doman" $*; }
+mpi_newman() { _mpi_do "newman" $*; }
+mpi_doinfo() { _mpi_do "doinfo" $*; }
+mpi_dodir() { _mpi_do "dodir" $*; }
+mpi_dohard() { _mpi_do "dohard" $*; }
+mpi_doins() { _mpi_do "doins" $*; }
+mpi_dosym() { _mpi_do "dosym" $*; }
+
+
+###########################################
+# Functions for MPI Implementation Builds #
+###########################################
+
+# @FUNCTION: mpi_imp_deplist
+# @USAGE:
+# @RETURNS: Returns a deplist that handles the blocking between mpi
+# implementations, the dep on eselect-mpi if a classed build, and any blockers
+# as specified in MPI_UNCLASSED_BLOCKERS
+mpi_imp_deplist() {
+ local c="sys-cluster"
+ local pn ver
+
+ mpi_classed && c="${CATEGORY}"
+ ver=""
+ for pn in ${__MPI_ALL_IMPLEMENTATION_PNS}; do
+ ver="${ver} !${c}/${pn}"
+ done
+ if mpi_classed; then
+ ver="${ver} >=app-admin/eselect-mpi-0.0.5"
+ else
+ for pn in ${MPI_UNCLASSED_BLOCKERS}; do
+ ver="${ver} !${MPI_UNCLASSED_BLOCKERS}"
+ done
+ fi
+ echo "${ver}"
+}
+
+mpi_imp_add_eselect() {
+ mpi_classed || return 0
+ local c=$(mpi_class)
+ cp "${FILESDIR}"/${MPI_ESELECT_FILE} ${T}/${c}.eselect || die
+ sed -i \
+ -e "s|@ROOT@|$(mpi_root)|g" \
+ -e "s|@LIBDIR@|$(get_libdir)|g" \
+ -e "s|@BASE_IMP@|${PN}|g" \
+ ${T}/${c}.eselect || die
+
+ eselect mpi add "${T}"/${c}.eselect || die
+}
+
+
+
+########################################
+# Functions for packages requiring MPI #
+########################################
+
+# @ECLASS-VARIABLE: MPI_PKG_NEED_IMPS
+# @DESCRIPTION: List of package names (${PN}) that this package is compatible
+# with. Default is the list of all mpi implementations
+MPI_PKG_NEED_IMPS="${MPI_PKG_NEED_IMPS:-${__MPI_ALL_CLASSABLE_PNS}}"
+
+# @FUNCTION: mpi_pkg_deplist
+# @USAGE:
+# @RETURN: Returns a deplist comprised of valid implementations and any blockers
+# depending on if this package is building with mpi class support.
+mpi_pkg_deplist() {
+ local c="sys-cluster"
+ local pn ver
+
+ mpi_classed && c="${CATEGORY}"
+ ver="|| ("
+ for pn in ${MPI_PKG_NEED_IMPS}; do
+ ver="${ver} ${c}/${pn}"
+ done
+ ver="${ver} )"
+
+ if ! mpi_classed && [ -n "${MPI_UNCLASSED_BLOCKERS}" ]; then
+ for pn in ${MPI_UNCLASSED_BLOCKERS}; do
+ ver="${ver} !${pn}"
+ done
+ fi
+ echo "${ver}"
+}
+
+# @FUNCTION: mpi_pkg_base_imp
+# @USAGE:
+# @DESCRIPTION: Returns the ${PN} of the package providing mpi support. Works
+# even when using an unclassed mpi build.
+mpi_pkg_base_imp() {
+ if mpi_classed; then
+ echo "$(_get_eselect_var CLASS_BASE_MPI_IMP)"
+ else
+ local pn
+ for pn in ${MPI_PKG_NEED_IMPS}; do
+ if has_version "sys-cluster/${pn}"; then
+ echo "${PN}"
+ fi
+ done
+ fi
+}
+
+# @FUNCTION: mpi_pkg_cc
+# @USAGE:
+# @DESCRIPTION: Returns the full path to the mpi C compiler. Trys to find one
+# even if this build is unclassed. If return is empty, user should assume the
+# implementation does not support this compiler
+# @FUNCTION: mpi_pkg_cxx
+# @USAGE:
+# @DESCRIPTION: Returns the full path to the mpi C++ compiler. Trys to find one
+# even if this build is unclassed. If return is empty, user should assume the
+# implementation does not support this compiler
+# @FUNCTION: mpi_pkg_fc
+# @USAGE:
+# @DESCRIPTION: Returns the full path to the mpi f90 compiler. Trys to find one
+# even if this build is unclassed. If return is empty, user should assume the
+# implementation does not support this compiler
+# @FUNCTION: mpi_pkg_f77
+# @USAGE:
+# @DESCRIPTION: Returns the full path to the mpi f77 compiler. Trys to find one
+# even if this build is unclassed. If return is empty, user should assume the
+# implementation does not support this compiler
+
+mpi_pkg_cc() { _mpi_pkg_compiler "MPI_CC" "cc"; }
+mpi_pkg_cxx() { _mpi_pkg_compiler "MPI_CXX" "cxx c++"; }
+mpi_pkg_f77() { _mpi_pkg_compiler "MPI_F77" "f77"; }
+mpi_pkg_fc() { _mpi_pkg_compiler "MPI_FC" "f90 fc"; }
+
+# If classed, we can ask eselect-mpi. Otherwise we'll look for some common
+# executable names in ${ROOT}usr/bin.
+_mpi_pkg_compiler() {
+ if mpi_classed; then
+ echo "$(eselect mpi printvar $(mpi_class) ${1})"
+ else
+ local suffixes=${2}
+ local p
+
+ for p in ${suffixes}; do
+ if [ -x ${ROOT}usr/bin/mpi${p} ]; then
+ echo "${ROOT}usr/bin/mpi${p}"
+ break
+ fi
+ done
+ fi
+}
-mpi_dobin() { mpi_do "dobin" $*; }
-mpi_newbin() { mpi_do "newbin" $*; }
-mpi_dodoc() { mpi_do "dodoc" $*; }
-mpi_newdoc() { mpi_do "newdoc" $*; }
-mpi_doexe() { mpi_do "doexe" $*; }
-mpi_newexe() { mpi_do "newexe" $*; }
-mpi_dohtml() { mpi_do "dohtml" $*; }
-mpi_dolib() { mpi_do "dolib" $*; }
-mpi_dolib.a() { mpi_do "dolib.a" $*; }
-mpi_newlib.a() { mpi_do "newlib.a" $*; }
-mpi_dolib.so() { mpi_do "dolib.so" $*; }
-mpi_newlib.so() { mpi_do "newlib.so" $*; }
-mpi_dosbin() { mpi_do "dosbin" $*; }
-mpi_newsbin() { mpi_do "newsbin" $*; }
-mpi_doman() { mpi_do "doman" $*; }
-mpi_newman() { mpi_do "newman" $*; }
-mpi_doinfo() { mpi_do "doinfo" $*; }
-mpi_dodir() { mpi_do "dodir" $*; }
-mpi_dohard() { mpi_do "dohard" $*; }
-mpi_doins() { mpi_do "doins" $*; }
-mpi_dosym() { mpi_do "dosym" $*; }
-
-EXPORT_FUNCTIONS src_compile src_install pkg_setup
+# @FUNCTION: mpi_pkg_set_env
+# @USAGE:
+# @DESCRIPTION: Exports 'some influential environment variables'. CC, CXX, F77, FC
+mpi_pkg_set_env() {
+ if mpi_classed; then
+ _mpi_oCC=$CC
+ _mpi_oCXX=$CXX
+ _mpi_oF77=$F77
+ _mpi_oFC=$FC
+ _mpi_oPCP=${PKG_CONFIG_PATH}
+ _mpi_oLLP=${LD_LIBRARY_PATH}
+ export CC=$(mpi_pkg_cc)
+ export CXX=$(mpi_pkg_cxx)
+ export F77=$(mpi_pkg_f77)
+ export FC=$(mpi_pkg_fc)
+ export PKG_CONFIG_PATH="$(mpi_root)$(get_libdir)/pkgconfig:${PKG_CONFIG_PATH}"
+ export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:$(_get_eselect_var LD_LIBRARY_PATH)"
+ fi
+}
+
+# @FUNCTION: mpi_pkg_restore_env
+# @USAGE:
+# @DESCRIPTION: Attempts to undo the damage done by mpi_pkg_set_env
+mpi_pkg_restore_env() {
+ if mpi_classed; then
+ export CC=$_mpi_oCC
+ export CXX=$_mpi_oCXX
+ export F77=$_mpi_oF77
+ export FC=$_mpi_oFC
+ export PKG_CONFIG_PATH=$_mpi_oPCP
+ export LD_LIBRARY_PATH=$_mpi_oLLP
+ fi
+}
+
+
+
+# @FUNCTION: _get_eselect_var
+# @USAGE: $1 - Variable to get from the class definition
+# @RETURN: If classed, and given a valid variable, the contents; empty
+# otherwise.
+_get_eselect_var() {
+ if mpi_classed && [ -n "${1}" ]; then
+ echo "$(eselect mpi printvar $(mpi_class) ${1} 2>/dev/null)"
+ fi
+}