#!/bin/bash
#
# Copyright (C) 2006-2007, Princeton University
# All rights reserved.
# Author: Christian Bienia
#
# bldconfadd - Add a build configuration to 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.0 to PARSEC 2.1:
#  - Made PARSECPLAT string detection more robust


#################################################################
#                                                               #
#                         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=""


##### 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"

  # 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
        eval "parsecdir=\$(${PWD})"
        PARSECDIR=${parsecdir}
      fi
    fi
    if [ -z "${PARSECDIR}" ]; then
      # Check next-higher directory
      if [ -f "../${uniquefile}" ]; then
        eval "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

  # Source global configuration file with alias definitions, package dependencies etc.
 # parsecconfig="${PARSECDIR}/config/parsec.conf"
 # if [ -f "${parsecconfig}" ]; then
 #   source ${parsecconfig}
 # else
 #   echo "${oprefix} Error: Cannot load global configuration file '${parsecconfig}'."
 #   exit 1
 # fi

  # 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
}

# process_args
#
# Process args and setup argument-dependent environment
#
# Arguments: all arguments given to the script (i.e. "$@")
function process_args {
  # Usage
  eval me=$(${BASENAME} $0)
  usage="\
Usage: $me -n NAME [OPTION]...

Add a new configuration to the PARSEC benchmark suite.

Options:
    -n NAME          Name of the configuration to add.
    -c CONFIG        Create a hard copy of configuration CONFIG (The resulting
                     configuration will be a full, independent copy of CONFIG).
    -s CONFIG        Create a soft copy of configuration CONFIG (The resulting
                     configuration will load CONFIG without modifications).
    -f               Overwrite any existing files.
    -h               Displays this help message.

Examples:
    - Create an empty configuration 'my-config' which does nothing:
        $me -n my-config
    - Create a copy 'my-config' of configuration 'gcc', overwrite files:
        $me -n my-config -c gcc -f
    - Create a new configuration 'my-config' which merely points to 'gcc':
        $me -n my-config -s gcc

Notes:
    If you would like to create a completely new configuration, you can use
    $me to create a template. An empty configuration will contain all
    variables which are recognized by PARSEC in a cleared form. A hard copy is a
    full copy of an existing configuration. A soft copy is merely a wrapper for
    an existing configuration. If you would like to modify an existing
    configuration only slightly, you can use a soft copy."

  # Parse arguments
  parsemode="none"
  need_arg_for=""
  config_name=""
  config_soft=""
  config_hard=""
  config_overwrite=""
  while [ ! -z "$1" ]; do
    arg="$1"
    case "${arg}" in
      "-n" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-n'"
          echo "${usage}"
          exit 1
        fi
        if [ ! -z "${config_name}" ]; then
          echo "${oprefix} Error: Two configuration names specified"
          exit 1
        fi
        need_arg_for="-n"
        parsemode="NAME";;
      "-c" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-c'"
          echo "${usage}"
          exit 1
        fi
        if [ ! -z "${config_hard}" ]; then
          echo "${oprefix} Error: Two hard copy names specified"
          exit 1
        fi
        need_arg_for="-n"
        parsemode="HCONFIG";;
      "-s" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-s'"
          echo "${usage}"
          exit 1
        fi
        if [ ! -z "${config_soft}" ]; then
          echo "${oprefix} Error: Two soft copy names specified"
          exit 1
        fi
        need_arg_for="-n"
        parsemode="SCONFIG";;
      "-f" )
        if [ ! -z "${need_arg_for}" ]; then
          echo "${oprefix} Error: ${parsemode} expected between '${need_arg_for}' and '-f'"
          echo "${usage}"
          exit 1
        fi
        config_overwrite="TRUE";;
      "-h" )
        echo "${usage}"
        exit 0;;
      *    )
        if [ ${arg:0:1} == "-" ]; then
          echo "${oprefix} Error: Unknown argument '${arg}'"
          echo "${usage}"
          exit 1
        fi
        need_arg_for=""
        case "${parsemode}" in
          "NAME"   )
            parsemode="none"
            config_name="${arg}";;
          "HCONFIG"   )
            parsemode="none"
            config_hard="${arg}";;
          "SCONFIG"   )
            parsemode="none"
            config_soft="${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 a configuration name was given
  if [ -z "${config_name}" ]; then
    echo "${oprefix} Error: A name for the new configuration must be given with option '-n'"
    exit 1
  fi

  # Check that hard and soft copy aren't requested at the same time
  if [ ! -z "${config_hard}" -a ! -z "${config_soft}" ]; then
    echo "${oprefix} Error: Cannot create hard copy ('-c') and soft copy ('-s') at the same time"
    exit 1
  fi
  if [ ! -z "${config_hard}" ]; then
    # Check whether configuration exists
    if [ ! -f "${PARSECDIR}/config/${config_hard}.bldconf" ]; then
      echo "${oprefix} Error: Configuration '${config_hard}' does not exist"
      exit 1
    fi
    # Make sure it's not the same configuration
    if [ "${config_name}" == "${config_hard}" ]; then
      echo "${oprefix} Error: Cannot create copy with same name '${config_name}'"
      exit 1
    fi
  fi
  if [ ! -z "${config_soft}" ]; then
    # Check whether configuration exists
    if [ ! -f "${PARSECDIR}/config/${config_soft}.bldconf" ]; then
      echo "${oprefix} Error: Configuration '${config_soft}' does not exist"
      exit 1
    fi
    # Make sure it's not the same configuration
    if [ "${config_name}" == "${config_soft}" ]; then
      echo "${oprefix} Error: Cannot create copy with same name '${config_soft}'"
      exit 1
    fi
  fi
}

