#!/bin/sh -f
#################################################################
#
#  Script to make tabular files.  Make up for lack of prefix
#  rules in smake.
#
#################################################################

#
#  either att, cov, ew, tex, ms
#
TYPE="" 

#
#  Three digit test number
#
TNUM=""


#
#  Simulator, c, cv, io, gate
#
SIM="cv"


#
#  Use archived source files (.rdp, .mem, .rdram) from apps directory
#  This isolates us from rabid changes in the emulator
#
USE_ARCHIVE=""

#
#  Use bb source files (captured from real hardware(indy))
#    
USE_BB_FILES=""
SYSTEM_4MB=""

#
#  Hardcode the random seed used by the simulator so that images will
#  compare from run to run.
#
USE_SEED="100"

#
# The gate level simulation is currently a hand tweaked executable maintained
# by Ken Hayes; coming soon to an account on a server near you...
#
# When we do change the location, we'll reflect that here.  SIMVGATEDIR gets
# used by the gatesim() internal script function, and overwrites SIMVDIR as set
# in the incoming shell environment (which is used by the iosim() internal 
# script function).
#
SIMVGATEDIR="/hosts/baraka/e/kishor/simv_ipc_gate"

#
#  Directories
#
PRDEPTH="../../.."

init_test()
{
    if [ "$USE_BB_FILES" = "" ]
    then
        ATTDIR="${PRDEPTH}/apps/rdpatt/InData"
        COVDIR="${PRDEPTH}/apps/rdpcov/InData"
        EWDIR="${PRDEPTH}/apps/rdpew/InData"
        TEXDIR="${PRDEPTH}/apps/rdptex/InData"
        MSDIR="${PRDEPTH}/apps/rdpms/InData"
    else
        ATTDIR="${PRDEPTH}/apps/rdpatt_bb/InData"
        COVDIR="${PRDEPTH}/apps/rdpcov_bb/InData"
        EWDIR="${PRDEPTH}/apps/rdpew_bb/InData"
        TEXDIR="${PRDEPTH}/apps/rdptex_bb/InData"
        MSDIR="${PRDEPTH}/apps/rdpms_bb/InData"
    fi

    if [ "$SYSTEM_4MB" = "" ]; then
        IO_TEST=${ROOT}/PR/iosim/test/bcp_rdp2MB.tst
    else
        IO_TEST=${ROOT}/PR/iosim/test/bcp_rdp4MB.tst
    fi
}

INDATA="InData"
OUTDATA="OutData"

#
#  Tools
#
RDP_CV="./rdp_cv $RDP_OPTS"
RDP_C="./rdp_c $RDP_OPTS"
RDP_IO="${ROOT}/PR/iosim/src/iosim"
FILTER=${ROOT}/PR/rdpsim/backend/filter
IO_TEST=${ROOT}/PR/iosim/test/rdp_3stall.tst
RDRAM2RDP=rdram2rdp
RDRAMGCLR=rdramgclr
RDRAMG=rdramg
RDRAM2IMG=rdram2image
export SIMVDIR=${ROOT}/PR/hw2/chip/vsim

#  
#  Set environment
#
LD_LIBRARY_PATH="/ecad/vcs/vcs_2.2/sgi/lib:${PRDEPTH}/lib/libimage:${PRDEPTH}/iosim/src/iosim"

export LD_LIBRARY_PATH

TIMELIMIT=180000


##################################################
#
#  Usage message
#
##################################################
usage()
{
  echo "Usage: testit [-a][-b][-m] <-n> test_number <-t> type <-s> simulator"
  echo "	-b : Use bb files(captured from indy)"
  echo "	-m : Configure as 4 MBytes system" 
  exit 2
}


