root/guts_io/guts_io.sh

#!/bin/sh

# GWU-HPCL Unified Testing Suite for UPC/IO implementation
# Script by Abdullah Kayi

if test -z "$1"; then
        echo "Usage: ./guts.sh [number of threads] "
        exit
fi

#go to the src directory
cd src

# Initial cleanup
if test -f units.passed; then
        rm -f units.passed
fi

if test -f units.notpassed; then
        rm -f units.notpassed
fi

printf "\n\n"
printf "_______________      Script for compiling and running GUTS      _______________\n\n"

umask 0002
NP=$1
UNITS=units
UNITS_SHARED=units_shared
echo "Running the testing suite for ${NP} threads"
printf "\n"
passed=0
failed=0
cmp_failed=0

UPCC=upcc

for UNIT in `cat ${UNITS}`; do
        printf ">-------------->      Working on unit $UNIT\n"
        
        BUILD=`upcio-config -build`
        build_output=`$UPCC -D__restrict="" -I../include $BUILD $UNIT.upc -o $UNIT >>$UNIT.out 2>$UNIT.errout`

        if test $? -eq 0; then
                echo $build_output      
                echo "Compilation was SUCCESSFUL for the unit [${UNIT}]"
                echo "Now the unit [${UNIT}] will be run for ${NP} threads ..."
                RUN=`eval echo "upcrun -qn ${NP} ${UNIT}"`
                echo $RUN
                exe_output=`$RUN` 
                if test $? -eq 0; then
                        printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$UNIT]"
                        echo $exe_output
                        echo "$UNIT" >>units.passed
                        passed=`expr $passed + 1`
                else
                        printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$UNIT]"
                        echo $exe_output
                        echo "$UNIT" >>units.notpassed
                        failed=`expr $failed + 1`
                fi
                
        else
                echo "COMPILER ERROR: The unit [$UNIT] cannot be compiled"
                echo "The unit will not be run!!!"
                cat $UNIT.errout
                echo "$UNIT" >>units.notpassed
                failed=`expr $failed + 1`
                cmp_failed=`expr $cmp_failed + 1`
        fi      
        
        `rm -f *.o ${UNIT} ${UNIT}.*out`
        
        printf "\n"
        printf "===============================================================================\n\n"
done 

# necessary files to run the units

FILE=read.test
FILE_INT=read_int.test
touch write_test.txt

# check whether the MEMVEC size is enabled or not

upcio-config -build | grep "DMEMVEC"
e_memvec=$?

# compile and run the UNITS including shared functionality

