Open Porous Media Git 1.3.34

pts/opm-git-1.3.34 - 07 February 2019 - Build fix.

downloads.xml

<?xml version="1.0"?>
<!--Phoronix Test Suite v8.6.0-->
<PhoronixTestSuite>
  <Downloads>
    <Package>
      <URL>http://gforge.inria.fr/frs/download.php/file/34618/scotch_6.0.4.tar.gz, http://pkgs.fedoraproject.org/repo/pkgs/scotch/scotch_6.0.4.tar.gz/d58b825eb95e1db77efe8c6ff42d329f/scotch_6.0.4.tar.gz</URL>
      <MD5>d58b825eb95e1db77efe8c6ff42d329f</MD5>
      <SHA256>f53f4d71a8345ba15e2dd4e102a35fd83915abf50ea73e1bf6efe1bc2b4220c7</SHA256>
      <FileName>scotch_6.0.4.tar.gz</FileName>
      <FileSize>4804966</FileSize>
    </Package>
    <Package>
      <URL>http://www.cs.sandia.gov/~kddevin/Zoltan_Distributions/zoltan_distrib_v3.8.tar.gz, http://ftp.mcs.anl.gov/pub/petsc/externalpackages/zoltan_distrib_v3.8.tar.gz</URL>
      <MD5>9d8fba8a990896881b85351d4327c4a9</MD5>
      <SHA256>5bdd46548fb9c73b225bbcf3d206c558c318cb292f0b19645e536315d14aafb7</SHA256>
      <FileName>zoltan_distrib_v3.8.tar.gz</FileName>
      <FileSize>5407789</FileSize>
    </Package>
    <Package>
      <FileName>omega-opm.tar.gz</FileName>
      <FileSize>440350494</FileSize>
    </Package>
  </Downloads>
</PhoronixTestSuite>

install.sh

#!/bin/bash

WDIR=$PWD
cd $WDIR

# NUM_CPU_CORES is always exported by the Phoronix Test Suite, but keep this logic here just for external testing purposes
if test -z $NUM_CPU_CORES
then
  if test -n `which nproc`
  then
    NUM_CPU_CORES=`nproc`
  else
    NUM_CPU_CORES=1
  fi
fi

# Download source from github
FOOTNOTE_INFO="Build Time `date`"

# Make Install folder
mkdir $WDIR/Install

# Download and build libecl from git
if [ -d libecl ]; then 
   pushd libecl
   git pull
   popd
else
   git clone --depth 1 https://github.com/Statoil/libecl.git
fi

mkdir libecl/build
pushd libecl/build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j $NUM_CPU_CORES 
popd

#Download and build opm simulators with MPI support from git
for repo in opm-common opm-grid opm-material ewoms opm-simulators
do

    # Determine if to clone from main URL or different repo, based upon REPO_{$repo} environment variable
    echo "### "
    echo "### $repo"
    echo "### "
    repo_env_var_check=REPO_`echo "$repo" | awk '{print toupper($0)}' | sed 's/-/_/g'`
    if test -z ${!repo_env_var_check}
    then
       repo_url="https://github.com/OPM/$repo.git"
       echo "$repo_env_var_check is not set, using $repo_url"
    else
       echo "$repo_env_var_check is set to ${!repo_env_var_check}"
       repo_url=${!repo_env_var_check}
    fi

    # use the base64 of the Git URL as the basis for the directory to avoid collissions
    repo_dir=`base64 <<< "$repo_url"`
    echo "$repo directory is $repo_dir"
    if [ -d "$repo_dir" ]; then 
        pushd "$repo_dir"
        git pull
        popd
    else
        git clone --depth 1 $repo_url "$repo_dir"
    fi

    # Determine if checking out Git master (default) or some other point based upon REPO_{$repo}_CHECKOUT environment variable
    git_checkout_env_var_check=${repo_env_var_check}_CHECKOUT
    if test -z ${!git_checkout_env_var_check}
    then
    	repo_checkout="master"
        echo "$git_checkout_env_var_check is not set, checking out $repo_checkout"
        pushd "$repo_dir"
        git checkout $repo_checkout
        popd
    elif [[ "${!git_checkout_env_var_check}" =~ ^[0-9]+$ ]]
    then
    	repo_checkout=${!git_checkout_env_var_check}
        echo "$git_checkout_env_var_check is a number, assuming it's a GitHub pull request - ${!git_checkout_env_var_check}"
        pushd "$repo_dir"
	git pull --no-edit origin pull/${!git_checkout_env_var_check}/head
        popd
    else
    	repo_checkout=${!git_checkout_env_var_check}
        echo "$git_checkout_env_var_check is set, checking out ${!git_checkout_env_var_check}"
        pushd "$repo_dir"
        git checkout $repo_checkout
        popd
    fi

   # symlinks for the default directory to the BASE64'd directories intended for this round of testing
   unlink $repo
   ln -s "$repo_dir" $repo

    mkdir "$repo_dir"/build
    pushd "$repo_dir"/build
    make clean
    cmake -DCMAKE_BUILD_TYPE=Release \
          -DUSE_OPENMP=ON \
          -DCMAKE_PREFIX_PATH=$WDIR/Install \
          -DUSE_MPI=ON -Decl_DIR=$WDIR/libecl/build -DBUILD_TESTING=OFF ..
    make -j $NUM_CPU_CORES 
    ecode=$?
    echo $? > ~/install-exit-status
    test $? -eq 0 || exit 1
    popd
