. "$BST_LIB"
require dhry dhrystone/present

# dhrystone 2.1 (Weicker, 1988) — the integer CPU benchmark, /usr/bin/dhry.
#
# WHAT THIS SUITE IS ACTUALLY FOR. Dhrystone's famous output is a score, but its
# useful output on a NEW ARM is the block above the score: twenty-odd variables
# whose final values the program publishes as "should be" alongside what it
# actually got. Each one is the residue of a specific language feature the
# benchmark exercises -- whole-struct assignment through a union with a
# discriminant, a self-referential record chased two links deep, 1-D and 2-D
# array indexing, an enum switch, char compare, call-by-reference, strcpy and
# strcmp -- so a single wrong value is a codegen fault on this arm, named. That
# makes dhrystone a correctness oracle wearing a benchmark's clothes, and it is
# why almost every case below asserts an invariant rather than a rate.
#
# THE COUNT COMES FROM STDIN, NOT argv. dhry printf's a prompt and scanf's the
# iteration count, and it does NOT check the scanf: `dhry </dev/null` runs an
# UNINITIALISED number of iterations (32727 observed on the x86_64 control) and
# still exits 0. Every invocation here pipes a count in. There is deliberately
# no case for the EOF path -- the count would be indeterminate, and a case whose
# workload is undefined cannot fail honestly.

work=${TMPDIR:-/tmp}/bst-dhry.$$
rm -rf "$work"; mkdir -p "$work"

# One large run carries both halves of the suite. N is chosen so the TIMING case
# below is able to pass on a kernel that accounts CPU time correctly: dhrystone
# needs Too_Small_Time = 120 clock ticks (1.2 s at HZ=100), and 100 000 000 runs
# measure ~2.5-5 s of CPU here. Picking a count that could never cross the
# threshold would make that case unfalsifiable.
N=100000000
echo "$N" | dhry > "$work/big" 2>&1; rc=$?

if [ "$rc" -eq 0 ]; then bst_ok dhrystone/exit-0
else bst_notok dhrystone/exit-0 "rc=$rc $(_bst_1line "$(cat "$work/big")")"; fi

check_out dhrystone/banner    "Dhrystone Benchmark, Version 2.1 (Language: C)" cat "$work/big"
check_out dhrystone/stdin-count "Execution starts, $N runs through Dhrystone"  cat "$work/big"
check_out dhrystone/completes "Execution ends"                                 cat "$work/big"

# Five field names (Ptr_Comp, Discr, Enum_Comp, Int_Comp, Str_Comp) are printed
# once for Ptr_Glob and again for Next_Ptr_Glob, so split the report at the
# second record before reading any of them by name.
sed -n '1,/^Next_Ptr_Glob->/p' "$work/big" > "$work/a"
sed -n '/^Next_Ptr_Glob->/,$p'  "$work/big" > "$work/b"

# fld <file> <label> -> the value dhry printed for that label. -F because
# Arr_1_Glob[8] carries brackets; the "should be:" lines never carry the label
# so they cannot be matched by accident.
fld() { grep -m1 -F "$2:" "$1" | sed 's/^[^:]*: *//'; }

# --- the published invariants, one case per language feature ----------------
check_eq dhrystone/int-glob        5  "$(fld "$work/a" Int_Glob)"
check_eq dhrystone/bool-glob       1  "$(fld "$work/a" Bool_Glob)"
check_eq dhrystone/ch-1-glob       A  "$(fld "$work/a" Ch_1_Glob)"
check_eq dhrystone/ch-2-glob       B  "$(fld "$work/a" Ch_2_Glob)"
check_eq dhrystone/arr-1-glob      7  "$(fld "$work/a" 'Arr_1_Glob[8]')"
# Arr_2_Glob[8][7] is the only invariant that is a function of the run count --
# it is Number_Of_Runs + 10 -- so it ties the 2-D array write to the count that
# actually reached the loop, not merely to a constant.
check_eq dhrystone/arr-2-glob "$((N + 10))" "$(fld "$work/a" 'Arr_2_Glob[8][7]')"

check_eq dhrystone/ptr-discr       0  "$(fld "$work/a" Discr)"
check_eq dhrystone/ptr-enum-comp   2  "$(fld "$work/a" Enum_Comp)"
check_eq dhrystone/ptr-int-comp    17 "$(fld "$work/a" Int_Comp)"
check_eq dhrystone/ptr-str-comp    "DHRYSTONE PROGRAM, SOME STRING" "$(fld "$work/a" Str_Comp)"

