#!/bin/sh
# kernbench by Con Kolivas <kernbench@kolivas.org>
# based on a benchmark by Martin J. Bligh
trap 'echo "ABORTING";exit' 1 2 15

VERSION=0.20

num_runs=5
single_runs=0
half_runs=1
opti_runs=1
max_runs=1

while getopts vsHOMn:o:h i
do
	case $i in
		 h) 	echo "kernbench v$VERSION by Con Kolivas <kernbench@kolivas.org>"
				echo "Usage:"
				echo "kernbench [-n runs] [-o jobs] [-s] [-H] [-O] [-M] [-h] [-v]"
				echo "n : number of times to perform benchmark (default 5)"
				echo "o : number of jobs for optimum run (default 4 * cpu)"
				echo "s : perform single threaded runs (default don't)"
				echo "H : don't perform half load runs (default do)"
				echo "O : don't perform optimal load runs (default do)"
				echo "M : don't perform maximal load runs (default do)"
				echo "h : print this help"
				echo "v : print version number"
				exit ;;
		 v) echo "kernbench Version $VERSION by Con Kolivas <kernbench@kolivas.org>" ; exit ;;
		 n) num_runs=$OPTARG ;;
		 o) optijobs=$OPTARG ;;
		 s) single_runs=1 ;;
		 H) half_runs=0 ;;
		 O) opti_runs=0 ;;
		 M) max_runs=0 ;;
	esac
done

if [[ ! -f include/linux/kernel.h ]] ; then
	echo "No kernel source found; exiting"
	exit 
fi

time=`which time`
if [[ ! -a $time ]] ; then
	echo "time not found in path, please install it; exiting"
	exit
fi

if (($num_runs < 1)) ; then
	echo "Nothing to do; exiting"
	exit
fi

if (($num_runs > 10)) ; then
	echo "Trimming number of runs to 10"
	num_runs=10
fi

if [[ ! -d /proc ]] ; then
	echo "Can't find proc filesystem; exiting"
	exit
fi

awk=`which awk`
if [[ ! -a $awk ]] ; then
        echo "awk not found in path, please install it; exiting"
        exit
fi

mem=`awk '/MemTotal/ {print $2}' /proc/meminfo`
if (($mem < 2000000)) ; then
	echo Less than 2Gb ram! This benchmark will not measure cpu throughput and may cause a swapstorm!
fi

(( single_runs *= $num_runs ))
(( half_runs *= $num_runs ))
(( opti_runs *= $num_runs ))
(( max_runs *= $num_runs ))

cpus=`grep -c processor /proc/cpuinfo`
echo $cpus cpus found
echo Cleaning source tree...
make clean > /dev/null 2>&1
make mrproper > /dev/null 2>&1
echo Making defconfig...
make defconfig > /dev/null 2>&1
echo Making dep if needed...
make dep > /dev/null 2>&1
echo Caching kernel source in ram...
for i in `find -type f`
do
	cat $i > /dev/null
done

halfjobs=$(( $cpus / 2 ))
optijobs=${optijobs:=$(( $cpus * 4 ))}

if echo $halfjobs 1 | awk '{exit $1>=$2}' ; then
	echo "Half load is no greater than single; disabling"
	half_runs=0
fi

if [[ ! $single_runs -eq 0 ]] ; then
	echo Warmup single threaded run...
	make > /dev/null 2>&1
fi

temp_runs=$single_runs
single_elapsed="a"
for (( i=1 ; i <= temp_runs ; i++ ))
do
	echo Single threaded run number $i...
	make clean > /dev/null 2>&1
	sleep 5
	$time -f "%e %U %S %P %c %w" -o timelog make > /dev/null 2>&1
	read elapsed_time user_time sys_time percent ctx sleeps <timelog
	single_elapsed=`echo $elapsed_time $num_runs $single_elapsed | awk '{print $1/$2+$3}'`
	single_user=`echo $user_time $num_runs $single_user | awk '{print $1/$2+$3}'`
	single_sys=`echo $sys_time $num_runs $single_sys | awk '{print $1/$2+$3}'`
	single_percent=`echo $percent $num_runs $single_percent | awk '{print $1/$2+$3}'`
	single_ctx=`echo $ctx $num_runs $single_ctx | awk '{print $1/$2+$3}'`
	single_sleeps=`echo $sleeps $num_runs $single_sleeps | awk '{print $1/$2+$3}'`
done

if [[ ! $half_runs -eq 0 ]] ; then
	echo Warmup half load run...
	make -j$halfjobs> /dev/null 2>&1
fi