##################################################
#
#  Run the C/Verilog simulation (rdp_cv)
#
##################################################
cvsim()
{
  echo CV sim test ${TNUM} start `date` 
  #set -x

  #  Generate input file names
  if [ ${TNUM} -ge 100 ] ; then
      NUM=`expr ${TNUM} - 100`
  else
      NUM=`expr ${TNUM} + 0`
  fi
  if [ "$USE_BB_FILES" = "TRUE" ]; then
      IN_BASE=test${TNUM}.${TYPE}_bb
  else
      IN_BASE=test${TNUM}.${TYPE}
  fi

  if test "$USE_ARCHIVE" = "TRUE"; then
    RDP_SRC=${APPDIR}/test${TNUM}.${NUM}.rdp.Z.archive
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.mem.Z.archive
  else
    RDP_SRC=${APPDIR}/test${TNUM}.${NUM}.rdp.Z
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.mem.Z
  fi

  RDP_FILE=${INDATA}/${IN_BASE}.rdp
  MEM_FILE=${INDATA}/${IN_BASE}_cv.mem

  #  Generate output file names
  if [ "$USE_BB_FILES" = "TRUE" ]
  then
    OUT_BASE=test${TNUM}_${TYPE}_bb_cv
  else
    OUT_BASE=test${TNUM}_${TYPE}_cv
  fi
  OUT_LOG=${OUTDATA}/${OUT_BASE}.out
  COV_FILE=${OUTDATA}/${OUT_BASE}_0.cov
  CVG_FILE=${OUTDATA}/${OUT_BASE}_0.cvg
  RGB_FILE=${OUTDATA}/${OUT_BASE}_0.rgb
  RGBF_FILE=${OUTDATA}/test${TNUM}_${TYPE}_cvf_0.rgb

  #  Copy and uncompress rdp and mem file from apps directory
  if test -r $MEM_SRC; then
      cat ${MEM_SRC} | uncompress -c > ${MEM_FILE} 
      if test $? -ne 0; then
          echo ".mem file ERROR"
          exit 1
      fi
  else
     echo "Error: $MEM_SRC does not exist or is not readable"
     exit 1
  fi


  if test -r $RDP_SRC; then
      cat ${RDP_SRC} | uncompress -c > ${RDP_FILE}
      if test $? -ne 0; then
          echo ".rdp file ERROR"
          exit 1
      fi
  else
     echo "Error: $RDP_SRC does not exist or is not readable"
     exit 1
  fi

  #  Run simulation
  ${RDP_CV} -e -i ${IN_BASE} -m ${IN_BASE}_cv \
	+tmem=allones.mem \
	-M 500 -S ${USE_SEED} \
	-f ${OUT_BASE} -z | tee ${OUT_LOG}

  if test $? -ne 0 ; then
    echo "RDP_CV FAILED"
    exit 1
  fi

  #  Create output files for comparison
  ${FILTER} -c ${COV_FILE} -i ${CVG_FILE} \
	-n ${RGB_FILE} -o ${RGBF_FILE}

  # cleanup
  rm -f ${MEM_FILE}

  echo CV sim test ${TNUM} finish `date` 
}


