test.sh

#!/bin/bash
# process recipe file compile and test all one test for all FPU configuration with optional defines

# recipe file syntax
# 0           1    2        3           4            5...
# <TESTNAME> <ID> <DAIFPU> <CHECKTYPE> <CHECKVALUE> <CFLAGS>
# if a line starts with '!' the line contains name of used toolchain ('llvm','gcc'), if it is used, linker script is cleared automatically 
# if a line starts with '$' the line contains name of used linker script file (link128kB, linkram2, ...)
# if a line starts with '^' the line contains CFLAGS used in all tests (the content is add to the end of each line with test [under the line])
# if a line starts with '*' the line contains defined symbols (used for adding -D and include them into CFLAGS
# if a line starts with '-' the line contains ID_from and ID_to as a range of used IDs
# if a line starts with '@' the line contains suffix to build directory for all next lines
# if a line starts with '~' the line contains additional settings for makefiles which are run
# if a line starts with '>' the line contains architecture selection (>march mabi [arch_cflags]) 
#                           ACHR=<march>, ABI=<mabi>, ARCHCFLAGS=-daiteq-fpu-type=<DAIFPU> [-m(arch_cflags)]
#                           e.g. '> rv64imaf_zfh_x-swar lp64d soft-float'
#                       '>' the keyword 'daifpu' can be used instead of ARCH and ABI for using <DAIFPU> from each test

#FPUS="daifpu_divsqrt daifpu_divonly daifpu_none daifpu_dual_dpsp_divsqrt daifpu_dual_dpsp_divonly daifpu_dual_dpsp_none \
     #daifpu_dual_sphp_divsqrt daifpu_dual_sphp_divonly daifpu_dual_sphp_none daifpu_dp_divsqrt daifpu_dp_divonly daifpu_dp_none \
     #daifpu_sp_divsqrt daifpu_sp_divonly daifpu_sp_none daifpu_hp_divsqrt daifpu_hp_divonly daifpu_hp_none \
     #daifpu_psp_divsqrt daifpu_psp_divonly daifpu_psp_none daifpu_php_divsqrt daifpu_php_divonly daifpu_php_none none"


if [ $# -lt 2 ]
then
    echo "The script needs two arguments at least - operation and recipe file."
    echo "Syntax: $0 <operation> <recipe> [<options>]"
    echo "Allowed operations are 'build','mgsim','ghdlsim','check','clean','rungrmon','runoocd'."
    echo "Optional arguments are:"
    echo "   F<fpu_type>    - FPU type for processing only lines with the selected FPU (all flavors)"
    echo "   S<fpu_subtype> - FPU subtype (divsqrt,divonly,none) for selection of required FPU flavor"
    echo "   p<serial_port> - select serial port for reading and saving data from board"
    echo "   f<ID_from>     - ID of lower bound (process only lines with equal or higher ID)"
    echo "   t<ID_to>       - ID of upper bound (process only lines with equal or lower ID)"
    echo "   g<grmon_port>  - change the default port for communication with grmon"
    echo "   n              - run each 'make' with '--dry-run'"
    echo "   C<clkfreq>     - add define -DSYSCLK=<clkfreq> at the end of CFLAGS (sysclk is in [Hz])"
    exit 1
fi

OP=$1
FILE=$2

TIMESTAMP=`date +"%Y%m%d_%H%M"`
CLEARFILE=`basename -s .txt ${FILE}`

BUILD_DIR=./BUILD
GSIM_ODIR=./GHDL
RESULT_DIR=./RESULTS/work_${TIMESTAMP}/$2
RESULT_OOCD_DIR=./RESULTS_OOCD/work_${TIMESTAMP}/$2
STAMPFILE=/tmp/test.timestamp
PIDFILE=/tmp/test.pid
AWKTIMEOUT="30s"
GRMONTIMEOUT="25m"

GRMON_PORT=/dev/ttyUSB1
SERPORT=""
idfrom=""
idto=""
fputype=""
fpusub=""
DRYRUN=""
CLKFREQ=""

for i in "${@:3}"
do
#  echo ">> $i - ${i:0:1} - ${i:1}"
  case ${i:0:1} in
    F)
      fputype=${i:1}
    ;;
    S)
      fpusub=${i:1}
    ;;
    p)
      SERPORT=${i:1}
    ;;
    f)
      idfrom=${i:1}
    ;;
    t)
      idto=${i:1}
    ;;
    g)
      GRMON_PORT=${i:1}
    ;;
    n)
      DRYRUN="-n"
    ;;
    C)
      CLKFREQ=" -DSYSCLK=${i:1}"
  esac
