#!/bin/bash -x

#PBS -N IOR
#PBS -j oe
#PBS -l walltime=00:49:00
#PBS -l size=8
#PBS -q batch
#PBS -A stf006
#PBS -V

cd $PBS_O_WORKDIR

/opt/public/bin/nodeinfo-cnl

xtprocadmin > ./NODEINFO

EXEC=${PWD}/../src/C/IOR
IODIR=/lustre/scr144/swh13/test_files_x
RESULTS=${PWD}

which mpirun

#rm -fr $IODIR
#mkdir  $IODIR
lfs find -v $IODIR

let "w=128"
let "s=1024*1024"

RESULTS="."
for tid in 1 2 3 4 5 6 7 8 9 10 11 12 13 14    16    18 19 20
do
XFERS="1048576 262144 32768 4096 1024"
for xfer in `echo $XFERS`
do
       let "n=8"
until [ "$n" -gt 8 ]
do

    let "m=$n/4"
  #TESTS="POSIX MPIIO HDF5 NCMPI"
  TESTS="POSIX"
  for test in `echo $TESTS`
  do
    runid="p$n.$xfer.${test}"
    date | tee    ${RESULTS}/${runid}.log

    let "block=${xfer}"
    case "$tid" in
    1 )
    #fileperproc write, random offset (no matter, just one write/file)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -w    -z                 -v -v -F -o $IODIR/testwrite.${runid}    -e -i 100 -m -t ${xfer} -b ${block} -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    2 )
    #fileperproc write, random offsetis for (10 writes/file)
    let "block=${xfer}*10"
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -w    -z                 -v -v -F -o $IODIR/testwrite.${runid}    -e -i 100 -m -t ${xfer} -b ${block} -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    3 )
    #shared file write, random offsets (1 writes/file)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -w    -z                 -v -v    -o $IODIR/testwrite.${runid}    -e -i 100 -m -t ${xfer} -b ${block} -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;; 
    4 )
    #generate fileperproc write files for subsequent reads)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -w    -z                 -v -v -F -o $IODIR/testwrite.${runid} -k -e -i 100 -m -t ${xfer} -b ${block} -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    5 )
    #fileperproc each proc reads file just written by it's own core)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z                 -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m -t ${xfer} -b ${block} -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    6 )
    #fileperproc each proc reads file just written by it's own core, test zero offset...should be close to previous test)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -C -Q 0         -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    7 )
    #fileperproc each proc reads file just written by proc offset by 1 node, defeat client side caching)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -C -Q 1         -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    8 )
    #fileperproc each proc reads file just written by proc offset by at least $m nodes, defeat client side caching, compare with offset of 1)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -C -Q $m        -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    9 )
    #fileperproc each proc reads file just written by proc randomly offset, seed 139, same random pattern per iteration, defeat client side caching, compare with offset of 1)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -Z -Q 0  -X 139 -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
   ;;
    10 )
    #fileperproc each proc reads file just written by proc randomly offset by at least 1 node, seed 139, same random pattern per iteration, defeat client side caching, compare with offset of 1)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -Z -Q 1  -X 139 -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    11 )
    #fileperproc each proc reads file just written by proc randomly offset by at least $m nodes, seed 139, same random pattern per iteration, defeat client side caching, compare with offset of 1)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -Z -Q $m -X 139  -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    12 )
    #fileperproc each proc reads file just written by proc randomly offset by at least 0 nodes, seed 139, different random pattern per iteration, defeat client side caching, compare with offset of 1)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -Z -Q 0  -X -139 -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    13 )
    #fileperproc each proc reads file just written by proc randomly offset by at least 1 nodes, seed 139, different random pattern per iteration, defeat client side caching, compare with offset of 1)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -Z -Q 1  -X -139 -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    14 )
    #fileperproc each proc reads file just written by proc randomly offset by at least $m nodes, seed 139, different random pattern per iteration, defeat client side caching, compare with offset of 1)
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z -Z -Q $m -X -139 -v -v -F -o $IODIR/testwrite.${runid} -k    -i 100 -m  -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    15 )
    #delete files run
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z                            -v -v -F -o $IODIR/testwrite.${runid}       -i 100 -m -t ${xfer} -b ${block}  -d 0.0 | tee -a ${RESULTS}/${runid}.log
    ;;
    16 )
    #           shared-file write
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -w                 -v -v    -o $IODIR/testwrite.${runid} -k -e -i 100 -m -t ${xfer} -b ${block}  -d 0.1  | tee -a ${RESULTS}/${runid}.log
    ;;
    17 )
    #random     shared-file write
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -w    -z           -v -v    -o $IODIR/testwrite.${runid} -k -e -i 100 -m -t ${xfer} -b ${block}  -d 0.1  | tee -a ${RESULTS}/${runid}.log
    ;;
    18 )
    #           shared-file read, offset by 0 node 
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r              -v -v    -o $IODIR/testwrite.${runid}  -k   -i 100 -m -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    19 )
    #           shared-file read, offset by 1 node 
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r    -C        -v -v    -o $IODIR/testwrite.${runid}  -k   -i 100 -m -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;
    20 )
    #random     shared-file read,random offset
    aprun -n $n ${EXEC} -A ${tid} -a ${test} -E -r -z           -v -v    -o $IODIR/testwrite.${runid}  -k   -i 100 -m -t ${xfer} -b ${block}  -d 0.1 | tee -a ${RESULTS}/${runid}.log
    ;;

    esac

    date | tee -a ${RESULTS}/${runid}.log
  done
  let "n = $n * 2"
 done #n
done #xfer
done #tid
exit