##################################################
#
#  Run the C simulation (rdp_c)
#
##################################################
csim()
{
  echo "C sim test ${TNUM} start `date`"
  set -x

  #  Generate input file names
  if [ ${TNUM} -ge 100 ] ; then
      NUM=`expr ${TNUM} - 100`
  else
      NUM=`expr ${TNUM} + 0`
  fi

  if [ "$USE_BB_FILES" = "TRUE" ]; then
      IN_BASE=test${TNUM}.${TYPE}_bb
  else
      IN_BASE=test${TNUM}.${TYPE}
  fi

  IN_BASE=test${TNUM}.${TYPE}
  if test "$USE_ARCHIVE" = "TRUE"; then
    RDP_SRC=${APPDIR}/test${TNUM}.${NUM}.rdp.Z.archive
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.mem.Z.archive
  else
    RDP_SRC=${APPDIR}/test${TNUM}.${NUM}.rdp.Z
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.mem.Z
  fi
  RDP_FILE=${INDATA}/${IN_BASE}.rdp
  MEM_FILE=${INDATA}/${IN_BASE}_c.mem

  #  Generate output file names
  if [ "$USE_BB_FILES" = "TRUE" ] 
  then 
     OUT_BASE=test${TNUM}_${TYPE}_bb_c
  else
     OUT_BASE=test${TNUM}_${TYPE}_c
  fi 
  OUT_LOG=${OUTDATA}/${OUT_BASE}.out
  COV_FILE=${OUTDATA}/${OUT_BASE}_0.cov
  CVG_FILE=${OUTDATA}/${OUT_BASE}_0.cvg
  RGB_FILE=${OUTDATA}/${OUT_BASE}_0.rgb
  RGBF_FILE=${OUTDATA}/test${TNUM}_${TYPE}_cf_0.rgb

  #  Copy and uncompress rdp and mem file from apps directory
  if test -r $MEM_SRC; then
      cat ${MEM_SRC} | uncompress -c > ${MEM_FILE} 
      if test $? -ne 0; then
          echo ".mem file ERROR"
          exit 1
      fi
  else
     echo "Error: $MEM_SRC does not exist or is not readable"
     exit 1
  fi


  if test -r $RDP_SRC; then
      cat ${RDP_SRC} | uncompress -c > ${RDP_FILE}
      if test $? -ne 0; then
          echo ".rdp file ERROR"
          exit 1
      fi
  else
     echo "Error: $RDP_SRC does not exist or is not readable"
     exit 1
  fi


  #  Run simulation
  ${RDP_C} -e -i ${IN_BASE} -m ${IN_BASE}_c \
	-M 500 -S ${USE_SEED} \
	-f ${OUT_BASE} -z | tee ${OUT_LOG}

  if test $? -ne 0 ; then
    echo "RDP_C FAILED"
    exit 1
  fi

  #  Create output files for comparison
  ${FILTER} -c ${COV_FILE} -i ${CVG_FILE} \
	-n ${RGB_FILE} -o ${RGBF_FILE}

  # cleanup
  rm -f ${MEM_FILE}

  echo "C sim test ${TNUM} finish `date`"
}