# create_global_config_empty
#
# Create an empty, global configuration file
#
# Arguments: the configuration file to create
function create_global_config_empty {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: create_global_config_empty called with no arguments."
    exit 1
  fi
  local configfile="${PARSECDIR}/$1"

  # Check whether file already exists
  if [ -z "${config_overwrite}" ]; then
    if [ -e "${configfile}" ]; then
      echo "${oprefix} Error: File '${configfile}' already exists, use option '-f' to overwrite."
      exit 1
    fi
  fi

  # Create empty, global configuration
  touch "${configfile}"
  if [ ! "$?" -eq "0" ]; then
    echo "${oprefix} Error: Cannot create file '${configfile}'."
    exit 1
  fi
  echo "#!/bin/bash" > ${configfile}
  echo "" >> ${configfile}
  echo "# $(${BASENAME} ${configfile}) - empty configuration file for PARSEC" >> ${configfile}
  echo "" >> ${configfile}
  echo "# Compilation and linking options" >> ${configfile}
  echo "# These are the global options we'll use to build the benchmark suite." >> ${configfile}
  echo "# Each package also has a local build configuration file defining the" >> ${configfile}
  echo "# exact arguments and environment to use." >> ${configfile}
  echo "" >> ${configfile}
  echo "# Programs to use" >> ${configfile}
  echo "export CC=\"\"" >> ${configfile}
  echo "export CXX=\"\"" >> ${configfile}
  echo "export CPP=\"\"" >> ${configfile}
  echo "export CXXCPP=\"\"" >> ${configfile}
  echo "export LD=\"\"" >> ${configfile}
  echo "" >> ${configfile}
  echo "# Arguments to use" >> ${configfile}
  echo "export CFLAGS=\"\"" >> ${configfile}
  echo "export CXXFLAGS=\"\"" >> ${configfile}
  echo "export CPPFLAGS=\"\"" >> ${configfile}
  echo "export CXXCPPFLAGS=\"\"" >> ${configfile}
  echo "export LDFLAGS=\"\"" >> ${configfile}
  echo "export LIBS=\"\"" >> ${configfile}
  echo "export EXTRA_LIBS=\"\"" >> ${configfile}
  echo "" >> ${configfile}
  echo "# Java" >> ${configfile}
  echo "export JAVAC=\"\"" >> ${configfile}
  echo "" >> ${configfile}
  echo "# Version numbers" >> ${configfile}
  echo "CC_ver=\$(\${CC} --version)" >> ${configfile}
  echo "CXX_ver=\$(\${CXX} --version)" >> ${configfile}
  echo "LD_ver=\$(\${LD} --version)" >> ${configfile}
  echo "JAVAC_ver=\$(\${JAVAC} --version)" >> ${configfile}
}

# create_config_empty
#
# Create an empty, local configuration file
#
# Arguments: name of the configuration file
function create_config_empty {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: create_config_empty called with no arguments."
    exit 1
  fi
  local configfile="${PARSECDIR}/$1"

  # Check whether file already exists
  if [ -z "${config_overwrite}" ]; then
    if [ -e "${configfile}" ]; then
      echo "${oprefix} Error: File '${configfile}' already exists, use option '-f' to overwrite."
      exit 1
    fi
  fi

  # Create empty configuration
  touch "${configfile}"
  if [ ! "$?" -eq "0" ]; then
    echo "${oprefix} Error: Cannot create file '${configfile}'."
    exit 1
  fi
  echo "#!/bin/bash" > ${configfile}
  echo "" >> ${configfile}
  echo "# $(${BASENAME} ${configfile}) - empty configuration file for PARSEC" >> ${configfile}
  echo "" >> ${configfile}
  echo "# Compilation and linking options" >> ${configfile}
  echo "# This is the configuration we'll use to build the program. Each package of the" >> ${configfile}
  echo "# benchmark suite has such a file with information that will be added to the" >> ${configfile}
  echo "# global configuration. All variables set in the global configuration files can" >> ${configfile}
  echo "# be referenced here." >> ${configfile}
  echo "" >> ${configfile}
  echo "# Environment to use for configure script and Makefile" >> ${configfile}
  echo "build_env=\"\"" >> ${configfile}
  echo "" >> ${configfile}
  echo "# Whether the build system supports only in-place compilation" >> ${configfile}
  echo "# If TRUE, then all sources will be copied to the build directory before we" >> ${configfile}
  echo "# start building the package. Required for older build systems which don't" >> ${configfile}
  echo "# support VPATH" >> ${configfile}
  echo "build_inplace=\"TRUE\"" >> ${configfile}
  echo "" >> ${configfile}
  echo "# Arguments to pass to the configure script, if it exists" >> ${configfile}
  echo "build_conf=\"\"" >> ${configfile}
}