done

if [[ ! -f "${FILE}" ]]
then
  echo "Recipe file does not exist."
  exit
fi

ln=0

# default values of variables
tool="llvm"
ldscr=""
ccflgs=""
defs=""
dsuf=""
mkset=""
archstr="rv64gc lp64d"

# once actions
case ${OP} in
  runoocd)
    mkdir -p $(pwd)/${RESULT_OOCD_DIR}
    if [ -z "${SERPORT}" ]; then
      echo "Serial port for reading is not set."
      exit 1
    fi
    if pgrep "openocd" >/dev/null 2>&1
    then
      echo "OpenOCD is running."
    else
      echo "OpenOCD is not running."
      exit 1
    fi
   ;;

  rungrmon)
    mkdir -p $(pwd)/${RESULT_DIR}
#    if [ -z "${SERPORT}" ]; then
#      echo "Serial port for reading is not set."
#      exit 1
#    fi
   ;;

  *)
   ;;
esac

skipbefore=0

# process recipe
while IFS= read -r line
do
 ln=$((ln+1))
 pln=( ${line} )

 if [[ ${pln[0]} == "#"* ]]   # skip comments
 then
  continue
 fi

 if [[ ${pln[0]} == "!"* ]]   # line starts with '!' globally controls make rules (e.g. select toolchain)
 then
  tool=${pln[1]}
  ldscr=""
  continue
 fi

 if [[ ${pln[0]} == "$"* ]]   # line starts with '$' change linker script
 then
   ldscr="${pln[1]}"
   continue
 fi

 if [[ ${pln[0]} == "^"* ]]   # line starts with '^' set common CFLAGS
 then
   ccflgs="${pln[@]:1}"
   continue
 fi

 if [[ ${pln[0]} == "*"* ]]   # line starts with '*' define symbols
 then
   defs="${pln[@]:1}"
   continue
 fi

 if [[ ( ${#pln[*]} -gt 2 ) && ( ${pln[0]} == "-"* ) ]]   # line starts with '-' select range of IDs for processing
 then
   idfrom="${pln[1]}"
   idto="${pln[2]}"
   continue
 fi

 if [[ ( ${#pln[*]} -gt 1 ) && ( ${pln[0]} == "@"* ) ]]   # line starts with '@' set build directory suffix
 then
   dsuf="_${pln[1]}"
   continue
 fi

 if [[ ( ${#pln[*]} -gt 1 ) && ( ${pln[0]} == "~"* ) ]]   # line starts with '~' set make variables
 then
   mkset="${pln[@]:1}"
   continue
 fi
 
 if [[ ( ${#pln[*]} -ge 2 ) && ( ${pln[0]} == ">"* ) ]]  # line starts with '>' change architecture string
 then
   archstr="${pln[@]:1}"
#   if [[ ( ${#archstr[*]} -eq 1 ) || ( ${archstr[0]} == "daifpu" ) ]]
#   then
#     archstr="daifpu"
#   fi
   continue
 fi

 if [[ ${#pln[*]} -eq 0 ]]    # skip empty lines
 then
  continue
 fi

 if [[ ${#pln[*]} -lt 3 ]]    # skip lines with bad syntax
 then
  echo "ERROR: Bad syntax on line #${ln}."
  continue
 fi



 # check if ID is in selected range
 if [[ ( ! -z "${idfrom}" ) && ( ${pln[1]} -lt ${idfrom} ) ]]
 then
  if [ ${skipbefore} -eq 0 ]
  then
   echo "Skip IDs:"
   skipbefore=1
  fi
  echo -n "  ${pln[1]}"
  continue
 fi
 if [[ ( ! -z "${idto}" ) && ( ${pln[1]} -gt ${idto} ) ]]
 then
  echo "Skip all IDs from ${pln[1]}"
  break
 fi
 
 if [ ${skipbefore} -eq 1 ]
 then
  skipbefore=0
  echo ""
 fi
 
 # check FPUTYPE/FPUSUB
 if [[ ( ! -z "${fputype}" ) && ( ${pln[2]} != "${fputype}"* ) ]]
 then
  echo "Skip FPU ${pln[2]} (${pln[1]})"
  continue
 fi
 if [[ ( ! -z "${fpusub}" ) && ( ${pln[2]} != *"_${fpusub}" ) ]]
 then
  echo "Skip FPUsub ${pln[2]} (${pln[1]})"
  continue
 fi

archarr=( $archstr )
if [[ ${archarr[0]} == "daifpu" ]]
then
  add=${archarr[@]:1}
  case ${pln[2]} in
    daifpu_divsqrt | daifpu_divonly | daifpu_none | daifpu_dual_dpsp_divsqrt | daifpu_dual_dpsp_divonly | daifpu_dual_dpsp_none)
      archarr=(rv64g lp64d)
      ;;
    daifpu_dual_sphp_divsqrt | daifpu_dual_sphp_divonly | daifpu_dual_sphp_none)
      archarr=(rv64imaf_zfh lp64f)
      ;;
    daifpu_dp_divsqrt | daifpu_dp_divonly | daifpu_dp_none)
      archarr=(rv64g lp64d)
      ;;
    daifpu_sp_divsqrt | daifpu_sp_divonly | daifpu_sp_none)
      archarr=(rv64imaf lp64f)
      ;;
    daifpu_hp_divsqrt | daifpu_hp_divonly | daifpu_hp_none)
      archarr=(rv64ima_zfh lp64)
      ;;
    daifpu_php_divsqrt | daifpu_php_divonly | daifpu_php_none)
      archarr=(rv64ima_zfh_x-fph lp64)
      ;;
    daifpu_psp_divsqrt | daifpu_psp_divonly | daifpu_psp_none)
      archarr=(rv64imaf_x-fps lp64f)
      ;;
    none)
      archarr=(rv64ima lp64)
      ;;
    *) 
      echo "Unsupported fputype '${pln[2]}' for automatic selection of the architecture/ABI"
      continue
      ;;
  esac
  if [ ${#add[*]} -ge 1 ]
  then
    archarr+=($add)
  fi
else
  archarr=( ${archstr} )
fi

ucflags="${pln[@]:3} ${ccflgs}"
if [ ! -z "${CLKFREQ}" ]; then
#  echo "set sysclk from cmdline ${CLKFREQ}"
  # find and remove previously defined SYSCLK
  if [[ $ucflags = *-DSYSCLK=* ]]; then
#    echo "remove previous -DSYSCLK"
    ucflags=$(awk -F '-DSYSCLK=[0-9]*' '{print $1 $2}' <<< "${ucflags}")${CLKFREQ}
#    echo "DONE : ${ucflags}"
  else
   ucflags=${ucflags}${CLKFREQ}
  fi
fi

if [[ ${pln[2]} == swar* ]]
then
 testtype="SWAR"
 makeopts="TEST=${pln[0]} BDIR=${BUILD_DIR} LDS=${ldscr} ID=${pln[1]} SWARCFG=${pln[2]} MAKEVAR='${mkset}' UCFLAGS='${ucflags}' ARCH=${archarr[0]} ABI=${archarr[1]} ARCHCFLAGS='${archarr[@]:2}' ${DRYRUN}"
else
 testtype="FPU"
 makeopts="TEST=${pln[0]} BDIR=${BUILD_DIR} LDS=${ldscr} ID=${pln[1]} FPUCFG=${pln[2]} MAKEVAR='${mkset}' UCFLAGS='${ucflags}' ARCH=${archarr[0]} ABI=${archarr[1]} ARCHCFLAGS='${archarr[@]:2}' ${DRYRUN}"
fi



 echo -e "\nProcess line #${ln}: T=${pln[0]} ID=${pln[1]} ${testtype}=${pln[2]} CF=\"${ucflags}\""
# echo " => makeopts = '${makeopts}'"

 case ${OP} in
  build)
   echo -e "\nCompile '${pln[0]}' for ${testtype} '${pln[2]}' with CFLAGS=\"${ucflags}\""
#   echo "Call: ${makeopts}"
   if [ ! -z "${DRYRUN}" ]; then
     echo "make -f Makefile.${tool} ${mkset} DSUFFIX=${dsuf} ${makeopts}"
   fi
   eval make -f Makefile.${tool} ${mkset} DSUFFIX=${dsuf} ${makeopts}
   MRES=$?
   echo "${pln[1]}-${pln[0]}-${pln[2]} ${MRES}" >> ${BUILD_DIR}/${TIMESTAMP}-${CLEARFILE}.log
   if [ ${MRES} -ne 0 ]
   then
    echo "Compilation of '${pln[0]}' (ID=${pln[1]}) for ${testtype} '${pln[2]}' failed"
    break
   fi
   ;;

  mgsim)
   echo -e "\nSimulate '${pln[0]}' for ${testtype} '${pln[2]}' with CFLAGS=\"${ucflags}\" "
   echo "make sim NOLOG=y DSUFFIX=${dsuf} ${makeopts}"
   eval make sim NOLOG=y DSUFFIX=${dsuf} ${makeopts}
   ;;

  ghdlsim)
    echo -e "\nSimulate '${pln[0]}' for ${testtype} '${pln[2]}' with GHDL simulator (CFLAGS='${ucflags}')"
   if [ -f "ghdlsim.map" ]; then
    ghdlexe=""
    while IFS= read -r gsim
    do
     gs=( ${gsim} )
     if [ "${pln[2]}" == "${gs[0]}" ]; then
      ghdlexe=${gs[1]}
     fi
    done < "ghdlsim.map"
    if [ -z ${ghdlexe} ]; then
     echo "  GHDL simulator not defined for ${testtype} '${pln[2]}'"
    else
     # test if test.dat file exists
     testname=${pln[0]}-${pln[1]}-${pln[2]}
     datfile=${BUILD_DIR}/${pln[2]}${dsuf}/${testname}.dat
     if [ ! -f "${datfile}" ]; then
      echo "Test ${testname} is not prepared"
     else
      if [ -f "${ghdlexe}" ]; then
       # get full path to GHDL simulator
       fullgexe=`find "$(pwd)"/"${ghdlexe}" -type f`
       #echo "FULLGHDL '${fullgexe}'"
       mkdir -p ${GSIM_ODIR}/${pln[2]}
       # make link in simulaiton directory
       ln -f -s "${fullgexe}" ${GSIM_ODIR}/${pln[2]}/ghdlsim
       # copy test as DAT file into simulation directory as ddr.dat file
       cp ${datfile} ${GSIM_ODIR}/${pln[2]}/ddr.dat
       # run simulation
       (cd ${GSIM_ODIR}/${pln[2]}; ./ghdlsim | awk '!/metavalue|cpu0|rf_int/{print }' | tee ${testname}.log;)
      else
       echo " GHDL simulator for ${testtype} '${pln[2]}' is not reachable"
      fi
     fi
    fi

   else
    echo "GHDL simulation needs file 'ghdlsim.map' which contains lines with mapping"
    echo " of FPUCFG to path to executable ghdl simulator which will be used for the"
    echo " specific FPU mode."
    echo "  (example of a line  'daifpu_dual_dpsp_divsqrt  /opt/ghdl_sim_dai_dpsp')"
   fi
   ;;


  runoocd)
    echo -e "\nRun OpenOCD for '${pln[0]}' with ${testtype} '${pln[2]}'"
    testname=${pln[0]}-${pln[1]}-${pln[2]}
    elffile=$(pwd)/${BUILD_DIR}/${pln[2]}${dsuf}/${testname}.elf
    outfile=$(pwd)/${RESULT_OOCD_DIR}/${testname}-output.log
    oocdlog=$(pwd)/${RESULT_OOCD_DIR}/${testname}-oocd.log
    timeoutlog=$(pwd)/${RESULT_OOCD_DIR}/${testname}.timeout
    elflink="/tmp/test.elf"
    echo "ELF:     ${elffile}"
    echo "OUTFILE: ${outfile}"
    echo "SerPort: ${SERPORT}"
    if [[ ! -f "${elffile}" ]]; then
      echo "!!! ELF file '${elffile}' does not exist. Skip"
      continue
    fi

    if [[ -f "${elflink}" ]]; then
      if [[ ! -L "${elflink}" ]]; then
        echo "!!! Temporary link '${elflink}' is not a link. Stop processing"
        exit 1
      fi
    fi
    ln -fs ${elffile} ${elflink}

    echo "Listen ${SERPORT}"
    killall awk; sleep 1s
    awk '/END OF TEST/ {print; exit}; {print};' < ${SERPORT} > ${outfile} &
    pidawk=$!

    # save timestamp
    echo `date +"%Y%m%d%H%M"` > ${STAMPFILE}
    # send commands to OOCD - skip .bss sections
    echo -e "halt\ninit_board\nload /tmp/test.elf .bss\nrun 0x40000000\nexit\n" | nc localhost 4444
    # wait for END OF TEST
    echo "Wait for END OF TEST on ${SERPORT}"
    wait ${pidawk}
    rm -f ${STAMPFILE}

   ;;


  rungrmon)
    echo -e "\nRun grmon for ${pln[0]} with ${testtype} ${pln[2]}"
    testname=${pln[1]}-${pln[0]}
    arch_flags="-march=${archarr[0]} -mabi=${archarr[1]} -daiteq-fpu-type=${pln[2]}"
    archid=$(touch /tmp/dummy.c; clang -print-sf-uid ${arch_flags} -c /tmp/dummy.c -o /dev/null 2>/dev/null)
    elfdir=${archid}${dsuf}
    elffile=$(pwd)/${BUILD_DIR}/${elfdir}/${testname}.elf
    longtestname=${testname}-${pln[2]}
    outfile=$(pwd)/${RESULT_DIR}/${longtestname}-output.log
    grmonlog=$(pwd)/${RESULT_DIR}/${longtestname}-grmon.log
    timeoutlog=$(pwd)/${RESULT_DIR}/${longtestname}.timeout
    elflink="/tmp/test.elf"
    echo "ELFDIR:  ${elfdir}"
    echo "ELF:     ${elffile}"
    echo "OUTFILE: ${outfile}"
    echo "SerPort: ${SERPORT}"
    if [[ ! -f "${elffile}" ]]; then
      echo "!!! ELF file '${elffile}' does not exist. Skip"
      continue
    fi

    if [[ -f "${elflink}" ]]; then
      if [[ ! -L "${elflink}" ]]; then
        echo "!!! Temporary link '${elflink}' is not a link. Stop processing"
        exit 1
      fi
    fi
    ln -fs ${elffile} ${elflink}

    stty -F ${SERPORT} 38400
    echo "Listening on ${SERPORT}"
    awk '/END OF TEST/ {print; exit}; {print};' < ${SERPORT} > ${outfile} &
    pidawk=$!
    # save timestamp
    echo `date +"%Y%m%d%H%M"` > ${STAMPFILE}
    echo "Run grmon @"
#     ( sleep ${GRMONTIMEOUT}; if [[ -e ${STAMPFILE} ]]; then echo "GRMON TIMEOUT" >> ${timeoutlog}; killall grmon; fi; ) &
#     killgrmonpid=$!
    grmon -digilent -c ./scripts/grmon_load_run_test.batch | tee ${grmonlog}
#     grmon -leon2 -uart ${GRMON_PORT} -c ./scripts/grmon_load_run_test.batch | tee ${grmonlog}
#     grmon -nopnp -sys leon2 -uart ${GRMON_PORT} -c ./scripts/grmon_load_run_test.batch | tee ${grmonlog}
#     grmon -digilent -c ./scripts/grmon_load_run_test.batch | tee ${grmonlog}
#     grmon -ftdi -c ./scripts/grmon_load_run_test.batch | tee ${grmonlog}
    rm -f ${STAMPFILE}
#     kill -0 ${killgrmonpid}
    # timeout for AWK
#     echo ${pidawk} > ${PIDFILE}
#     ( sleep ${AWKTIMEOUT}; if [[ -e ${PIDFILE} ]]; then echo "AWK TIMEOUT" >> ${timeoutlog}; kill -0 ${pidawk} ; fi ; ) &
#     killerpid=$!
#     echo "Wait for END OF TEST on ${SERPORT}"
#     wait ${pidawk}
    killall awk; sleep 1s
#     rm -f ${PIDFILE}
#     kill -0 ${killerpid}

   ;;

  check)
   ;;

  clean)
   ;;

  test)
   eval "echo TEST : '${ln}' '${line}'"
   eval "echo      : '${pln[0]}' ${pln[1]} ${pln[2]} ${ucflags}"
   ;;

  *)
   echo "Unsupported operation."
   ;;
 esac
done < "$FILE"