#!/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.30

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

while getopts vsHOMn:o:hf 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 optimal 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 "f : fast run"
				echo "h : print this help"
				echo "v : print version number"
				exit ;;
		 v) echo "kernbench Version $VERSION by Con Kolivas <kernbench@kolivas.org>" ; exit ;;
		 n) nruns=$OPTARG ;;
		 o) optijobs=$OPTARG ;;
		 s) single_runs=1 ;;
		 H) half_runs=0 ;;
		 O) opti_runs=0 ;;
		 M) max_runs=0 ;;
		 f) fast_run=1 ;;
	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 [[ $nruns -gt 0 ]] ; then
	num_runs=$nruns
elif [[ $fast_run -eq 1 ]]; then
	echo "Dropping to 3 runs for fast run"
	num_runs=3
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 -lt 2000000 && $max_runs -gt 0 ]] ; then
	echo Less than 2Gb ram detected!
	echo Maximal loads will not measure cpu throughput and may cause a swapstorm!
	echo If you did not plan this, -M flag is recommended to bypass maximal load.
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

if [[ $fast_run -eq 0 ]] ; then
	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
fi

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

if [[ $halfjobs -lt 2 ]] ; then
	echo "Half load is no greater than single; disabling"
	half_runs=0
elif [[ $halfjobs -eq 2 ]] ; then
	echo "Half load is 2 jobs, changing to 3 as a kernel compile won't guarantee 2 jobs"
	halfjobs=3
fi

echo
echo Performing $num_runs runs of
if [[ $single_runs -gt 0 ]] ; then
	echo make
fi
if [[ $half_runs -gt 0 ]] ; then
	echo make -j $halfjobs
fi
if [[ $opti_runs -gt 0 ]] ; then
	echo make -j $optijobs
fi
if [[ $max_runs -gt 0 ]] ; then
	echo make -j
fi
echo

if [[ ! $single_runs -eq 0 && $fast_run -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
	sync
	if [[ $fast_run -eq 0 ]] ; then
		sleep 5
	fi
	$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 && $fast_run -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
	sync
	if [[ $fast_run -eq 0 ]] ; then
		sleep 5
	fi
	$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 && $fast_run -eq 0 ]] ; then
	echo Warmup optimal 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 Optimal load -j$optijobs run number $i...
	make clean > /dev/null 2>&1
	sync
	if [[ $fast_run -eq 0 ]] ; then
		sleep 5
	fi
	$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 && $fast_run -eq 0 ]] ; then
	echo Warmup maximal 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 Maximal load -j run number $i...
	make clean > /dev/null 2>&1
	sync
	if [[ $fast_run -eq 0 ]] ; then
		sleep 5
	fi
	$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 -j $halfjobs 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 Optimal -j $optijobs 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 Maximal -j 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