temp_runs=$half_runs
half_elapsed="a"
for (( i=1 ; i <= temp_runs ; i++ ))
do
	echo Half load -j$halfjobs run number $i...
	make clean > /dev/null 2>&1
	sleep 5
	$time -f "%e %U %S %P %c %w" -o timelog make -j $halfjobs> /dev/null 2>&1
	read elapsed_time user_time sys_time percent ctx sleeps <timelog
	half_elapsed=`echo $elapsed_time $num_runs $half_elapsed | awk '{print $1/$2+$3}'`
	half_user=`echo $user_time $num_runs $half_user | awk '{print $1/$2+$3}'`
	half_sys=`echo $sys_time $num_runs $half_sys | awk '{print $1/$2+$3}'`
	half_percent=`echo $percent $num_runs $half_percent | awk '{print $1/$2+$3}'`
	half_ctx=`echo $ctx $num_runs $half_ctx | awk '{print $1/$2+$3}'`
	half_sleeps=`echo $sleeps $num_runs $half_sleeps | awk '{print $1/$2+$3}'`
done

if [[ ! $opti_runs -eq 0 ]] ; then
	echo Warmup optimum load run...
	make -j$optijobs> /dev/null 2>&1
fi

temp_runs=$opti_runs
opti_elapsed="a"
for (( i=1 ; i <= temp_runs ; i++ ))
do
	echo Optimum load -j$optijobs run number $i...
	make clean > /dev/null 2>&1
	sleep 5
	$time -f "%e %U %S %P %c %w" -o timelog make -j $optijobs > /dev/null 2>&1
	read elapsed_time user_time sys_time percent ctx sleeps <timelog
	opti_elapsed=`echo $elapsed_time $num_runs $opti_elapsed | awk '{print $1/$2+$3}'`
	opti_user=`echo $user_time $num_runs $opti_user | awk '{print $1/$2+$3}'`
	opti_sys=`echo $sys_time $num_runs $opti_sys | awk '{print $1/$2+$3}'`
	opti_percent=`echo $percent $num_runs $opti_percent | awk '{print $1/$2+$3}'`
	opti_ctx=`echo $ctx $num_runs $opti_ctx | awk '{print $1/$2+$3}'`
	opti_sleeps=`echo $sleeps $num_runs $opti_sleeps | awk '{print $1/$2+$3}'`
done

if [[ ! $max_runs -eq 0 ]] ; then
	echo Warmup maximum load run...
	make -j > /dev/null 2>&1
fi

temp_runs=$max_runs
max_elapsed="a"
for (( i=1 ; i <= temp_runs ; i++ ))
do
	echo Maximum load -j run number $i...
	make clean > /dev/null 2>&1
	sleep 5
	$time -f "%e %U %S %P %c %w" -o timelog make -j > /dev/null 2>&1
	read elapsed_time user_time sys_time percent ctx sleeps <timelog
	max_elapsed=`echo $elapsed_time $num_runs $max_elapsed | awk '{print $1/$2+$3}'`
	max_user=`echo $user_time $num_runs $max_user | awk '{print $1/$2+$3}'`
	max_sys=`echo $sys_time $num_runs $max_sys | awk '{print $1/$2+$3}'`
	max_percent=`echo $percent $num_runs $max_percent | awk '{print $1/$2+$3}'`
	max_ctx=`echo $ctx $num_runs $max_ctx | awk '{print $1/$2+$3}'`
	max_sleeps=`echo $sleeps $num_runs $max_sleeps | awk '{print $1/$2+$3}'`
done

echo

if [[ -n $single_user ]] ; then
 	echo Average Single Threaded Run:
	echo Elapsed Time $single_elapsed
	echo User Time $single_user
	echo System Time $single_sys
	echo Percent CPU $single_percent
	echo Context Switches $single_ctx
	echo Sleeps $single_sleeps
	echo 
fi

if [[ -n $half_user ]] ; then
	echo Average Half Load Run:
	echo Elapsed Time $half_elapsed
	echo User Time $half_user
	echo System Time $half_sys
	echo Percent CPU $half_percent
	echo Context Switches $half_ctx
	echo Sleeps $half_sleeps
	echo
fi

if [[ -n $opti_user ]] ; then
	echo Average Optimum Load Run:
	echo Elapsed Time $opti_elapsed
	echo User Time $opti_user
	echo System Time $opti_sys
	echo Percent CPU $opti_percent
	echo Context Switches $opti_ctx
	echo Sleeps $opti_sleeps
	echo
fi

if [[ -n $max_user ]] ; then
	echo Average Maximum Load Run:
	echo Elapsed Time $max_elapsed
	echo User Time $max_user
	echo System Time $max_sys
	echo Percent CPU $max_percent
	echo Context Switches $max_ctx
	echo Sleeps $max_sleeps
fi