#!/bin/bash
#
# Copyright (C) 2006-2011 Princeton University
# All rights reserved.
# Author: Christian Bienia
#
# parsecmgmt - A tool to manage the PARSEC benchmark suite
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#     * Redistributions of source code must retain the above copyright
#       notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above copyright
#       notice, this list of conditions and the following disclaimer in the
#       documentation and/or other materials provided with the distribution.
#     * Neither the name of Princeton University nor the
#       names of its contributors may be used to endorse or promote products
#       derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY CHRISTIAN BIENIA ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL CHRISTIAN BIENIA BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# CHANGELOG
#
# From PARSEC 2.1 to PARSEC 3.0:
#  - Added package configuration files and eliminated central parsec.conf file
#  - Make parsecmgmt display more information about packages
#
# From PARSEC 2.0 to PARSEC 2.1:
#  - Made PARSECPLAT string detection more robust
#  - Place log files in separate log/${PARSECPLAT} subdirectories
#  - Always append build config name to PARSECPLAT
#
# From PARSEC 1.0 to PARSEC 2.0:
#  - parsecmgmt now adds '$CC_HOME/lib' and '$CC_HOME/lib64' to LD_LIBRARY_PATH
#  - file 'compile-info' renamed to 'build-info'
#  - option `-x' added to append extention to platform descriptor string
#  - option `-k' to keep run directory
#  - eliminated need for "inputs" list from file parsec.conf
#  - auto-detect available aliases and packages
#  - conditional package dependencies (also depend on build configuration now)
#  - Renamed action `uninstallall' to `fulluninstall'
#  - Renamed action `cleanall' to `fullclean'


#################################################################
#                                                               #
#                         CONFIGURATION                         #
#                                                               #
#################################################################

# Define directory of PARSEC benchmark suite
# If $PARSECDIR is not set, the script tries to autodetect the path
#export PARSECDIR=""

# Define platform name to use
# If $PARSECPLAT is not set, the script will automaticaly determine a name
#export PARSECPLAT=""

# Should output be logged? Anything other than "TRUE" will turn off logging
create_log="TRUE"


##### There should be no need to touch anything below here #####

# Output prefix to use
oprefix="[PARSEC]"


#################################################################
#                                                               #
#                           FUNCTIONS                           #
#                                                               #
#################################################################