check_eq dhrystone/next-discr      0  "$(fld "$work/b" Discr)"
check_eq dhrystone/next-enum-comp  1  "$(fld "$work/b" Enum_Comp)"
check_eq dhrystone/next-int-comp   18 "$(fld "$work/b" Int_Comp)"
check_eq dhrystone/next-str-comp   "DHRYSTONE PROGRAM, SOME STRING" "$(fld "$work/b" Str_Comp)"

# The two Ptr_Comp values are "implementation-dependent" individually, but the
# program states they must be THE SAME pointer -- Proc_1/Proc_3 close the record
# chain onto itself. Equality (and non-null) is therefore assertable where the
# value is not, and it is the only case here that exercises pointer identity
# across two heap records.
pc_a=$(fld "$work/a" Ptr_Comp); pc_b=$(fld "$work/b" Ptr_Comp)
if [ -n "$pc_a" ] && [ "$pc_a" = "$pc_b" ] && [ "$pc_a" -ne 0 ] 2>/dev/null; then
  bst_ok dhrystone/ptr-chain-aliases
else
  bst_notok dhrystone/ptr-chain-aliases "Ptr_Glob->Ptr_Comp='$pc_a' Next_Ptr_Glob->Ptr_Comp='$pc_b'"
fi

check_eq dhrystone/int-1-loc  5  "$(fld "$work/b" Int_1_Loc)"
check_eq dhrystone/int-2-loc  13 "$(fld "$work/b" Int_2_Loc)"
check_eq dhrystone/int-3-loc  7  "$(fld "$work/b" Int_3_Loc)"
check_eq dhrystone/enum-loc   1  "$(fld "$work/b" Enum_Loc)"
check_eq dhrystone/str-1-loc  "DHRYSTONE PROGRAM, 1'ST STRING" "$(fld "$work/b" Str_1_Loc)"
check_eq dhrystone/str-2-loc  "DHRYSTONE PROGRAM, 2'ND STRING" "$(fld "$work/b" Str_2_Loc)"

# --- the whole-report gate ---------------------------------------------------
# The cases above name each invariant so a failure says WHICH feature broke.
# This one is the backstop: it walks every "<label>: <value>" / "should be: <x>"
# pair in the report and fails on any mismatch, so a variable added by a future
# version is covered the day it appears rather than the day someone adds a case
# for it. The two prose expectations -- "(implementation-dependent)" and
# "Number_Of_Runs + 10" -- are skipped here; both are asserted above instead.
mism=$(awk '
  /^ *should be:/ {
    e = $0; sub(/^ *should be: */, "", e)
    if (e ~ /^\(/ || e ~ /^Number_Of_Runs/) next
    if (v != e) printf "%s(want %s got %s) ", l, e, v
    next
  }
  /:/ { l = $0; sub(/:.*/, "", l); gsub(/^ +/, "", l)
        v = $0; sub(/^[^:]*: */, "", v) }
' "$work/big")
if [ -z "$mism" ]; then bst_ok dhrystone/self-check-all
else bst_notok dhrystone/self-check-all "$(_bst_1line "$mism")"; fi

# --- the count really is read, not defaulted ---------------------------------
# A second, tiny run: if the scanf were ignored and some constant used instead,
# every case above would still pass, because only Arr_2_Glob[8][7] depends on N
# and it would simply be wrong twice in the same way. Two different counts
# yielding two different N+10 values is what rules that out.
echo 1000 | dhry > "$work/small" 2>&1
check_eq dhrystone/count-honoured 1010 "$(fld "$work/small" 'Arr_2_Glob[8][7]')"

# --- the benchmark's own reason to exist -------------------------------------
# EXPECTED RED on wasm32-hwjs today, and it is the finding rather than a defect
# in this port. dhrystone times itself with times(2) from INSIDE its own process
# (Begin_Time/End_Time = tms_utime around the loop). On this arm a live task's
# CPU time is settled only when the task ENDS: /proc/<pid>/stat reads utime=0
# for the whole 5 s a dhry child spends in state R, then jumps to the full 500
# ticks the instant it reaches Z. A process therefore cannot observe its own
# CPU time while running, User_Time is 0 at any run count, and dhrystone always
# takes its "Measured time too small" branch -- so the one number this program
# exists to print is unreachable. brintos/linux#38.
if grep -q "Dhrystones per Second" "$work/big"; then
  bst_ok dhrystone/score
else
  bst_notok dhrystone/score "no rate at N=$N: $(grep -m1 'too small' "$work/big") — brintos/linux#38"
fi

rm -rf "$work"