# create_config_hard
#
# Create a hard copy of a configuration file
#
# Arguments: name of the new configuration file, name of the existing configuration file
function create_config_hard {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: create_config_hard called with no arguments."
    exit 1
  fi
  local configfile="${PARSECDIR}/$1"
  if [ -z "$2" ]; then
    echo "${oprefix} Error: create_config_hard called with too few arguments."
    exit 1
  fi
  local sourcefile="${PARSECDIR}/$2"

  # Check whether file already exists
  if [ -z "${config_overwrite}" ]; then
    if [ -e "${configfile}" ]; then
      echo "${oprefix} Error: File '${configfile}' already exists, use option '-f' to overwrite."
      exit 1
    fi
  fi
  # Make sure source file exists
  if [ ! -f "${sourcefile}" ]; then
    echo "${oprefix} Configuration file '${sourcefile}' does not exist, skipping."
    return
  fi

  # Create hard copy of configuration
  touch "${configfile}"
  if [ ! "$?" -eq "0" ]; then
    echo "${oprefix} Error: Cannot create file '${configfile}'."
    exit 1
  fi
  cp ${sourcefile} ${configfile}
}

# create_config_soft
#
# Create a soft copy of a configuration file
#
# Arguments: name of the new configuration file, name of the existing configuration file
function create_config_soft {
  if [ -z "$1" ]; then
    echo "${oprefix} Error: create_config_soft called with no arguments."
    exit 1
  fi
  local configfile="${PARSECDIR}/$1"
  if [ -z "$2" ]; then
    echo "${oprefix} Error: create_config_soft called with too few arguments."
    exit 1
  fi
  local sourcefile="${PARSECDIR}/$2"
  local pathsuffix="$2"

  # Check whether file already exists
  if [ -z "${config_overwrite}" ]; then
    if [ -e "${configfile}" ]; then
      echo "${oprefix} Error: File '${configfile}' already exists, use option '-f' to overwrite."
      exit 1
    fi
  fi
  # Make sure source file exists
  if [ ! -f "${sourcefile}" ]; then
    echo "${oprefix} Configuration file '${sourcefile}' does not exist, skipping."
    return
  fi

  # Create soft copy of configuration
  touch "${configfile}"
  if [ ! "$?" -eq "0" ]; then
    echo "${oprefix} Error: Cannot create file '${configfile}'."
    exit 1
  fi
  echo "#!/bin/bash" > ${configfile}
  echo "" >> ${configfile}
  echo "# $(${BASENAME} ${configfile}) - configuration file for PARSEC" >> ${configfile}
  echo "" >> ${configfile}
  echo "source \${PARSECDIR}/${pathsuffix}" >> ${configfile}
}


#################################################################
#                                                               #
#                             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 "$@"

# Create empty configuration?
if [ -z "${config_hard}" -a -z "${config_soft}" ]; then
  create_global_config_empty "config/${config_name}.bldconf"
  for pkg in ${alias_all}; do
    eval pkggroup="\${group_${pkg}}"
    create_config_empty "pkgs/${pkggroup}/${pkg}/parsec/${config_name}.bldconf"
  done
fi

# Create hard copy of configuration?
if [ ! -z "${config_hard}" ]; then
  create_config_hard "config/${config_name}.bldconf" "config/${config_hard}.bldconf"
  for pkg in ${alias_all}; do
    eval pkggroup="\${group_${pkg}}"
    create_config_hard "pkgs/${pkggroup}/${pkg}/parsec/${config_name}.bldconf" "pkgs/${pkggroup}/${pkg}/parsec/${config_hard}.bldconf"
  done
fi

# Create soft copy of configuration?
if [ ! -z "${config_soft}" ]; then
  create_config_soft "config/${config_name}.bldconf" "config/${config_soft}.bldconf"
  for pkg in ${alias_all}; do
    eval pkggroup="\${group_${pkg}}"
    create_config_soft "pkgs/${pkggroup}/${pkg}/parsec/${config_name}.bldconf" "pkgs/${pkggroup}/${pkg}/parsec/${config_soft}.bldconf"
  done
fi