done

echo $FOOTNOTE_INFO > ~/install-footnote

# SETUP OMEGA IF PRESENT
if test -f $HOME/omega-opm.tar.gz
then
  git clone --depth 1 https://github.com/OPM/opm-data.git
  pushd opm-data
  tar -xf ~/omega-opm.tar.gz
  popd
fi

#####################################################
# Run benchmark
#####################################################

echo "<?php 

\$log_file = file_get_contents(getenv('LOG_FILE'));
function get_value_from_line(\$log_file, \$s)
{
	\$s .= ': ';
	\$log_file .= PHP_EOL;
	if((\$x = strpos(\$log_file, \$s)) !== false)
	{
		\$log_file = substr(\$log_file, (\$x + strlen(\$s)));
		\$log_file = substr(\$log_file, 0, strpos(\$log_file, PHP_EOL));

		if(str_replace(array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, '%', ' ', '.', '(', ')', 'Failed:', ';'), '', \$log_file) == null)
		{
			\$log_file = str_replace('Failed:' , 'F:', \$log_file);
			return trim(\$log_file);
		}
	}
}
if((\$x = strpos(\$log_file, 'End of simulation')) !== false)
{
	\$log_file = substr(\$log_file, \$x);
	foreach(array('Assembly time (seconds)', 'Linear solve time (seconds)', 'Solver time (seconds)', 'Update time (seconds)', 'Output write time (seconds)', 'Overall Well Iterations', 'Overall Linearizations', 'Overall Newton Iterations', 'Overall Linear Iterations') as \$a)
	{
		\$val = get_value_from_line(\$log_file, \$a);
		if(\$val == null)
		{
			continue;
		}
		if((\$x = strpos(\$a, ' (')) !== false)
		{
			\$a = substr(\$a, 0, \$x);
		}
		echo ucwords(str_replace('Overall ', '', \$a)) . ': ' . \$val . PHP_EOL;
	}

}" > report-additional-data.php

echo "#!/bin/sh

NPROC=\$2