##################################################
#
#  Run the io simulation (simv.ipc or simv2.ipc)
#
##################################################
iosim()
{
  echo "IO sim test ${TNUM} start `date`"
  echo "DP test ${TYPE} ${TNUM}" >> /tmp/bb_perf
  
  set -x

  #  Generate input file names
  if [ ${TNUM} -ge 100 ] ; then
      NUM=`expr ${TNUM} - 100`
  else
      NUM=`expr ${TNUM} + 0`
  fi
  SRC_BASE=test${TNUM}.${TYPE}
  
  if [ "$USE_BB_FILES" = "TRUE" ]; then
      IN_BASE=test${TNUM}_${TYPE}_bb
  else
      IN_BASE=test${TNUM}_${TYPE}
  fi

  if test "$USE_ARCHIVE" = "TRUE"; then
#    RDP_SRC=${APPDIR}/test${TNUM}.${NUM}.rdp.Z.archive
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.rdram.Z.archive
  else
#    RDP_SRC=${APPDIR}/test${TNUM}.${NUM}.rdp.Z
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.rdram.Z
  fi

#  RDP_FILE=${INDATA}/${SRC_BASE}.rdp
  MEM_FILE=${INDATA}/${IN_BASE}_io.rdram

  #  Generate output file names
  if [ "$USE_BB_FILES" = "TRUE" ]
  then
    OUT_BASE=test${TNUM}_${TYPE}_bb_io
  else
    OUT_BASE=test${TNUM}_${TYPE}_io
  fi 
  OUT_LOG=${OUTDATA}/${OUT_BASE}.log
  OUT_LOGF=${OUTDATA}/${OUT_BASE}f.log
  COV_FILE=${OUTDATA}/${OUT_BASE}_0.cov
  CVG_FILE=${OUTDATA}/${OUT_BASE}_0.cvg
  RGB_FILE=${OUTDATA}/${OUT_BASE}_0.rgb
  RGBF_FILE=${OUTDATA}/test${TNUM}_${TYPE}_iof_0.rgb

  #  Copy and uncompress rdp and mem file from apps directory
  if test -r $MEM_SRC; then
      cat ${MEM_SRC} | uncompress -c > ${MEM_FILE} 
      if test $? -ne 0; then
          echo ".mem file ERROR"
          exit 1
      fi
  else
     echo "Error: $MEM_SRC does not exist or is not readable"
     exit 1
  fi


#  if test -r $RDP_SRC; then
#      cat ${RDP_SRC} | uncompress -c > ${RDP_FILE}
#      if test $? -ne 0; then
#          echo ".rdp file ERROR"
#          exit 1
#      fi
#  else
#     echo "Error: $RDP_SRC does not exist or is not readable"
#     exit 1
#  fi
  
  # GET hw image first for BB data
  if [ "$USE_BB_FILES" = "TRUE" ]; then
     cp ${INDATA}/${IN_BASE}_io.rdram ${INDATA}/test${TNUM}_${TYPE}_hw.rdram
     ${RDRAMG} ${INDATA}/test${TNUM}_${TYPE}_hw
     ${RDRAM2IMG} ${INDATA}/test${TNUM}_${TYPE}_hw
 
     ${FILTER} -c ${OUTDATA}/test${TNUM}_${TYPE}_hw_0.cov \
			   -i ${OUTDATA}/test${TNUM}_${TYPE}_hw_0.cvg \
               -n ${OUTDATA}/test${TNUM}_${TYPE}_hw_0.rgb \
		       -o ${OUTDATA}/test${TNUM}_${TYPE}_hwf_0.rgb

	 #### Golden cov will be come from rcp iosim result
	 cp ${OUTDATA}/test${TNUM}_${TYPE}_rcp.cov ${OUTDATA}/test${TNUM}_${TYPE}_hw_0.cov
	 cp ${OUTDATA}/test${TNUM}_${TYPE}_rcp.z ${OUTDATA}/test${TNUM}_${TYPE}_hw_0.z

     #exit
     rm -f ${INDATA}/test${TNUM}_${TYPE}_hw.rdram
  fi

  if [ "$SYSTEM_4MB" = "" ]; then
      ${RDRAMGCLR} ${INDATA}/${IN_BASE}_io
  else
      ${RDRAMGCLR} -m 2 ${INDATA}/${IN_BASE}_io
  fi

  #
  # Check to see if the user wants to generate images from 1st tapeout sim.
  #
  if test -z "${USE_HW_ROOT}" ; then
      SIMV_EXE=${SIMVDIR}/sim.ipc
  else
      SIMV_EXE=${SIMVDIR}/sim.ipc
  fi

  #  Run simulation
  cp ${INDATA}/${IN_BASE}_io.rdram tmp.iosim.rdram
  SIMV="${SIMV_EXE} \
  		+timelimit=${TIMELIMIT} \
  		+gclock_mon=150 +cbus_mon +ri_mon $BBOPTS $RDP_OPTS"
  #export SIMV

  ${RDP_IO} 			\
	-n test${TNUM}_${TYPE} 	\
	-d 0x41 		\
	-f ${IO_TEST} 		\
	-l ${OUT_LOG} 		\
	    >  ${OUT_LOGF}

  if test $? -ne 0 ; then
    echo "IOSIM FAILED"
    exit 1
  fi

  cp tmp.iosim.rdram ${INDATA}/${IN_BASE}_io.rdram
  ${RDRAM2IMG} ${INDATA}/${IN_BASE}_io

  #  Create output files for comparison
  ${FILTER} -c ${COV_FILE} -i ${CVG_FILE} \
	-n ${RGB_FILE} -o ${RGBF_FILE}

  # cleanup
  rm -f ${MEM_FILE}

  echo "IO sim test ${TNUM} finish `date`"
}

