root/guts_main/guts_main.sh

#!/bin/sh

# GWU-HPCL Unified Testing Suite
# UPC Compilers compliance check with the latest UPC spec v1.2
# 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-UPC      _______________\n"

umask 0002
NP=$1
UNITS=units
RNUNITS=units_runtime_neg
UNITS_NEG=units_neg

echo "Running the testing suite for ${NP} threads"
printf "\n"
passed=0
failed=0
cmp_failed=0

# specify second argument as ON to turn on the coloring in the output
COLOR=$2

# flags for Berkeley UPC Compiler
# NOTE: interface to automatically set these variables for various UPC Compilers
# will be added as we get access and test those UPC Compilers
UPCC=upcc
UPC_FLAGS="-T=${NP}"

# for gcc-upc use the following flags instead
#UPCC=upc
#UPC_FLAGS="-fupc-threads-${NP}"

for UNIT in `cat ${UNITS}`; do
        printf ">-------------->      Working on unit -- $UNIT\n"
        
        build_output=`$UPCC $UPC_FLAGS -I../include $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 ..."
                #runtime settings for berkeley UPC 
                RUN=`eval echo "upcrun -qn ${NP} ${UNIT}"`
                #use the following runtime settings for gcc-upc
                #RUN=`eval echo "./${UNIT}"`
                echo $RUN
                exe_output=`$RUN` 
                
        if test $? -eq 0 ; then
                        if [ "$COLOR" == "ON" ]; then
                                printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$UNIT]"
                        else
                                printf "TEST PASSED for the unit [$UNIT]"
                        fi
                        echo $exe_output
                        echo "$UNIT" >>units.passed
                        passed=`expr $passed + 1`
                else
                        if [ "$COLOR" == "ON" ]; then
                                printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$UNIT]"
                        else
                                printf "TEST FAILED for the unit [$UNIT]"
                        fi
                        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=$((failed+1))
                cmp_failed=$((cmp_failed+1))
        fi      
        
        `rm -f *.o ${UNIT} ${UNIT}.*out`
        
        printf "\n"
        printf "===============================================================================\n\n"
done

# compile the negative UNITS
# these UNITS should raise compiler ERRORS 

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

        build_output=`$UPCC $UPC_FLAGS -I../include $NUNIT.upc -o $NUNIT`

         if test $? -eq 0 ; then
        echo $build_output 
                echo "ERROR: The NEGATIVE unit [$NUNIT] pass the compilation phase"
        echo "The unit will not be run!!!"
                if [ "$COLOR" == "ON" ]; then
                        printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$NUNIT]"
                else
                        printf "TEST FAILED for the unit [$NUNIT]"
        fi
                echo "$NUNIT" >>units.notpassed
        failed=`expr $failed + 1`
        cmp_failed=`expr $cmp_failed + 1`
     
     else
                echo "Compilation was UNSUCCESSFUL for the negative unit [${NUNIT}]"
                echo "Note that this is the EXPECTED result since the unit is negative"
                echo "The unit will not be run!!!"
                if [ "$COLOR" == "ON" ]; then
                        printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$NUNIT]"
                else
                        printf "TEST PASSED for the unit [$NUNIT]"
                fi
                echo "$NUNIT" >>units.passed     
                passed=`expr $passed + 1`
        fi

    `rm -f *.o ${NUNIT} ${NUNIT}.*out`
        
        printf "\n\n"
        printf "===============================================================================\n\n"
        
done

# following loop will work for negative units which expect to raise ERROR at runtime

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

    build_output=`$UPCC $UPC_FLAGS -I../include $RNUNIT.upc -o $RNUNIT >>$RNUNIT.out 2>$RNUNIT.errout`

    if test $? -eq 0 ; then
        echo $build_output
        echo "Compilation was SUCCESSFUL for the unit [${RNUNIT}]"
        echo "Now the unit [${RNUNIT}] will be run for ${NP} threads ..."
        echo "Note that this is a negative unit which MUST raise a RUNTIME ERROR"
        #runtime settings for berkeley UPC 
        RUN=`eval echo "upcrun -qn ${NP} ${RNUNIT}"`
        #use the following runtime settings for gcc-upc
        #RUN=`eval echo "./${RNUNIT}"`
        echo $RUN
        exe_output=`$RUN`
        
        if test $? -eq 0 ; then
            if [ "$COLOR" == "ON" ]; then
                printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$RNUNIT]"
            else
                printf "TEST FAILED for the unit [$RNUNIT]"
            fi
            echo "$RNUNIT" >>units.notpassed
            failed=`expr $failed + 1`
        else
            if [ "$COLOR" == "ON" ]; then
                printf "TEST \033[34m\033[1mPASSED\033[0m for the unit [$UNIT]"
            else
                printf "TEST PASSED for the unit [$UNIT]"
            fi
            echo "$UNIT" >>units.passed
            passed=`expr $passed + 1`
        fi

    else
        echo "COMPILER ERROR: The unit [$RNUNIT] cannot be compiled"
        echo "The unit will not be run!!!"
        
        if [ "$COLOR" == "ON" ]; then
            printf "TEST \033[31m\033[1mFAILED\033[0m for the unit [$RNUNIT]"
        else
            printf "TEST FAILED for the unit [$RNUNIT]"
        fi
        
        cat $RNUNIT.errout
        echo "$RNUNIT" >>units.notpassed
        failed=`expr $failed + 1`
        cmp_failed=`expr $cmp_failed + 1`
    fi

    `rm -f *.o ${RNUNIT} ${RNUNIT}.*out`

    printf "\n\n"
    printf "===============================================================================\n"
done


# STATISTICAL OUTPUT

printf "________________       GWU-HPCL UPC Compiler Testing Summary         ________________\n"
echo "SUCCESSFUL UNITS --> (units.passed)"

if [ "$COLOR" == "ON" ]; then
        printf "\033[34m\033[1m"
fi

if test -f units.passed ; then
        cat units.passed|sort|uniq
fi

if [ "$COLOR" == "ON" ]; then
        printf "\033[0m"
fi

echo "    FAILED UNITS --> (units.notpassed)"

if [ "$COLOR" == "ON" ]; then
        printf "\033[31m\033[1m"
fi

if test -f units.notpassed ; then
        cat units.notpassed|sort|uniq
fi

if [ "$COLOR" == "ON" ]; then
        printf "\033[0m"
        printf "\033[1m\033[1m\033[35m"
fi

echo "                  >-->    Number of units PASSED : $passed"
echo "                  >-->    Number of units FAILED : $failed"
total=`expr $passed + $failed`
percentage=$(((passed*100) / total))

echo "                  >-->    $percentage % of the units have PASSED"
printf "\n"

if [ "$COLOR" == "ON" ]; then
        printf "\033[0m"
fi

printf "===========================     TEST END    ====================================\n"