if [ ! \"X\$HOSTFILE\" = \"X\" ] && [ -f \$HOSTFILE ]
then
	HOSTFILE=\"--hostfile \$HOSTFILE\"
elif [ -f /etc/hostfile ]
then
	HOSTFILE=\"--hostfile /etc/hostfile\"
else
	HOSTFILE=\"\"
fi

MPIRUN_AS_ROOT_ARG=\"--allow-run-as-root\"
if [ \`whoami\` != \"root\" ]
then
  MPIRUN_AS_ROOT_ARG=\"\"
fi

if dmesg | grep -q NUMA; then
    MPI_MAP_BY=\"--map-by numa\"
else
    MPI_MAP_BY=\"--map-by socket\"
fi
MPI_MAP_BY=\"--map-by socket\"

if [ \$1 = \"upscale_relperm_benchmark\" ]
then
	nice mpirun \$MPIRUN_AS_ROOT_ARG -np \$NPROC \$MPI_MAP_BY --report-bindings \$HOSTFILE ./opm-upscaling/build/bin/upscale_relperm_benchmark --tolerance-mb=1e-5 --max-strict-iter=4 > \$LOG_FILE 2>&1
elif [ \$1 = \"flow_mpi_norne\" ]
then
	cd opm-data/norne
	nice mpirun \$MPIRUN_AS_ROOT_ARG -np \$NPROC \$MPI_MAP_BY --report-bindings \$HOSTFILE ../../opm-simulators/build/bin/flow NORNE_ATW2013.DATA --tolerance-mb=1e-5 --max-strict-iter=4 > \$LOG_FILE 2>&1
elif [ \$1 = \"flow_ebos_extra\" ]
then
	cd opm-data/omega-opm
	nice mpirun \$MPIRUN_AS_ROOT_ARG -np \$NPROC \$MPI_MAP_BY --report-bindings \$HOSTFILE ../../opm-simulators/build/bin/flow OMEGA-0.DATA --tolerance-mb=1e-5 --max-strict-iter=4 > \$LOG_FILE 2>&1
elif [ \$1 = \"flow_mpi_extra\" ]
then
	cd opm-data/omega-opm
	nice mpirun \$MPIRUN_AS_ROOT_ARG -np \$NPROC \$MPI_MAP_BY --report-bindings \$HOSTFILE ../../opm-simulators/build/bin/flow OMEGA-0.DATA --tolerance-mb=1e-5 --max-strict-iter=4 > \$LOG_FILE 2>&1
else
	nice mpirun \$MPIRUN_AS_ROOT_ARG -np \$NPROC \$MPI_MAP_BY --report-bindings \$HOSTFILE opm-simulators/build/bin/flow \$1 --tolerance-mb=1e-5 --max-strict-iter=4 > \$LOG_FILE 2>&1
fi

cd ~
\$PHP_BIN report-additional-data.php > ~/pts-footnote 

# echo \$? > ~/test-exit-status" > opm-git
chmod +x opm-git

results-definition.xml

<?xml version="1.0"?>
<!--Phoronix Test Suite v8.6.0-->
<PhoronixTestSuite>
  <ResultsParser>
    <OutputTemplate>Total wallclock time:       #_RESULT_# sec  (52 min 59.02 sec)</OutputTemplate>
    <MatchToTestArguments>upscale_relperm_benchmark</MatchToTestArguments>
    <LineHint>Total wallclock time</LineHint>
  </ResultsParser>
  <ResultsParser>
    <OutputTemplate>Total time taken (seconds):  #_RESULT_#</OutputTemplate>
    <LineHint>Total time</LineHint>
  </ResultsParser>
  <ResultsParser>
    <OutputTemplate>Total time (seconds):  #_RESULT_#</OutputTemplate>
    <LineHint>Total time</LineHint>
  </ResultsParser>
</PhoronixTestSuite>

test-definition.xml

<?xml version="1.0"?>
<!--Phoronix Test Suite v8.6.0-->
<PhoronixTestSuite>
  <TestInformation>
    <Title>Open Porous Media Git</Title>
    <Description>This is a test of Open Porous Media, a set of open-source tools concerning simulation of flow and transport of fluids in porous media. This test profile builds OPM and its dependencies from upstream Git.</Description>
    <ResultScale>Seconds</ResultScale>
    <Proportion>LIB</Proportion>
    <TimesToRun>3</TimesToRun>
    <PreInstallMessage>Some external dependencies needed for this test are not currently covered by the Phoronix Test Suite. You might need to manually install those packages; on an Ubuntu system it would be - sudo apt-get install build-essential cmake git wget libblas-dev liblapack-dev libsuitesparse-dev libtrilinos-zoltan-dev mpi-default-dev mpi-default-bin libbz2-1.0 libbz2-dev libbz2-ocaml libbz2-ocaml-dev libdune-common-dev libdune-grid-dev libdune-geometry-dev libdune-istl-dev libsuperlu-dev libsuperlu5 libboost-all-dev.</PreInstallMessage>
  </TestInformation>
  <TestProfile>
    <Version>1.3.34</Version>
    <SupportedPlatforms>Linux</SupportedPlatforms>
    <SoftwareType>Utility</SoftwareType>
    <TestType>Processor</TestType>
    <License>Free</License>
    <Status>Verified</Status>
    <ExternalDependencies>build-utilities, fortran-compiler, cmake, boost-development, suitesparse, tinyxml, openmpi-development, blas-development, lapack-development</ExternalDependencies>
    <EnvironmentSize>2000</EnvironmentSize>
    <ProjectURL>http://www.opm-project.org/</ProjectURL>
    <InternalTags>SMP</InternalTags>
    <Maintainer>Michael Larabel</Maintainer>
    <RemoveInstallDirectoryOnReinstall>FALSE</RemoveInstallDirectoryOnReinstall>
  </TestProfile>
  <TestSettings>
    <Option>
      <DisplayName>OPM Benchmark</DisplayName>
      <Identifier>opm-benchmark</Identifier>
      <Menu>
        <Entry>
          <Name>Upscale-Relperm</Name>
          <Value>upscale_relperm_benchmark</Value>
        </Entry>
        <Entry>
          <Name>Flow MPI Norne</Name>
          <Value>flow_mpi_norne</Value>
        </Entry>
        <Entry>
          <Name>Flow MPI Extra</Name>
          <Value>flow_mpi_extra</Value>
        </Entry>
      </Menu>
    </Option>
    <Option>
      <DisplayName>Threads</DisplayName>
      <Identifier>threads</Identifier>
      <Menu>
        <Entry>
          <Name>1</Name>
          <Value>1</Value>
        </Entry>
        <Entry>
          <Name>2</Name>
          <Value>2</Value>
        </Entry>
        <Entry>
          <Name>4</Name>
          <Value>4</Value>
        </Entry>
        <Entry>
          <Name>8</Name>
          <Value>8</Value>
        </Entry>
        <Entry>
          <Name>16</Name>
          <Value>16</Value>
        </Entry>
        <Entry>
          <Name>32</Name>
          <Value>32</Value>
        </Entry>
        <Entry>
          <Name>64</Name>
          <Value>64</Value>
        </Entry>
        <Entry>
          <Name>128</Name>
          <Value>128</Value>
        </Entry>
      </Menu>
    </Option>
  </TestSettings>
</PhoronixTestSuite>