##################################################
#
#  Run the gate level simulation (simv.ipc.gates or simv2.ipc.gates)
#
##################################################
gatesim()
{
  echo "GATE sim test ${TNUM} start `date`"
  set -x

  #  Generate input file names
  if [ ${TNUM} -ge 100 ] ; then
      NUM=`expr ${TNUM} - 100`
  else
      NUM=`expr ${TNUM} + 0`
  fi
  SRC_BASE=test${TNUM}.${TYPE}
  
  if [ "$USE_BB_FILES" = "TRUE" ]; then
      IN_BASE=test${TNUM}_${TYPE}_bb
  else
      IN_BASE=test${TNUM}_${TYPE}
  fi

  if test "$USE_ARCHIVE" = "TRUE"; then
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.rdram.Z.archive
  else
    MEM_SRC=${APPDIR}/test${TNUM}.${NUM}.rdram.Z
  fi
  MEM_FILE=${INDATA}/${IN_BASE}_gate.rdram

  #  Generate output file names
  if [ "$USE_BB_FILES" = "TRUE" ]
  then
     OUT_BASE=test${TNUM}_${TYPE}_bb_gate
  else
     OUT_BASE=test${TNUM}_${TYPE}_gate
  fi
  OUT_LOG=${OUTDATA}/${OUT_BASE}.log
  OUT_LOGF=${OUTDATA}/${OUT_BASE}f.log
  COV_FILE=${OUTDATA}/${OUT_BASE}_0.cov
  CVG_FILE=${OUTDATA}/${OUT_BASE}_0.cvg
  RGB_FILE=${OUTDATA}/${OUT_BASE}_0.rgb
  RGBF_FILE=${OUTDATA}/test${TNUM}_${TYPE}_gatef_0.rgb

  #  Copy and uncompress rdp and mem file from apps directory
  if test -r $MEM_SRC; then
      cat ${MEM_SRC} | uncompress -c > ${MEM_FILE} 
      if test $? -ne 0; then
          echo ".mem file ERROR"
          exit 1
      fi
  else
     echo "Error: $MEM_SRC does not exist or is not readable"
     exit 1
  fi


  ${RDRAMGCLR} ${INDATA}/${IN_BASE}_gate

  #
  # Check to see if the user wants to generate images from 1st tapeout sim.
  #
  if test -z "${USE_HW_ROOT}"; then
      SIMV_EXE=${SIMVGATEDIR}/simv2.ipc.gates
  else
      SIMV_EXE=${SIMVGATEDIR}/simv.ipc.gates
  fi

  SIMV="${SIMV_EXE} +mmap_rdram=${INDATA}/${IN_BASE}_gate $RDP_OPTS"
  export SIMV

  ${RDP_IO} 			\
	-n test${TNUM}_${TYPE} 	\
	-d 0x41 		\
	-f ${IO_TEST} 		\
	-l ${OUT_LOG} 		\
	    >  ${OUT_LOGF}

  if test $? -ne 0 ; then
    echo "IOSIM FAILED"
    exit 1
  fi

  ${RDRAM2IMG} ${INDATA}/${IN_BASE}_gate

  #  Create output files for comparison
  ${FILTER} -c ${COV_FILE} -i ${CVG_FILE} \
	-n ${RGB_FILE} -o ${RGBF_FILE}

  # cleanup
  rm -f ${MEM_FILE}

  echo "GATE sim test ${TNUM} finish `date`"
}


##################################################
#  Main
#
##################################################
  date
  if test $# = 0 
  then
    usage
  fi
  
  while getopts "n:t:s:m?b?a?" a
  do
    case $a in
    	a)  USE_ARCHIVE=TRUE;;
	b)  USE_BB_FILES=TRUE;;
	m)  SYSTEM_4MB=TRUE;;
    	n)  TNUM=$OPTARG;;
    	t)  TYPE=$OPTARG;;
    	s)  SIM=$OPTARG;;
    	\?) usage ;;
    esac
  done
  shift `expr $OPTIND - 1`
  init_test
  #  Determine app directory
  case ${TYPE} in
	"att") APPDIR=$ATTDIR;;
	"tex") APPDIR=$TEXDIR;;
	"cov") APPDIR=$COVDIR;;
	"ew")  APPDIR=$EWDIR;;
	"ms")  APPDIR=$MSDIR;;
	*)     echo "Unrecognized type: ${TYPE}"
	       exit 1;;
  esac
  # run simulation
  case $SIM in
  	c)  csim;;
  	cv) cvsim;;
  	io) iosim;;
  	gate) gatesim;;
	*)  echo "Unrecognized simulator: ${SIM}"
  esac

  date
  echo "########################################################"
# End testit