for SUNIT in `cat ${UNITS_SHARED}`; do
        printf ">-------------->      Working on unit -- $SUNIT\n"

        SBUILD=`upcio-config -build`

        `$UPCC -D__restrict="" -DMEMVEC_SIZE=1 -DTYPE=char -DBLOCKSIZE=0 -I../include \
                                $SBUILD $SUNIT.upc -o $SUNIT.char0 >>$SUNIT.char0.out 2>>$SUNIT.errout`
        
        `$UPCC -D__restrict="" -DMEMVEC_SIZE=1 -DTYPE=char -DBLOCKSIZE=1 -I../include \
                                $SBUILD $SUNIT.upc -o $SUNIT.char1  >>$SUNIT.char1.out 2>>$SUNIT.errout`

        `$UPCC -D__restrict="" -DMEMVEC_SIZE=1 -DTYPE=char -DBLOCKSIZE=4 -I../include \
                                $SBUILD $SUNIT.upc -o $SUNIT.char4 >>$SUNIT.char4.out 2>>$SUNIT.errout`
        if test $e_memvec -eq 0; then

                `$UPCC -D__restrict="" -DMEMVEC_SIZE=1 -DTYPE=int -DBLOCKSIZE=0 -I../include \
                                        $SBUILD $SUNIT.upc -o $SUNIT.int0 >>$SUNIT.int0.out 2>>$SUNIT.errout`

                `$UPCC -D__restrict="" -DMEMVEC_SIZE=1 -DTYPE=int -DBLOCKSIZE=1 -I../include \
                                        $SBUILD $SUNIT.upc -o $SUNIT.int1 >>$SUNIT.int1.out 2>>$SUNIT.errout`

                `$UPCC -D__restrict="" -DMEMVEC_SIZE=1 -DTYPE=int -DBLOCKSIZE=4 -I../include \
                                        $SBUILD $SUNIT.upc -o $SUNIT.int4 >>$SUNIT.int4.out 2>>$SUNIT.errout`
        fi

        if test $? -eq 0; then
                echo "Compilation was SUCCESSFUL for the unit [${SUNIT}]"
                
                echo "Now the unit [${SUNIT}] will be run for ${NP} threads by executing 6 sub-units ..."
                RUN_char0=`eval echo "upcrun -qn ${NP} ${SUNIT}.char0 ${FILE}"`
                echo ${RUN_char0}
                exe_output=`${RUN_char0}`
                if test $? -eq 0 ; then
                        printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$SUNIT.char0]\n"
                        echo $exe_output
                        echo "${SUNIT}.char0" >>units.passed
                        passed=`expr $passed + 1`
                else
                        printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$SUNIT.char0]\n"
                        echo $exe_output
                        echo "${SUNIT}.char0" >>units.notpassed
                        failed=`expr $failed + 1`
                fi

                RUN_char1=`eval echo "upcrun -qn ${NP} ${SUNIT}.char1 ${FILE}"`
                echo ${RUN_char1}
                exe_output=`${RUN_char1}`
                if test $? -eq 0; then
                        printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$SUNIT.char1]\n"
                        echo $exe_output
                        echo "${SUNIT}.char1" >>units.passed
                        passed=`expr $passed + 1`
                else
                        printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$SUNIT.char1]\n"
                        echo $exe_output
                        echo "${SUNIT}.char1" >>units.notpassed
                        failed=`expr $failed + 1`
                fi
                
                RUN_char4=`eval echo "upcrun -qn ${NP} ${SUNIT}.char4 ${FILE}"`
                echo ${RUN_char4}
                exe_output=`${RUN_char4}`
                if test $? -eq 0; then
                        printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$SUNIT.char4]\n"
                        echo $exe_output
                        echo "${SUNIT}.char4" >>units.passed
                        passed=$((passed+1))
                else
                        printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$SUNIT.char4]\n"
                        echo $exe_output
                        echo "${SUNIT}.char4" >>units.notpassed
                        failed=`expr $failed + 1`
                fi

                if test $e_memvec -eq  0; then
                        RUN_int0=`eval echo "upcrun -qn ${NP} ${SUNIT}.int0 ${FILE_INT}"`
                        echo ${RUN_int0}
                        exe_output=`${RUN_int0}`
                        if test $? -eq 0; then
                                printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$SUNIT.int0]\n"
                                echo $exe_output
                                echo "${SUNIT}.int0" >>units.passed
                                passed=`expr $passed + 1`
                        else
                                printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$SUNIT.int0]\n"
                                echo $exe_output
                                echo "${SUNIT}.int0" >>units.notpassed
                                failed=`expr $failed + 1`
                        fi

                        RUN_int1=`eval echo "upcrun -qn ${NP} ${SUNIT}.int1 ${FILE_INT}"`
                        echo ${RUN_int1}
                        exe_output=`${RUN_int1}`
                        if test $? -eq 0; then
                                printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$SUNIT.int1]\n"
                                echo $exe_output
                                echo "${SUNIT}.int1" >>units.passed
                                passed=`expr $passed + 1`
                        else
                                printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$SUNIT.int1]\n"
                                echo $exe_output
                                echo "${SUNIT}.int1" >>units.notpassed
                                failed=`expr $failed+1`
                        fi

                        RUN_int4=`eval echo "upcrun -qn ${NP} ${SUNIT}.int4 ${FILE_INT}"`
                        echo ${RUN_int4}
                        exe_output=`${RUN_int4}`
                        if test $? -eq 0; then
                                printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$SUNIT.int4]\n"
                                echo $exe_output
                                echo "${SUNIT}.int4" >>units.passed
                                passed=`expr $passed + 1`
                        else
                                printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$SUNIT.int4]\n"
                                echo $exe_output
                                echo "${SUNIT}.int4" >>units.notpassed
                                failed=`expr $failed + 1`
                        fi
                fi

        else
                echo "COMPILER ERROR: The unit [$SUNIT] cannot be compiled"
                echo "The unit will not be run!!!"
                cat $SUNIT.errout
                echo "$SUNIT" >>units.notpassed
                failed=`expr $failed + 1`
                cmp_failed=`expr $cmp_failed + 1`
        fi

        rm -f *.o ${SUNIT}.char[0,1,4] ${SUNIT}.int[0,1,4] ${SUNIT}.*out
        
        printf "\n"
        printf "===============================================================================\n"
        
done

rm -f *.test *.txt

# STATISTICAL OUTPUT

printf "________________       GWU-HPCL UPC/IO Testing Summary         ________________\n"
echo "SUCCESSFUL UNITS --> (units.passed)"
printf "\033[34m\033[1m"
if test -f units.passed; then
        cat units.passed|sort|uniq
fi
printf "\033[0m"

echo "    FAILED UNITS --> (units.notpassed)"
printf "\033[31m\033[1m"
if test -f units.notpassed; then
        cat units.notpassed|sort|uniq
fi
printf "\033[0m"

printf "\033[1m\033[1m\033[35m"
echo "                 -->      Number of units PASSED : $passed"
echo "                 -->      Number of units FAILED : $failed"
total=`expr $passed + $failed`
percentage=`expr $passed * 100 / $total`

printf "                 -->    $percentage % of the units have PASSED\n"
printf "\033[0m"
printf "===========================     TEST END    ====================================\n"