# parsec_init
#
# Initialize the script
#
# Arguments: none
function parsec_init {
  # We need to hard-wire a few commands because we need them for the path detection
  PWD="pwd"
  BASENAME="basename"
  DIRNAME="dirname"

  # Determine script name
  eval me=$(${BASENAME} $0)

  # Try to find path
  uniquefile=".parsec_uniquefile"
  parsecdir=""
  if [ ! -z "${PARSECDIR}" ]; then
    # User defined PARSECDIR, check it
    parsecdir="${PARSECDIR}"
    if [ ! -f "${parsecdir}/${uniquefile}" ]; then
      echo "${oprefix} Error: Variable PARSECDIR points to '${PARSECDIR}', but this does not seem to be the PARSEC directory. Either unset PARSECDIR to make me try to autodetect the path or set it to the correct value."
      exit 1
    fi
  else
    # Try to autodetect path by looking at path used to invoke this script

    # Try to extract absoute or relative path
    if [ "${0:0:1}" == "/" ]; then
      # Absolute path given
      eval parsecdir=$(${DIRNAME} $(${DIRNAME} $0))
      # Check
      if [ -f "${parsecdir}/${uniquefile}" ]; then
        PARSECDIR=${parsecdir}
      fi
    else
      # No absolute path, maybe relative path?
      eval parsecdir=$(${PWD})/$(${DIRNAME} $(${DIRNAME} $0))
      # Check
      if [ -f "${parsecdir}/${uniquefile}" ]; then
        PARSECDIR=${parsecdir}
      fi
    fi

    # If PARSECDIR is still undefined, we try to guess the path
    if [ -z "${PARSECDIR}" ]; then
      # Check current directory
      if [ -f "./${uniquefile}" ]; then
        parsecdir="$(${PWD})"
        PARSECDIR=${parsecdir}
      fi
    fi
    if [ -z "${PARSECDIR}" ]; then
      # Check next-higher directory
      if [ -f "../${uniquefile}" ]; then
        parsecdir="$(${PWD})/.."
        PARSECDIR=${parsecdir}
      fi
    fi
  fi

  # Make sure PARSECDIR is defined and exported
  if [ -z "${PARSECDIR}" ]; then
    echo "${oprefix} Error: Unable to autodetect path to the PARSEC benchmark suite. Either define an environment variable PARSECDIR, or edit ${me} and set PARSECDIR to the correct value at the beginning of the file."
    exit 1
  fi
  export PARSECDIR

  # Eliminate trailing `/.' from PARSECDIR
  PARSECDIR=${PARSECDIR/%\/./}

  # Determine OS name to use for automatically determined PARSECPLAT
  case "${OSTYPE}" in
  *linux*)   ostype="linux";;
  *solaris*) ostype="solaris";;
  *bsd*)     ostype="bsd";;
  *aix*)     ostype="aix";;
  *hpux*)    ostype="hpux";;
  *irix*)    ostype="irix";;
  *amigaos*) ostype="amigaos";;
  *beos*)    ostype="beos";;
  *bsdi*)    ostype="bsdi";;
  *cygwin*)  ostype="windows";;
  *darwin*)  ostype="darwin";;
  *interix*) ostype="interix";;
  *os2*)     ostype="os2";;
  *osf*)     ostype="osf";;
  *sunos*)   ostype="sunos";;
  *sysv*)    ostype="sysv";;
  *sco*)     ostype="sco";;
  *)         ostype="${OSTYPE}";;
  esac

  # Determine HOST name to use for automatically determined PARSECPLAT
  case "${HOSTTYPE}" in
  *i386*)    hosttype="i386";;
  *x86_64*)  hosttype="amd64";;
  *amd64*)   hosttype="amd64";;
  *i486*)    hosttype="amd64";;
  *sparc*)   hosttype="sparc";;
  *sun*)     hosttype="sparc";;
  *ia64*)    hosttype="ia64";;
  *itanium*) hosttype="ia64";;
  *powerpc*) hosttype="powerpc";;
  *ppc*)     hosttype="powerpc";;
  *alpha*)   hosttype="alpha";;
  *mips*)    hosttype="mips";;
  *arm*)     hosttype="arm";;
  *)         hosttype="${HOSTTYPE}";;
  esac

  # Determine first part of value to use for PARSECPLAT environment variable if not defined by user
  # Note: We will append the compiler configuration to that to get the final value for PARSECPLAT
  hostostype="${hosttype}-${ostype}"

  # Define some global directories
  benchdir=${parsecdir}/pkgs
  logdir=${parsecdir}/log

  # Try to load OS-specific configuration to get binaries and correct arguments
  sysconfig="${PARSECDIR}/config/${ostype}.sysconf"
  if [ -f "${sysconfig}" ]; then
    source ${sysconfig}
  else
    echo "${oprefix} Error: Cannot load system configuration file '${sysconfig}' for OS type '${ostype}'. Please create a new system configuration file."
    exit 1
  fi

  # Setup environment so PARSEC tools are usable by other programs
  if [ -z "${PATH}" ]; then
    export PATH="${PARSECDIR}/bin"
  else
    export PATH="${PARSECDIR}/bin:${PATH}"
  fi

  # Build list of aliases from package configurations
  list_of_aliases=""
  for file in ${PARSECDIR}/config/packages/*.*.pkgconf; do
    source $file
    # Append unique aliases to global list, build package list for each alias
    for newalias in ${pkg_aliases}; do
      local is_duplicate=""
      for alias in ${list_of_aliases}; do
        if [[ "$newalias" == "$alias" ]]; then
          is_duplicate=TRUE
          break
        fi
      done
      # Initialize new aliases
      if [[ "$is_duplicate" != "TRUE" ]]; then
        list_of_aliases="$list_of_aliases $newalias"
        eval alias_${newalias}=\"\"
      fi
      is_duplicate=""
      # Append package to alias list
      local pkg
      local pkglist
      eval pkg=$(${BASENAME} $file)
      pkg=${pkg%\.pkgconf}

      # Add prefex ('parsec' or 'splash2')to the pkg 
      pkg=${pkg/\./_}

      eval  pkglist=\"\$alias_${newalias}\"
      eval alias_${newalias}=\"$pkglist $pkg\"
    done
  done
}

# process_args
#
# Process args and setup argument-dependent environment
#
# Arguments: all arguments given to the script (i.e. "$@")
function process_args {
  # Default configuration to use
  default_pkgs="parsec splash2 splash2x"
  default_build="gcc"
  default_rundir="${PARSECDIR}"
  default_inputsize="test"
  default_nthreads="1"
  default_submit="time"

  # Usage
  usage="\
Usage: $me -a ACTION [OPTION]...

Manage the installation of the PARSEC benchmark suite.

Options:
    -a ACTION        Specifies the action to perform. See below for a
                     list of valid actions.
    -p PACKAGE       A list of packages or aliases on which the action is to be
                     performed.
    -c CONFIG        Which build configuration to use. Default: '$default_build'
    -d RUNDIR        Use directory RUNDIR as root in which to run the
                     benchmarks.
    -i INPUT         The input to use to run the benchmarks. Default: '$default_inputsize'
    -n THREADS       The minimum number of threads to use. Default: '$default_nthreads'
    -s SUBMIT        Command to use to submit the benchmark for execution.
                     Default: '$default_submit'
    -x EXTENSION     Extension to append to platform descriptor string.
                     Default: none
    -k               Keep & use run directory as found, do not unpack inputs for
                     benchmark execution. Assume everything is already set up.
    -m NETMODE       Execution mode for network workloads. 
                     NETMODE can be either 'server' or 'client'. 
    -t THREADS       The number of user threads talking to the upTCP/IP stack. Default: '1'
    -r THREADS       The number of TCP/IP protocol receving threads. Default: '1'
    -l               Disable log.
    -h               Displays this help message.


Actions:
    'build'          Builds and installs the specified packages.
    'run'            Runs the specified packages.
    'clean'          Removes all files generated during the build and run phase
                     of the listed packages for the current platform, but
                     leaves the installed files untouched.
    'uninstall'      Removes the installed files of the listed packages for the
                     current platform.
    'fullclean'      Like 'clean', but for all architectures.
    'fulluninstall'  Like 'uninstall', but for all architectures.
    'status'         Shows a summary of the current status of the PARSEC
                     installation.
    'info'           List available packages and configurations.


Examples (1) [Compatible to PARSEC 2.1 but Extended]:
    - Build all benchmarks of three suites, i.e., PARSEC, SPLASH-2 and SPLASH-2x:
        $me -a build -p all
    - Build only applications, use 'icc' as build configuration:
        $me -a build -c icc -p apps
    - Do a full cleanup after a build or benchmark run:
        $me -a fullclean -p all
    - Remove all generated files of the current architecture:
        $me -a uninstall -p all
    - Run benchmark 'ferret' w/ input 'simsmall' and 4 threads:
        $me -a run -p ferret -i simsmall -n 4
    - Get a quick summary of all available packages and features:
        $me -a info
    - Show which kernel binaries have been installed:
        $me -a status -p kernels


Examples (2) [NEW: Network Benchmarks]:
    - Check the status of all components involved in network benchmarks:
        $me -a status -p netapps
    - Build network benchmark 'netstreamcluster':
        $me -a build -p raytrace
    - Build all network benchmark:
        $me -a build -p netapps
    - Run network benchmark 'netdedup' w/ input 'native' and 2 server threads:
        $me -a run -p netdedup -i native -n 2
    - Run network benchmark 'netferret' w/ input 'simlarge', 4 server threads and 2 client connections:
        $me -a run -p netferret -i simlarge -n 4 -t 2
    - For simulation, run 'netdedup' server on a simulator w/ 4 threads and run client on a real machine:
        $me -a run -p netdedup -i simlarge -n 4 -m server
        $me -a run -p netdedup -i simlarge -m client
    - Do a full cleanup for network benchmarks:
        $me -a fullclean -p netapps


Examples (3) [NEW: SPLASH-2 Suite and SPLASH-2x Suite]:
    - Check the status of SPLASH-2 suite and SPLASH-2x suite:
        $me -a status -p splash2
        $me -a status -p splash2x
    - Build benchmark 'raytrace' from SPLASH-2x suite other than PARSEC:
        $me -a build -p splash2x.raytrace
        $me -a build -p raytrace   ## defaultly from PARSEC (for comparison)
    - Build benchmark 'fft' from SPLASH-2 suite with 'gcc-serial' build configuration:
        $me -a build -c gcc-serial -p splash2.fft
    - Build all benchmarks from SPLASH-2 suite and SPLASH-2x suite:
        $me -a build -p splash2
        $me -a build -p splash2x
    - Run benchmark 'fft' from SPLASH-2x w/ input 'simsmall' and 4 threads:
        $me -a run -p splash2x.fft -i simsmall -n 4
    - Do a full cleanup for SPLASH-2 suite
        $me -a fullclean -p splash2"

  # Define valid actions
  valid_actions="build run clean uninstall fullclean fulluninstall status info"

  # Parse arguments
  parsemode="none"
  need_arg_for=""
  action=""
  pkgs=""
  build=""
  rundir=""
  inputsize=""
  netmode=""
  nthreads=""
  userthreads=""
  rxthreads=""
  submit=""
  extension=""
  extcmd=""
  keep_rundir=""
  while [ ! -z "$1" ]; do
    arg="$1"
    case "${arg}" in
      "-a" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-a'"
          echo "${usage}"
          exit 1
        fi
        if [ ! -z "${action}" ]; then
          echo "${oprefix} Error: Two actions specified"
          exit 1
        fi
        need_arg_for="-a"
        parsemode="ACTION";;
      "-p" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-p'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-p"
        parsemode="PKGS";;
      "-c" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-c'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-c"
        parsemode="CONFIG";;
      "-d" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-d'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-d"
        parsemode="RUNDIR";;
      "-i" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-i'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-i"
        parsemode="INPUT";;
      "-n" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-n'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-n"
        parsemode="NTHREADS";;
      "-t" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-t'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-t"
        parsemode="USERTHREADS";;
      "-r" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-r'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-r"
        parsemode="RXTHREADS";;
      "-s" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-s'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-s"
        parsemode="SUBMIT";;
      "-x" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-x'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-x"
        parsemode="EXTENSION";;
      "-X" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-X'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-X"
        parsemode="EXTCMD";;
      "-m" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-m'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for="-m"
        parsemode="NETMODE";;
     "-k" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-k'"
          echo "${usage}"
          exit 1
        fi
        keep_rundir="yes";;
      "-h" )
        echo "${usage}"
        exit 0;;
      "-l" )
	create_log="FALSE";;
     *    )
        if [ ${arg:0:1} == "-" ]; then
          echo "${oprefix} Error: Unknown argument '${arg}'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for=""
        case "${parsemode}" in
          "ACTION"   )
            parsemode="none"
            # Check whether specified action is valid
            is_valid=""
            for valid_action in ${valid_actions}; do
              if [ "${arg}" == "${valid_action}" ]; then
                is_valid="TRUE"
                break
              fi
            done
            if [ -z "$is_valid" ]; then
              echo "${oprefix} Error: Unknown action '${arg}'."
              echo "${usage}"
              exit 1
            fi
            action="${arg}";;
          "PKGS"   )
            # Check whether specified package is valid
            is_valid=""
            # Is it a recognized alias?
            tmparg=""
            tmparg=${arg/\./_} #arg could be "splash2" or "splash2.fmm"
            if [ ${tmparg} == ${arg} ]; then
                eval tmparg="\"\${alias_${arg}}\""
                if [ ! -z "${tmparg}" ]; then
                    is_valid="TRUE"
                else # parsec pkg 
                    tmparg=parsec_${arg}
                    arg=parsec.${arg}
                fi
            fi
            # Is it a recognized package?
            if [[ -e "${PARSECDIR}/config/packages/${arg}.pkgconf" ]]; then
              is_valid="TRUE"
            fi
            # Interpret result
            if [ -z "$is_valid" ]; then
              echo "${oprefix} Error: Invalid package '${arg}'."
              exit 1
            fi
            pkgs="${pkgs} ${tmparg}";;
          "CONFIG"   )
            parsemode="none"
            # Check whether specified config file exists
            buildfile="${PARSECDIR}/config/${arg}.bldconf"
            if [ ! -f "${buildfile}" ]; then
              echo "${oprefix} Error: Cannot find build configuration file '${buildfile}'."
              exit 1
            fi
            build="${arg}";;
          "RUNDIR"   )
           parsemode="none"
            # Check whether specified run directory exists
            if [ ! -d "${arg}" ]; then
              echo "${oprefix} Error: Cannot find directory '${arg}'."
              exit 1
            fi
            rundir="${arg}";;
          "INPUT"    )
            parsemode="none"
            # Check whether specified input set exists
            runconfigfile="${PARSECDIR}/config/${arg}.runconf"
            if [ ! -f "${runconfigfile}" ]; then
              echo "${oprefix} Error: Unknown input set '${arg}'."
              exit 1
            fi
            inputsize="${arg}";;
          "NTHREADS" )
            parsemode="none"
            declare -i nthreads
            nthreads="${arg}"
            # Note: This check also filters out strings (nthreads==0 in that case)
            if [ "${nthreads}" -lt "1" ]; then
              echo "${oprefix} Error: Illegal number of threads: '${arg}'."
              echo "${usage}"
              exit 1
            fi;;
          "USERTHREADS" )
            parsemode="none"
            userthreads="${arg}"
            # Note: This check also filters out strings (userthreads==0 in that case)
            if [ "${userthreads}" -lt "1" ]; then
              echo "${oprefix} Error: Illegal number of user threads: '${arg}'."
              echo "${usage}"
              exit 1
            fi;;
          "RXTHREADS" )
            parsemode="none"
            rxhreads="${arg}"
            # Note: This check also filters out strings (rxthreads==0 in that case)
            if [ "${rxthreads}" -lt "1" ]; then
              echo "${oprefix} Error: Illegal number of receiving threads: '${arg}'."
              echo "${usage}"
              exit 1
            fi;;
          "SUBMIT" )
            parsemode="none"
            # Check whether specified program exists
            cmd=$(echo "${arg}" | awk '{print $1}')
            if [ ! -e "${cmd}" ]; then
              # Check whether program is in path and give it a second try
              cmd=$(which ${cmd}); rv=$?
              if [ ! $rv -eq 0 ]; then
                echo "${oprefix} Error: Cannot find file '${arg}'."
                exit 1
              fi
            fi
            # Check whether specified file is executable
            if [ ! -x "${cmd}" ]; then
              echo "${oprefix} Error: '${arg}' is not executable."
              exit 1
            fi
            submit="${arg}";;
          "EXTENSION" )
            parsemode="none"
            extension="${arg}";;
          "EXTCMD" )
            parsemode="none"
            extpkg="${arg}"
            extcmd="${PARSECDIR}/toolkit/${extpkg}/${extpkg}.sh ${PARSECDIR}/toolkit/${extpkg}/parameter.cfg &"
            eval ${extcmd}
            echo ""
            echo "NOTE: The external package ${extpkg} is running in background. Please check results later."
            echo ""
            exit 0;;
         "NETMODE" )
            parsemode="none"
            if [ ! ${arg} == "server" ] && [ ! ${arg} == "client" ]; then
		echo "illegal value for NETMODE: NETMODE should be either 'server' or 'client'"
		exit 1
	    fi
            netmode="${arg}";;
         *        )
            echo "${oprefix} Error: Unknown argument '${arg}'"
            echo "${usage}"
            exit 1;;
        esac;;
    esac

    shift
  done
  if [ ! -z "${need_arg_for}" ]; then
    echo "${oprefix} Error: ${parsemode} expected after '${need_arg_for}'"
    echo "${usage}"
    exit 1
  fi

  # Make sure we have an action and at least one package
  if [ -z "${action}" ]; then
    echo "${oprefix} Error: No action specified."
    echo "${usage}"
    exit 1
  fi

  if [ -z "${pkgs}" ]; then
    # Is it a recognized alias?
    for arg in ${default_pkgs} ; do
            tmparg=""
            tmparg=${arg/\./_} #arg could be "splash2" or "splash2.fmm"
            if [ ${tmparg} == ${arg} ]; then
                eval tmparg="\"\${alias_${arg}}\""
                if [ -z "${tmparg}" ]; then
                    tmparg=parsec_${arg}
                    arg=parsec.${arg}
                fi
            fi
            pkgs="${pkgs} ${tmparg}"
    done
  fi

  # Set NTHREADS
  if [ -z "${nthreads}" ]; then
    # Use default value
    NTHREADS="${default_nthreads}"
  else
    NTHREADS="${nthreads}"
  fi

  # Set rundir
  if [ -z "${rundir}" ]; then
    # Use default value
    rundir="${default_rundir}"
  fi

  # Set input size
  if [ -z "${inputsize}" ]; then
    # Use default value
    inputsize="${default_inputsize}"
  fi

  # Set submit program
  if [ -z "${submit}" ]; then
    # Use default value
    submit="${default_submit}"
  fi

  # Determine build
  if [ -z "${build}" ]; then
    build="${default_build}"
  fi

  # Define PARSECPLAT, if not set by user
  if [ -z "${PARSECPLAT}" ]; then
    PARSECPLAT=${hostostype}.${build}
  else
    PARSECPLAT=${PARSECPLAT}.${build}
  fi
  # Append extension if specified
  if [ ! -z "${extension}" ]; then
    PARSECPLAT=${PARSECPLAT}.${extension}
  fi

  export PARSECPLAT
  # Load build configuration
  if [ "${action}" == "build" -o "${action}" == "run" ]; then
    buildfile="${PARSECDIR}/config/${build}.bldconf"
    if [ -f "${buildfile}" ]; then
      source ${buildfile}
    else
      echo "${oprefix} Error: Cannot find build configuration file '${buildfile}'."
      exit 1
    fi
  fi

  # Expand aliases to get full list of packages to build
  # there are three kinds of token in $pkgs:
  #    1) parsec_pthread, parsec_opemmp, etc. alias, remove "parsec_" and just expand them
  #    2) parsec_streamcluster etc. not alias but parsec workloads, just add them
  #    3) splash2_raytrace, splash2_xxx. not alias but splash2 workloads, just add them
  expanded_aliases=""
  for token in ${pkgs}; do
    # Is it a recognized alias?
    local tmpbench
    tmpbench=${token:0:5}
    if [ $tmpbench == "parsec" ]; then
        local tmppkg
        tmppkg=${token:7}
        eval temp="\"\${alias_${tmppkg}}\""
        if [ ! -z "${temp}" ]; then
          # Yes it is, expand alias
          expanded_aliases="${expanded_aliases} ${temp}"
        else
          # Otherwise keep it in the list
          expanded_aliases="${expanded_aliases} ${token}"
        fi
    else
        expanded_aliases="${expanded_aliases} ${token}"
    fi
  done

  # Rebuild list with packages, remove duplicate packages
  pkgs=""
  pkgs_nonapps="${alias_tools} ${alias_libs}"
  for pkg in $expanded_aliases; do
    is_included=""
    local tmppkg
    # restore to xxxx.xxxx format
    tmppkg=${pkg/_/\.}
    for dummy in $pkgs; do
      if [ "$tmppkg" == "$dummy" ]; then
        is_included="TRUE"
        break
      fi
    done

    if [ "${action}" == "run" ]; then
        for tmppkg2 in ${pkgs_nonapps}; do
           tmppkg3=${tmppkg2/_/\.}
           if [ "${tmppkg3}" == "$tmppkg" ]; then
                is_included="TRUE"
                break
           fi
        done
    fi

    if [ -z "$is_included" ]; then
      pkgs="${pkgs} ${tmppkg}"
    fi
  done

  # Initialize logging functionality
  logfile=""
  if [ "${action}" == "build" ]; then
    eval logfile="build_\$(${LOGDATE}).log"
  elif [ "${action}" == "run" ]; then
    eval logfile="run_${NTHREADS}_${inputsize}_\$(${LOGDATE}).log"
  fi
  if [ "$create_log" == "TRUE" ] && [ ! -z "$logfile" ]; then
    ${MKDIR} ${logdir}/${PARSECPLAT}
    log=${logdir}/${PARSECPLAT}/${logfile}
  else
    log="/dev/null"
  fi
}

# build_info
#
# Create a text file containing information about the build.
# Assumes that all relevant configuration files have already been sourced.
#
# Arguments: $1 - Package name
#            $2 - The name of the text file to create
function build_info {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: build_info called with no arguments." 2>&1 | ${TEE} ${log}
    exit 1
  fi
  local package_name="$1"
  if [ -z "$2" ]; then
    echo "${oprefix} Error: build_info called with insufficient number of arguments." 2>&1 | ${TEE} ${log}
    exit 1
  fi
  local cinfo_file="$2"

  echo "PARSEC Compile Information" > ${cinfo_file}
  echo "==========================" >> ${cinfo_file}
  echo "Package '${package_name}'" >> ${cinfo_file}
  eval echo "Built on \$(${DATE})" >> ${cinfo_file}
  echo >> ${cinfo_file}

  # Package-specific build information
  local env_package="${build_env}"
  local build_conf_package="${build_conf} ${build_conf_global}"

  echo "Configure arguments: ${build_conf_package}" >> ${cinfo_file}
  echo >> ${cinfo_file}
  echo "Environment modifications: ${env_package}" >> ${cinfo_file}
  echo >> ${cinfo_file}

  echo "CC: ${CC}" >> ${cinfo_file}
  echo "Version: ${CC_ver}" >> ${cinfo_file}
  echo "CFLAGS: ${CFLAGS}" >> ${cinfo_file}
  echo >> ${cinfo_file}

  echo "CXX: ${CXX}" >> ${cinfo_file}
  echo "Version: ${CXX_ver}" >> ${cinfo_file}
  echo "CXXFLAGS: ${CXXFLAGS}" >> ${cinfo_file}
  echo >> ${cinfo_file}

  echo "CCAS: ${CCAS}" >> ${cinfo_file}
  echo "Version: ${CCAS_ver}" >> ${cinfo_file}
  echo "CCASFLAGS: ${CCASFLAGS}" >> ${cinfo_file}
  echo >> ${cinfo_file}

  echo "LD: ${LD}" >> ${cinfo_file}
  echo "Version: ${LD_ver}" >> ${cinfo_file}
  echo "LDFLAGS: ${LDFLAGS}" >> ${cinfo_file}
  echo >> ${cinfo_file}

  echo "JAVAC: ${JAVAC}" >> ${cinfo_file}
  echo "Version: ${JAVAC_ver}" >> ${cinfo_file}
  echo "JFLAGS: ${JFLAGS}" >> ${cinfo_file}
  echo >> ${cinfo_file}

  echo "[EOF]" >> ${cinfo_file}
}

# build_package
#
# Build a software package and recursively all packages it depends on
#
# Arguments: $1 - The package name
function build_package {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: build_package called with no arguments." 2>&1 | ${TEE} ${log}
    exit 1
  fi
  local pkg=$1

  echo "${oprefix} [---------- Analyzing package ${pkg} ----------]" 2>&1 | ${TEE} ${log}

  # Load package configuration
  source ${PARSECDIR}/config/packages/${pkg}.pkgconf

  # Define package-specific directories
  if [ -z "$pkg_group" ]; then
    echo "${oprefix} Error: Group of package ${pkg} is unknown." 2>&1 | ${TEE} ${log}
    exit 1
  fi

  # determine top directory
  local bench
  bench=`expr match ${pkg} '\(.*\.\)'`
  eval pkgname="${pkg#${bench}}"
  bench=${bench%\.}

  if [ ${bench} == "parsec" ]; then
      benchdir="pkgs"
  else
      eval benchdir="ext\/${bench}"
  fi
  
  local pkgdir=${PARSECDIR}/${benchdir}/${pkg_group}/${pkgname}
  local pkgsrcdir=${pkgdir}/src
  local pkgobjdir=${pkgdir}/obj/${PARSECPLAT}
  local pkginstdir=${pkgdir}/inst/${PARSECPLAT}
  local pkgparsecdir=${pkgdir}/parsec

  # Check whether package has already been built
  if [ -f "${pkginstdir}/build-info" ]; then
    echo "${oprefix} Package ${pkg} already exists, proceeding." 2>&1 | ${TEE} ${log}
    return 0
  fi

  # Source local build configuration to get dependencies
  if [ ! -f "${pkgparsecdir}/${build}.bldconf" ]; then
    echo "${oprefix} Error: Cannot find local build configuration '${build}.bldconf' for package ${pkg}." 2>&1 | ${TEE} ${log}
    exit 1
  else
    source ${pkgparsecdir}/${build}.bldconf
  fi

  # Build packages on which pkg depends
  if [ -z "${build_deps}" ]; then
    echo "${oprefix} ${pkg} does not depend on any other packages." 2>&1 | ${TEE} ${log}
  else
    echo "${oprefix} ${pkg} depends on: ${build_deps}" 2>&1 | ${TEE} ${log}
  fi

  local dep=""
  for dep in ${build_deps}; do
    local tmpdep
    local index
    tmpdep=${dep}
    eval index=`expr "${dep}" : '\.'`
    if [ $index -eq 0 ]; then
        eval tmpdep="parsec.${dep}"
    fi
    build_package "${tmpdep}"
  done

  # Now build pkg itself
  echo "${oprefix} [---------- Building package ${pkg} ----------]" 2>&1 | ${TEE} ${log}

  # Source local package build configuration again (might have gotten overwritten by recursion)
  if [ ! -f "${pkgparsecdir}/${build}.bldconf" ]; then
    echo "${oprefix} Error: Cannot find local build configuration '${build}.bldconf' for package ${pkg}." 2>&1 | ${TEE} ${log}
    exit 1
  else
    source ${pkgparsecdir}/${build}.bldconf
  fi

  # Check for obvious errors
  if [ -z "${build_inplace}" ]; then
    echo "${oprefix} Variable 'build_inplace' for package '${benchmark}' has not been set in file '${build}.bldconf'." | ${TEE} ${log}
    exit 1
  fi

  # Global arguments to configure script
  build_conf_global="--prefix=${pkginstdir}"

  # We need either configure or a Makefile
  if [ ! -x ${pkgsrcdir}/configure -a ! -f ${pkgsrcdir}/[Mm]akefile ]; then
    echo "${oprefix} Error: Need 'configure' script or a '[Mm]akefile' to build package ${pkg}." 2>&1 | ${TEE} ${log}
    exit 1
  fi

  # Remove an already existing build directory
  if [ -e "${pkgobjdir}" ]; then
     echo "${oprefix} Removing old build directory." 2>&1 | ${TEE} ${log}
     ${RM} ${pkgobjdir} 
  fi

  # Set up build directory
  if [ "${build_inplace}" == "TRUE" ]; then
    local pkgbuildsrcdir=${pkgobjdir}
    echo "${oprefix} Copying source code of package ${pkg}." 2>&1 | ${TEE} ${log}
    ${MKDIR} ${pkgobjdir} > /dev/null
    ${CP} ${pkgsrcdir}/* ${pkgobjdir}
  else
    local pkgbuildsrcdir=${pkgsrcdir}
    ${MKDIR} ${pkgobjdir} > /dev/null
  fi
  pushd ${pkgobjdir} > /dev/null

  # Run configure
  if [ -x ${pkgbuildsrcdir}/configure ]; then
    local build_conf_pkg="${build_conf} ${build_conf_global}"
    # Current pwd is $pkgobjdir
    if [ "${pkgobjdir}" == "${pkgbuildsrcdir}" ]; then
      local configcmd="env ${build_env} ./configure ${build_conf_pkg}"
    else
      local configcmd="env ${build_env} ${pkgbuildsrcdir}/configure ${build_conf_pkg}"
    fi
    eval echo "${oprefix} Running \'${configcmd}\':" 2>&1 \| ${TEE} ${log}
    eval \( ${configcmd} 2>&1 \) 2>&1 \| ${TEE} ${log} \; retval=\${PIPESTATUS[0]}
    if [ "$retval" -ne "0" ]; then
      eval echo "${oprefix} Error: \'${configcmd}\' failed." 2>&1 \| ${TEE} ${log}
      popd > /dev/null
      exit 1
    fi
  fi
  
  # Make sure a Makefile exists in the build directory
  if [ ! -f ${pkgobjdir}/[Mm]akefile ]; then
    echo "${oprefix} Error: Cannot find Makefile in ${pkgobjdir}" 2>&1 | ${TEE} ${log}
    popd > /dev/null
    exit 1
  fi

  # Run make
  local makecmd="env ${build_env} ${MAKE}"
  eval echo "${oprefix} Running \'$makecmd\':" 2>&1 \| ${TEE} ${log}
  eval \( ${makecmd} 2>&1 \) 2>&1 \| ${TEE} ${log} \; retval=\${PIPESTATUS[0]}
  if [ "$retval" -ne "0" ]; then
    eval echo "${oprefix} Error: \'${makecmd}\' failed." 2>&1 \| ${TEE} ${log}
    popd > /dev/null
    exit 1
  fi

  # Run make install
  ${MKDIR} ${pkginstdir} > /dev/null
  local makecmd="env ${build_env} ${MAKE} install"
  eval echo "${oprefix} Running \'$makecmd\':" 2>&1 \| ${TEE} ${log}
  eval \( ${makecmd} 2>&1 \) 2>&1 \| ${TEE} ${log} \; retval=\${PIPESTATUS[0]}
  if [ "$retval" -ne "0" ]; then
    eval echo "${oprefix} Error: \'${makecmd}\' failed." 2>&1 \| ${TEE} ${log}
    popd > /dev/null
    exit 1
  fi

  popd > /dev/null
  pushd ${pkginstdir} > /dev/null

  # Create build info file
  build_info ${pkg} ${pkginstdir}/build-info

  # Finish up
  popd > /dev/null
}

# run_benchmark
#
# Run the specified benchmarks
#
# Arguments: $1 - The benchmark name
#            $2 - Which input to use
#            $3 - The run directory root
function run_benchmark {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: run_benchmark called with no arguments." | ${TEE} ${log}
    exit 1
  fi
  local benchmark=$1
  if [ -z "$2" ]; then
      echo "${oprefix} Error: run_benchmark called with insufficient number of arguments." | ${TEE} ${log}
    exit 1
  fi
  local inputsize=$2
  if [ -z "$3" ]; then
    if [ ${benchmark} == "parsec.uptcpip" ]; then
        exit 1
    fi
    echo "${oprefix} Error: run_benchmark called with insufficient number of arguments." | ${TEE} ${log}
    exit 1
  fi
  local cite_list=$3
  if [ -z "$4" ]; then
    echo "${oprefix} Error: run_benchmark called with insufficient number of arguments." | ${TEE} ${log}
    exit 1
  fi
  local rundir=$4


  echo "${oprefix} [========== Running benchmark ${benchmark} [${cite_list}] ==========]" | ${TEE} ${log}

  # Load package configuration
  source ${PARSECDIR}/config/packages/${benchmark}.pkgconf

  # Define benchmark-specific directories
  if [ -z "${pkg_group}" ]; then
    echo "${oprefix} Error: Group of benchmark '${benchmark}' is unknown." | ${TEE} ${log}
    exit 1
  fi


  # determine top directory
  local bench
  bench=`expr match ${benchmark} '\(.*\.\)'`
  eval pkgname="${benchmark#${bench}}"
  bench=${bench%\.}

  # deal with some specific cases
  if [ ${bench} == "parsec" ]; then
      eval benchdir="pkgs"
  else
      eval benchdir="ext/${bench}"
  fi

  # splash2 does not support multiple inputs 
  if [ ${bench} == "splash2" ]; then
      inputsize="test"
      echo "${oprefix} NOTE: SPLASH-2 only supports \"test\" input sets." | ${TEE} ${log}
      echo "${oprefix}       Please use SPLASH-2x for multiple input sets." | ${TEE} ${log}
  fi

  # splash2 does not support multiple inputs 
  if [ ${bench} == "splash2" ]; then
      inputsize="test"
      echo "${oprefix} NOTE: SPLASH-2 only supports \"test\" input sets." | ${TEE} ${log}
      echo "${oprefix}       Please use SPLASH-2x for multiple input sets." | ${TEE} ${log}
  fi

  local platform
  platform=${PARSECPLAT/serial/REPLACED} # check if gcc-serial
  if [ ${platform} != ${PARSECPLAT}  ]; then
      if [ "${NTHREADS}" -gt "1" ]; then
          NTHREADS=1
          echo "${oprefix} WARNING: Serial does not support multiple threads." | ${TEE} ${log}
          echo "${oprefix}          Change thread number to default 1." | ${TEE} ${log}
      fi
  fi

  # specific cases end
  #
  
  local bmrundir="${rundir}/${benchdir}/${pkg_group}/${pkgname}/run"
  local bmdir="${PARSECDIR}/${benchdir}/${pkg_group}/${pkgname}"
  local bminputdir="${bmdir}/inputs"
  local bmoutputdir="${bmdir}/outputs"
  local bminstdir="${bmdir}/inst/${PARSECPLAT}"
  local bmparsecdir="${bmdir}/parsec"

  # netapps leverages existing benchmark's inputs
  if [ ${pkg_group} == "netapps" ]; then
	if [ ${pkgname} == "netdedup" ] || [ ${pkgname} == "netstreamcluster" ]; then
		bminputdir=${bminputdir/netapps\/net/kernels\/}
	elif [ ${pkgname} == "netferret" ]; then
		bminputdir=${bminputdir/netapps\/net/apps\/}
	fi
  fi
 
  # Check whether selected input size is available
  if [ ! -f "${PARSECDIR}/config/${inputsize}.runconf" ]; then
    echo "${oprefix} Error: Selected input size not available."  2>&1 | ${TEE} ${log}
    exit 1
  fi

  # Source package run configuration
  if [ ! -f "${bmparsecdir}/${inputsize}.runconf" ]; then
    echo "${oprefix} Error: Cannot find run configuration '${inputsize}.runconf' for package ${benchmark}." 2>&1 | ${TEE} ${log}
    exit 1
      get_topdir "${package}"
  else
    source ${bmparsecdir}/${inputsize}.runconf
  fi

  # Determine binary
  local bmexec_suffix=${run_exec}
  if [ -z "${bmexec_suffix}" ]; then
    echo "${oprefix} Variable 'bench_exec_${benchmark}' for package '${benchmark}' has not been set." | ${TEE} ${log}
    exit 1
  fi
  local bmexec="${bminstdir}/${bmexec_suffix}"
  if [ ! -x "${bmexec}" ]; then
    echo "${oprefix} Error: Binary '${bmexec}' of package '${benchmark}' cannot be found." | ${TEE} ${log}
    exit 1
  fi

  # Determine output archive
  local bmoutput="${bmoutputdir}/output_${inputsize}.tar"
  #if [ ! -f "${bmoutput}" ]; then
  #  echo "${oprefix} Error: Output archive '${bmoutput}' of package '${benchmark}' cannot be found." | ${TEE} ${log}
  #  exit 1
  #fi

  if [ "${keep_rundir}" == "yes" ]; then
    # Keep run directory, just check that it exists
    if [ ! -d "${bmrundir}" ]; then
      echo "${oprefix} Error: Cannot keep run directory because it does not exist." | ${TEE} ${log} 
      exit 1
    fi
    echo "${oprefix} Keeping old run directory." | ${TEE} ${log}
    pushd "${bmrundir}" > /dev/null
  else 
    # Set up run directory
    if [ -d "${bmrundir}" ]; then
      echo "${oprefix} Deleting old run directory." | ${TEE} ${log}
      ${RM} ${bmrundir} | ${TEE} ${log}
    fi

    echo "${oprefix} Setting up run directory." | ${TEE} ${log}
    ${MKDIR} ${bmrundir} | ${TEE} ${log}
    pushd "${bmrundir}" > /dev/null
    
    # Determine input archive
    local bminput="${bminputdir}/input_${inputsize}.tar"
    if [ ! -f "${bminput}" ]; then
      echo "${oprefix} No archive for input '${inputsize}' available, skipping input setup." | ${TEE} ${log}
    else
      echo "${oprefix} Unpacking benchmark input '${inputsize}'." | ${TEE} ${log}
      ${UNTAR} ${bminput} | ${TEE} ${log}
    fi
  fi

  # Execute
  local bmexec_args=${run_args}
  if [ ! -z ${netmode} ]; then
      bmexec_args="${bmexec_args} ${netmode}"
  fi 
  if [ ! -z ${userthreads} ]; then
      bmexec_args="${bmexec_args} ${userthreads}"
  fi 
  if [ ! -z ${rxthreads} ]; then
      UPTCPIP_RX_THREADS="${rxthreads}"
      export UPTCPIP_RX_THREADS
  else
      UPTCPIP_RX_THREADS=1
      export UPTCPIP_RX_THREADS
  fi 
  eval cmd="\"${submit} ${bmexec} ${bmexec_args}\""
  echo "${oprefix} Running '${cmd}':" | ${TEE} ${log}
  echo "${oprefix} [---------- Beginning of output ----------]" | ${TEE} ${log}
  (eval ${cmd} 2>&1) 2>&1 | ${TEE} ${bmrundir}/benchmark.out | ${TEE} ${log}
  echo "${oprefix} [----------    End of output    ----------]" | ${TEE} ${log}


  # Unpack reference output and compare
  #echo "${oprefix} Unpacking benchmark reference output for '${inputsize}'." | ${TEE} ${log}
  #${MKDIR} ${bmrundir}/output.ref | ${TEE} ${log}
  #cd ${bmrundir}/output.ref
  #${UNTAR} ${bmoutput} | ${TEE} ${log}

  #echo "${oprefix} Checking benchmark output:" | ${TEE} ${log}
  #bmcorrect="TRUE"
  #for outfile in *; do
  #  echo -n "${oprefix}   ${outfile} - " | ${TEE} ${log}
  #  if [ ! -f "${bmrundir}/${outfile}" ]; then
  #    echo "MISSING" | ${TEE} ${log}
  #    bmcorrect="FALSE"
  #  else
  #    ${CMP} ${bmrundir}/output.ref/${outfile} ${bmrundir}/${outfile} > /dev/null
  #    if [ "$?" == "0" ]; then
  #      echo "PASSED" | ${TEE} ${log}
  #    else
  #      echo "FAILED" | ${TEE} ${log}
  #      bmcorrect="FALSE"
  #    fi
  #  fi
  #done
  #if [ "${bmcorrect}" != "TRUE" ]; then
  #  echo "${oprefix} Error: Benchmark not correctly executed." | ${TEE} ${log}
  #  exit 1
  #else
  #  echo "${oprefix} Benchmark correctly executed." | ${TEE} ${log}
  #fi
  popd > /dev/null
}

function get_topdir {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: get_topdir with no arguments." | ${TEE} ${log}
    exit 1
  fi
  local benchmark=$1

  # determine top directory
  benchdir=""
  pkgname=""
  local bench
  
  bench=`expr match ${benchmark} '\(.*\.\)'`
  eval pkgname="${benchmark#${bench}}"
  bench=${bench%\.}

  if [ ${bench} == "parsec" ]; then
      benchdir="pkgs"
  else
      eval benchdir="ext\/${bench}"
  fi
}

#################################################################
#                                                               #
#                             MAIN                              #
#                                                               #
#################################################################

# Check version
if [ ${BASH_VERSINFO[0]} -lt 3 ]; then
  # We need certain Bash 3 features. e.g. PIPESTATUS (which was available but broken in earlier versions)
  echo "${oprefix} Warning: At least bash version 3 is recommended. Earlier versions might not function properly. Current version is $BASH_VERSION."
fi

# Execute functions to setup environment
parsec_init
process_args "$@"

# Now we take decisive action
case ${action} in
  "build"         )
    eval echo "${oprefix} \[========== PARSEC $(${CAT} ${PARSECDIR}/version) BUILD LOGFILE ==========\]" > ${log}
    echo >> ${log}
    eval echo "${oprefix} Build '${PARSECPLAT}' started on \$(${DATE})." >> ${log}
    echo "${oprefix} Packages to build: ${pkgs}" 2>&1 | ${TEE} ${log}

    # Prepare LD_LIBRARY_PATH (some build systems call their own binaries)
    LD_LIBRARY_PATH_orig="${LD_LIBRARY_PATH}"
    if [ -z "${LD_LIBRARY_PATH}" ]; then
      export LD_LIBRARY_PATH="${CC_HOME}/lib:${CC_HOME}/lib64"
    else
      LD_LIBRARY_PATH="${CC_HOME}/lib:${CC_HOME}/lib64:${LD_LIBRARY_PATH}"
    fi

    # Initialize local variables
    list_of_bibentries=""

    # Build all packages
    for pkg in ${pkgs}; do

      # Load package configuration
      source ${PARSECDIR}/config/packages/${pkg}.pkgconf

      cite_list=""
      for bibkey in ${pkg_cite}; do
        i=1
        is_duplicate=""
        for bib in ${list_of_bibentries}; do
          if [[ "${bibkey}" == "${bib}" ]]; then
            is_duplicate="TRUE"
            break
          fi
          ((i++))
        done
        if [[ -z "${is_duplicate}" ]]; then
          # A unique entry, append to bibliography list
          # (Note: Order is important because of the numbering)
          list_of_bibentries="${list_of_bibentries} ${bibkey}"
        fi
        # Always append citation number to list of citations for component
        if [[ -z "${cite_list}" ]]; then
          cite_list="$i"
        else
          cite_list="${cite_list},${i}"
        fi
      done


      echo | ${TEE} ${log}
      echo "${oprefix} [========== Building package ${pkg} [${cite_list}] ==========]" | ${TEE} ${log}
      build_package "${pkg}"
    done

    # Bibliography list
    echo "${oprefix}"
    echo "${oprefix} BIBLIOGRAPHY"
    echo "${oprefix}"
    # Initialize variables & iterate through list of used bib entries
    i=1
    for bibkey in ${list_of_bibentries}; do
      bibfile="${PARSECDIR}/config/bibliography/${bibkey}.bibconf"
      if [[ -f ${bibfile} ]]; then
        source ${bibfile}
        echo "${oprefix} [${i}] ${bib_string}"
      else
        echo "${oprefix} [${i}] ERROR: File '${bibkey}.bibconf' does not exist."
      fi
      ((i++))
    done
    echo "${oprefix}"
 

    # Restore LD_LIBRARY_PATH
    LD_LIBRARY_PATH="${LD_LIBRARY_PATH_orig}"

    echo "${oprefix} Done." | ${TEE} ${log};;
  "run"           )
    eval echo "${oprefix} \[========== PARSEC $(${CAT} ${PARSECDIR}/version) RUN LOGFILE ==========\]" > ${log}
    echo >> ${log}
    eval echo "${oprefix} Run with '${PARSECPLAT}' binaries and input ${inputsize} started on \$(${DATE})." >> ${log}
  #  echo "${oprefix} Using ${rundir} as run directory root." >> ${log}
    echo "${oprefix} Benchmarks to run: ${pkgs}" 2>&1 | ${TEE} ${log}

    # Prepare LD_LIBRARY_PATH
    LD_LIBRARY_PATH_orig="${LD_LIBRARY_PATH}"
    if [ -z "${LD_LIBRARY_PATH}" ]; then
      export LD_LIBRARY_PATH="${CC_HOME}/lib:${CC_HOME}/lib64"
    else
      LD_LIBRARY_PATH="${CC_HOME}/lib:${CC_HOME}/lib64:${LD_LIBRARY_PATH}"
    fi

    # Initialize local variables
    list_of_bibentries=""

    # Execute all benchmarks
    for benchmark in ${pkgs}; do

      # Load package configuration
      source ${PARSECDIR}/config/packages/${benchmark}.pkgconf

      cite_list=""
      for bibkey in ${pkg_cite}; do
        i=1
        is_duplicate=""
        for bib in ${list_of_bibentries}; do
          if [[ "${bibkey}" == "${bib}" ]]; then
            is_duplicate="TRUE"
            break
          fi
          ((i++))
        done
        if [[ -z "${is_duplicate}" ]]; then
          # A unique entry, append to bibliography list
          # (Note: Order is important because of the numbering)
          list_of_bibentries="${list_of_bibentries} ${bibkey}"
        fi
        # Always append citation number to list of citations for component
        if [[ -z "${cite_list}" ]]; then
          cite_list="$i"
        else
          cite_list="${cite_list},${i}"
        fi
      done

      echo | ${TEE} ${log}
      run_benchmark "${benchmark}" "${inputsize}" "${cite_list}" "${rundir}"
    done

    # Bibliography list
    echo "${oprefix}"
    echo "${oprefix} BIBLIOGRAPHY"
    echo "${oprefix}"
    # Initialize variables & iterate through list of used bib entries
    i=1
    for bibkey in ${list_of_bibentries}; do
      bibfile="${PARSECDIR}/config/bibliography/${bibkey}.bibconf"
      if [[ -f ${bibfile} ]]; then
        source ${bibfile}
        echo "${oprefix} [${i}] ${bib_string}"
      else
        echo "${oprefix} [${i}] ERROR: File '${bibkey}.bibconf' does not exist."
      fi
      ((i++))
    done
    echo "${oprefix}"
 
    # Restore LD_LIBRARY_PATH
    LD_LIBRARY_PATH="${LD_LIBRARY_PATH_orig}"

    echo "${oprefix} Done." | ${TEE} ${log};;
  "clean"         )
    echo "${oprefix} Removing build and run files for build '${PARSECPLAT}':"
    for package in ${pkgs}; do
      # Load package configuration
      source ${PARSECDIR}/config/packages/${package}.pkgconf

      get_topdir "${package}"
      # Setup
      packagedir="${PARSECDIR}/${benchdir}/${pkg_group}/${pkgname}"
      packageobjdir="${packagedir}/obj/${PARSECPLAT}"
      packageparsecdir="${packagedir}/parsec"
      packagerundir="${rundir}/${benchdir}/${pkg_group}/${pkgname}/run"
      cleanenv="sysconfig=\"${sysconfig}\" packagedir=\"${packagedir}\""
      nothingtodo=""

      echo -n "${oprefix} ${package} - "

      # Remove build directory
      if [ -d "${packageobjdir}" ]; then
        echo -n "[Removing build '${PARSECPLAT}'] "
        ${RM} ${packageobjdir}
        nothingtodo="FALSE"
      fi

      # Remove run directory
      if [ -d "${packagerundir}" ]; then
        echo -n "[Removing run directory]"
        ${RM} ${packagerundir}
        nothingtodo="FALSE"
      fi

      # Finish
      if [ -z "${nothingtodo}" ]; then
        echo -n "[Nothing to do]"
      fi
      echo ""
    done
    exit 0;;
  "uninstall"     )
    echo "${oprefix} Removing installations for build '${PARSECPLAT}':"
    for package in ${pkgs}; do
      # Load package configuration
      source ${PARSECDIR}/config/packages/${package}.pkgconf

      get_topdir "${package}"

      # Setup
      packagedir="${PARSECDIR}/${benchdir}/${pkg_group}/${pkgname}"
      packageinstdir="${packagedir}/inst/${PARSECPLAT}"
      packageparsecdir="${packagedir}/parsec"
      cleanenv="sysconfig=\"${sysconfig}\" packagedir=\"${packagedir}\""
      nothingtodo=""

      echo -n "${oprefix} ${package} - "

      # Remove inst directory
      if [ -d "${packageinstdir}" ]; then
        echo -n "[Removing installation '${PARSECPLAT}'] "
        ${RM} ${packageinstdir}
        nothingtodo="FALSE"
      fi

      # Finish
      if [ -z "${nothingtodo}" ]; then
        echo -n "[Nothing to do]"
      fi
      echo ""
    done
    exit 0;;
  "fullclean"     )
    echo "${oprefix} Removing all build and run files:"
    for package in ${pkgs}; do
      # Load package configuration
      source ${PARSECDIR}/config/packages/${package}.pkgconf

      get_topdir "${package}"
      # Setup
      packagedir="${PARSECDIR}/${benchdir}/${pkg_group}/${pkgname}"
      packageobjdir="${packagedir}/obj"
      packageparsecdir="${packagedir}/parsec"
      packagerundir="${rundir}/${benchdir}/${pkg_group}/${pkgname}/run"
      cleanenv="sysconfig=\"${sysconfig}\" packagedir=\"${packagedir}\""
      nothingtodo=""

      echo -n "${oprefix} ${package} - "

      # Remove obj directory
      if [ -d "${packageobjdir}" ]; then
        echo -n "[Removing build directory] "
        ${RM} ${packageobjdir}
        nothingtodo="FALSE"
      fi

      # Remove run directory
      if [ -d "${packagerundir}" ]; then
        echo -n "[Removing run directory] "
        ${RM} ${packagerundir}
        nothingtodo="FALSE"
      fi

      # Finish
      if [ -z "${nothingtodo}" ]; then
        echo -n "[Nothing to do]"
      fi
      echo ""
    done
    exit 0;;
  "fulluninstall" )
    echo "${oprefix} Removing all installed files:"
    for package in ${pkgs}; do
      # Load package configuration
      source ${PARSECDIR}/config/packages/${package}.pkgconf

      get_topdir "${package}"
      # Setup
      packagedir="${PARSECDIR}/${benchdir}/${pkg_group}/${pkgname}"
      packageinstdir="${packagedir}/inst"
      packageparsecdir="${packagedir}/parsec"
      cleanenv="sysconfig=\"${sysconfig}\" packagedir=\"${packagedir}\""
      nothingtodo=""

      echo -n "${oprefix} ${package} - "

      # Remove inst directory
      if [ -d "${packageinstdir}" ]; then
        echo -n "[Removing installation directory]"
        ${RM} ${packageinstdir}
        nothingtodo="FALSE"
      fi

      # Finish
      if [ -z "${nothingtodo}" ]; then
        echo -n "[Nothing to do]"
      fi
      echo ""
    done
    exit 0;;
  "status"        )
    echo "${oprefix} Installation status of selected packages: "

    # Initialize local variables
    list_of_bibentries=""

    for package in ${pkgs}; do
      # Load package configuration
      source ${PARSECDIR}/config/packages/${package}.pkgconf

      echo "${oprefix}"
      cite_list=""
      for bibkey in ${pkg_cite}; do
        i=1
        is_duplicate=""
        for bib in ${list_of_bibentries}; do
          if [[ "${bibkey}" == "${bib}" ]]; then
            is_duplicate="TRUE"
            break
          fi
          ((i++))
        done
        if [[ -z "${is_duplicate}" ]]; then
          # A unique entry, append to bibliography list
          # (Note: Order is important because of the numbering)
          list_of_bibentries="${list_of_bibentries} ${bibkey}"
        fi
        # Always append citation number to list of citations for component
        if [[ -z "${cite_list}" ]]; then
          cite_list="$i"
        else
          cite_list="${cite_list},${i}"
        fi
      done

      get_topdir "${package}"

      echo "${oprefix} ${package} [${cite_list}]:"
      packageinstdir="${PARSECDIR}/${benchdir}/${pkg_group}/${pkgname}/inst"
      if [ -d "${packageinstdir}" ]; then
        build_arch_dirs="$(${LS} ${packageinstdir})"
        if [ -z "${build_arch_dirs}" ]; then
          echo -e "${oprefix}   -no installations-"
        else
          found_insts="FALSE"
          for archdir in $build_arch_dirs; do
            if [ -f "${packageinstdir}/${archdir}/build-info" ]; then
              echo -e "${oprefix}   ${archdir}"
              found_insts="TRUE"
            fi
          done
          if [ "${found_insts}" == "FALSE" ]; then
            echo -e "${oprefix}   -no installations-"
          fi
        fi
      else
        echo -e "${oprefix}   -no installations-"
      fi
    done

    # Bibliography list
    echo "${oprefix}"
    echo "${oprefix} BIBLIOGRAPHY"
    echo "${oprefix}"
    # Initialize variables & iterate through list of used bib entries
    i=1
    for bibkey in ${list_of_bibentries}; do
      bibfile="${PARSECDIR}/config/bibliography/${bibkey}.bibconf"
      if [[ -f ${bibfile} ]]; then
        source ${bibfile}
        echo "${oprefix} [${i}] ${bib_string}"
      else
        echo "${oprefix} [${i}] ERROR: File '${bibkey}.bibconf' does not exist."
      fi
      ((i++))
    done
 
    exit 0;;
  "info"        )
    # Initialize local variables
    list_of_bibentries=""
    parsecversion="$(${CAT} ${PARSECDIR}/version)"
    # Output header
    echo "${oprefix} PARSEC Distribution v${parsecversion}"
    echo "${oprefix}"
    # List all available packages
    echo "${oprefix} PACKAGES"
    echo "${oprefix}"
    for file in ${PARSECDIR}/config/packages/*.pkgconf; do
      # Get package name
      eval package=$(${BASENAME} $file)
      package=${package%\.pkgconf}
      # Load package configuration
      source ${PARSECDIR}/config/packages/${package}.pkgconf
      # Update bibliography list & get citation reference numbers
      cite_list=""
      for bibkey in ${pkg_cite}; do
        i=1
        is_duplicate=""
        for bib in ${list_of_bibentries}; do
          if [[ "${bibkey}" == "${bib}" ]]; then
            is_duplicate="TRUE"
            break
          fi
          ((i++))
        done
        if [[ -z "${is_duplicate}" ]]; then
          # A unique entry, append to bibliography list
          # (Note: Order is important because of the numbering)
          list_of_bibentries="${list_of_bibentries} ${bibkey}"
        fi
        # Always append citation number to list of citations for component
        if [[ -z "${cite_list}" ]]; then
          cite_list="$i"
        else
          cite_list="${cite_list},${i}"
        fi
      done
      # Create output
      echo "${oprefix} ${package} [${cite_list}] (${pkg_domain})"
      echo "${oprefix} ${pkg_desc}"
      echo "${oprefix}   Package Group: ${pkg_group}"
      echo "${oprefix}   Contributor:   ${pkg_contrib}"
      echo "${oprefix}   Aliases:       ${pkg_aliases}"
      echo "${oprefix}"
    done
    # List all available input sets
    echo "${oprefix} INPUT SETS"
    echo "${oprefix}"
    for inputfile in ${PARSECDIR}/config/*.runconf; do
      # Get input name
      inputname=$(${BASENAME} ${inputfile})
      inputname=${inputname/%.runconf/}
      # Load configuration file
      source ${inputfile}
      # Update bibliography list & get citation reference numbers
      cite_list=""
      for bibkey in ${pkg_cite}; do
        i=1
        is_duplicate=""
        for bib in ${list_of_bibentries}; do
          if [[ "${bibkey}" == "${bib}" ]]; then
            is_duplicate="TRUE"
            break
          fi
          ((i++))
        done
        if [[ -z "${is_duplicate}" ]]; then
          # A unique entry, append to bibliography list
          # (Note: Order is important because of the numbering)
          list_of_bibentries="${list_of_bibentries} ${bibkey}"
        fi
        # Always append citation number to list of citations for component
        if [[ -z "${cite_list}" ]]; then
          cite_list="$i"
        else
          cite_list="${cite_list},${i}"
        fi
      done
      # Output information
      echo "${oprefix} ${inputname} [${cite_list}]"
      echo "${oprefix} ${run_desc}"
      echo "${oprefix}"
    done
    # List all supported build configurations
    echo "${oprefix} BUILD CONFIGURATIONS"
    echo "${oprefix}"
    build_config_files=$(ls ${PARSECDIR}/config/*.bldconf)
    for file in ${build_config_files}; do
      config_file_base=$(${BASENAME} ${file})
      echo "${oprefix} ${config_file_base%.bldconf}"
    done
    # Bibliography list
    echo "${oprefix}"
    echo "${oprefix} BIBLIOGRAPHY"
    echo "${oprefix}"
    # Initialize variables & iterate through list of used bib entries
    i=1
    for bibkey in ${list_of_bibentries}; do
      bibfile="${PARSECDIR}/config/bibliography/${bibkey}.bibconf"
      if [[ -f ${bibfile} ]]; then
        source ${bibfile}
        echo "${oprefix} [${i}] ${bib_string}"
      else
        echo "${oprefix} [${i}] ERROR: File '${bibkey}.bibconf' does not exist."
      fi
      ((i++))
    done
    exit 0;;
  *           )
    echo "${oprefix} Error: Unknown action '${action}'."
    exit 1;;
esac

exit 0