Leave windows on deep stacks to the table: the search never wins there

[codenlighten]

--effort high spends nearly all its time in the superoptimizer's A* search, and on real scripts that search almost never pays. Instrumenting where its wins come from:

script	searches	wins	from a stack of	time
examples/scripts/field-300.hex	1,391	15 (16 B)	at most 15 items	43 s
a 934 B mainnet contract	280	3 (3 B)	at most 6 items	176 s

In both, the searches starting from a stack of 20 or more items found nothing, while taking 40 s of 43 s and 113 s of 176 s. The search's cost grows with the stack it starts from (every expansion copies it, and PICK/ROLL branch over its depth) but its wins do not.

Change

A window whose stack is deeper than searchMaxDepth (default 16) is left to the table, the way a window wider than the table already is. Nothing else about which windows are searched changes, and the limit is an option.

The search also builds each state's key once, when the state is created, instead of rebuilding it at each pop, and tests the goal by comparing stacks instead of strings.

Effect

Same bytes, less time:

script	bytes	before	after
field-300.hex (--effort high)	2,607	45 s	8.9 s
934 B contract (--effort high)	694	155 s	51 s
two more contracts	unchanged		2.8-3.5x faster
two small contracts	unchanged		unchanged (their searches were shallow)

Output is byte for byte what it was, compared by SHA-256: the Miller loop (333,031 → 199,147), the final exponentiation (473,562 → 284,713), field-300.hex, sha256.block, g1.inSubgroup, fp12.mul, fp12.inv and ec.add. npm test: 28/28.

Why not lower the expansion budget instead

Also measured: at --effort high with maxExpand 1,000–1,500 the contract drops to 25 s, but one of the three wins is lost, and on field-300.hex raising the budget from 1,000 to 5,000 buys nothing at all (2,607 B either way, 26 s more). The depth limit removes the waste without giving up a win, so the budget is left alone.

What this came out of

Measuring whether the optimizer leaves bytes on the table inside regions. On mainnet contracts --effort high finds zero extra bytes over medium (the 3 B it found were recovered by other passes anyway) while taking up to 100x as long; on field code it finds 0.5%. Branch-level work looks similarly thin: across 4,071 IF blocks in the mainnet contract corpus, code shared between both branches that could be moved out of the block comes to 0.24% of their bytes, and no IF has a constant condition. What is left in these scripts is algorithmic, like the relax pass, not more search.