Files
LithosAnanke/v4/tools/depthsweep.py
T
Claude 37469f6c54 feat(v4): v3's whole POST is v4's POST -- 990 cases, all passed on Hera (#189)
Phase 7, Task 8: PARITY:V4_POST tests=990 pass=990 fail=0 on Hera (mesh-boot); the hosted
product 945 of them, all passed -- the 45 cases of physics.4th's words need the kernel.

- Enlarged, as ruled ("Enlarge v4 to fit"): a node is 32768 words, its data stack 1024
  deep (v3's), host and kernel alike; the dictionary's end moves with them.
- POST's runner compares every value a case leaves (v3's leave 101); V4_POST_KERNEL marks
  a case of the kernel's words, and a host without a kernel does not run it.
- mkpost.py --all is POST's table (make -C v4 post79), with docs/v4.0.0/POST.md; it reads a
  module's #defines (v3's Mama cases are MAMA_IMPLEMENTED, 0: v3's own POST skips all 20);
  it cuts no line between a word and the name it takes.
- Rules for the last of the table: the min/max and array-sum programs written as meant,
  CREATE's 26-character name (FORTH-79: 31), many_defs.
- POST_FLOOR 990.
- Tests sized for a 32-deep stack and a 16384-word node made deep-stack-ready
  (test_host_depth, test_host_quit, test_host_node, hosted-check, depthsweep.py).

make -C v4 test: all v4 tests passed. make -C kernel/tests test: all passed.
depthsweep at 1024: 230 runs, 0 failures. v4-checks running.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm
2026-11-14 08:12:23 +00:00

94 lines
4.6 KiB
Python
Executable File

#!/usr/bin/env python3
# SPDX-License-Identifier: LicenseRef-Starship-1.0
# Copyright (c) 2023-2026 Robert A. James
"""depthsweep.py -- the hosted product at every depth of both stacks.
depthsweep.py <starforth4 binary> <data depth> <return depth>
Every path by which the node begins, writes or reads a message is run with
the data stack holding 0 .. depth+2 values, and from 1 .. depth+2 calls
deep. At each, every line typed must be answered -- " ok" or " ERROR" --
and the node must come back: it may refuse with an error, but it may not
hang, and it may not swallow a line. Where the stack is shallow the
answers themselves are checked.
Why: docs/v4.0.0/MESH.md 7c.6. A fault that came after a message's first
word had moved left it half done; and a fault inside a flush of the output
buffer let EMIT run past the buffer's end. Nothing ran these paths on a
deep stack.
"""
import subprocess, sys
from concurrent.futures import ThreadPoolExecutor
binary, ddepth, rdepth = sys.argv[1], int(sys.argv[2]), int(sys.argv[3])
cases = []
def run(lines):
text = '\n'.join(lines) + '\n'
try:
r = subprocess.run([binary], input=text.encode(), capture_output=True, timeout=30)
return r.stdout.decode('latin1'), False
except subprocess.TimeoutExpired as e:
return (e.stdout or b'').decode('latin1'), True
def answers(out):
# what follows POST: one answer to a line typed
body = out.split('POST: PASSED', 1)[-1]
return body.count(' ok\n') + body.count(' ERROR\n')
def check(name, k, lines, expect=None):
cases.append((name, k, lines, expect))
def judge(case):
name, k, lines, expect = case
out, hung = run(lines)
why = None
if 'POST: PASSED' not in out: why = 'POST did not pass'
elif hung: why = 'it hung'
elif answers(out) != len(lines): why = '%d lines typed, %d answered' % (len(lines), answers(out))
elif expect is not None and expect not in out: why = 'no "%s"' % expect.strip()
if why is None: return None
tail = out.split('POST: PASSED', 1)[-1][-160:].replace('\n', '|')
return 'depthsweep: FAIL %s at %d: %s: ...%s' % (name, k, why, tail)
def vals(k):
# a word that leaves k values: typed as k numbers, a line for a stack 1024 deep would be longer than a line
# may be (#189 Phase 7: the host node's data stack is v3's 1024)
return ': V %d 0 DO 1 LOOP ; V' % k
# The stack shallow, and then every depth from well below where anything
# changes to past its end. An error empties the stack, and a wait that a
# typed line breaks ends in an error: so the line that broke it is always
# done, whatever the depth.
shallow = ddepth - 12
for k in [0, 1, shallow] + list(range(ddepth - 10, ddepth + 3)):
v = [vals(k)] if k else []
sh = k <= shallow
check('a number printed', k, v + ['7 .', '77 .'], '77 ok' if sh else None)
check('WORDS', k, v + ['WORDS', '77 .'], 'DUP' if sh else None)
check('a line typed during AWAIT', k, [': AW 5 AWAIT ;'] + v + ['AW', '77 .', '88 .'], '77 ok')
check('SEND with no way', k, [': SD S" 1 DROP" 5 SEND ;'] + v + ['SD', '77 .'], 'Argument out of range' if sh else None)
check('a write to an empty port', k, v + ['5 7 PORT!', '77 .'], 'No one on that port' if sh else None)
check('an unknown word', k, v + ['NOSUCHWORD', '77 .'], 'UNKNOWN WORD' if sh else None)
check('a loop that prints 400 numbers', k, [': PR 400 0 DO I . LOOP ;'] + v + ['PR', '77 .'], ' 398 399 ok' if sh else None)
check('SEND by a way with no one on the port', k, ['5 7 ROUTE', ': SP S" 1 DROP" 5 SEND ;'] + v + ['SP', '77 .'], 'No one on that port' if sh else None)
def nest(n, inner):
return [': N1 %s ;' % inner] + [': N%d N%d ;' % (i, i - 1) for i in range(2, n + 1)] + ['N%d' % n]
rshallow = rdepth - 14
for n in [1, rshallow] + list(range(rdepth - 12, rdepth + 3)):
sh = n <= rshallow
check('a number printed, calls deep', n, nest(n, '7 .') + ['77 .'], '77 ok')
check('WORDS, calls deep', n, nest(n, 'WORDS') + ['77 .'], '77 ok')
check('a line typed during AWAIT, calls deep', n, nest(n, '5 AWAIT') + ['77 .', '88 .'], '77 ok')
check('SEND with no way, calls deep', n, nest(n, 'S" 1 DROP" 5 SEND') + ['77 .'], '77 ok')
check('a loop that prints 400 numbers, calls deep', n, nest(n, '400 0 DO I . LOOP') + ['77 .'], '77 ok')
check('SEND by a way with no one on the port, calls deep', n, ['5 7 ROUTE'] + nest(n, 'S" 1 DROP" 5 SEND') + ['77 .'], '77 ok')
with ThreadPoolExecutor(max_workers=8) as pool:
found = [f for f in pool.map(judge, cases) if f]
for f in found: print(f)
print('depthsweep: %d runs, %d failures' % (len(cases), len(found)))
sys.exit(1 if found else 0)