From f2623cb62b9081fc732d8df2b102a536c7b2d535 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 16 Apr 2026 17:17:10 +0000
Subject: [PATCH] sha256/computing: track byte offsets directly to skip
 per-iter shift
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The phased compression driver was computing the schedule/round
*index* per iteration and then shifting it left by 2 to get the
byte offset (`schedule_one(i << 2)`, `round_one(r << 2)`). The
shift compiles to two ASLs per iteration — cheap, but pure dead
work since the byte offset is just the previous one + 4.

Track the byte offset as the loop counter and bump it by 4 each
iteration. The schedule and round APIs already wanted byte
offsets, so the call sites also get a touch shorter (no more
intermediate `var i: u8 = first_idx + step`).

Strict cycle savings are tiny — a handful per iteration — so
this is more about not leaving obviously redundant work in the
inner loop than a meaningful perf win. Hash output unchanged
(still AE9145DB…4E0D for "NES"); no other examples affected;
emulator harness 34/34.

https://claude.ai/code/session_01FRmSBruVWCufm3LsUVMs8v
---
 examples/sha256.nes                | Bin 24592 -> 24592 bytes
 examples/sha256/computing_state.ne |  28 ++++++++++++++++++----------
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/examples/sha256.nes b/examples/sha256.nes
index e53088bbebed797f6a4bd5f5812bb4663f4f256f..b3e856981634e6a2499b281dab96bdf221949cad 100644
GIT binary patch
delta 1392
zcmah|Ur1Y57|+eUX_I)>#;IIul&i6S(hlaoLf8b8wku2ynwi#GBO|6ujj4auZVm<;
zF$o8@mti@B;e&hV{7P>ITg4~aDt%}*Hzl=7`XFqNyG#aK`?QB`u<zXK==QRaaK3ZC
z@Avzi@Au_o{(&%$-;af{8=t5`=Ehe?gwXQC?+ys1l@AVjg>*YOXa{uAPUzH~cSQ1a
z0otjg4i}&^u;-+m<TKpqw&!-N-L-1Hg^f<c#XzE6(1qaM!hYbXZs@jB{~r*3gr0&^
z7XCj1+j1(xF#FY6&t#X|K3rfPm#>E37Jz`&tr=L<)quF1%YOh~=c;VU<*$S{tP9M*
z)?LRWbl1cB-Jx_Zx(`B-h9G3RzgdJ{1Yasbh`SGwPjR>Je$}d-EpCL!%_6`2G@M58
z+2X$gubhE1mJAOFutMyXwB%R~ON(L0PX!)XRfXQruN|in^izkL+~iyJUO{`6XV~)!
zuh7pb<;I2q6EpA<^Tfgou#oH(2G~1tV_Vq7gkNI*v@rV_lvEel?-gFQDtp**+4D+H
zH}84dV(|JpBeIvdD?RB!7}V8yk(?;OV1CUe(JV&DF1Aa?AdyQk%|;^-(Srzivjma6
zW?KwPMufapvMP@bV<m$X{~z=`t|GmliGd$4&>Wms5;;1AoHbRV85qh##^SzJg2M>E
zh^t4W!yG@1_g+*IS$c_mQ`vBA1V#dTL7LN4oKFt>{-ww>UYap88O(Sd!wCDi(kG0t
z>MFi=Re=y?yH)LS6w6;cHjz<QSN)}T6h=*x_qJd(zt+x8j&hS>hcU_u)i2U9P~2`e
zozr4UVvde!Czo6>wqUbsCl>^}W?Qh^A+{je4VU%dQ;9=dKZM?gwjtiv*GDfy+<%b1
zYsnnqG6}fMPgzan#;zb|9OCA@T9IQ;WgHT84zBQq##xW&XgW@Qc*@n2kkp;1UcUoL
z)R@3j3Q}guvjeF<RK=-f=~b9e5?4)6lZcsulwZJSERx&XFo|vT(JAsRZvE9*LnXJ8
zNYQDYpMh!Y_q~5~cnxOi`7xv2RuUO{9j;+p*YTH|V!wHg)~3kxwvi;!ZEILcqJh58
zI%>LWXJOWy#N-al^7o-i#_Y;RHP3|fhh=C)MLvTdpFs<@*b1$>gwAHl(1I^<xdbiB
zghX46RuU;|g3(CUk)?YPvW%O+o@^@kklF@qCN*CMA5tGZ0UxLOj5hN5-&FPfmS(4-
z`mjvSkxg~?DLJ=^)Ml-gHpPr)Xx4k~h~)b+&q34vKYp*g(PSP(;(G>yKZpYq`9^iw
Za0XdC)~wXky*S~>?AjjqR;q)7`WHqD8-)M>

delta 1455
zcmaJ=T})GF8189LCoQG52HXLv9;!vFOU9s*nut;hOV*s3%AcUnG}@zp1$1^HOGZlD
ze93-paNm-J3%qc?#=|my!j(T5E);rds+QDbT<p?jWXYlz%Wk%~_dBPHxFt)Q@A<y>
zd7k%t@6*$nC2j`4pL0W(rbKS)(q#|VcKhMYcQ|z+vB|}qX$CWCffnKepIULtBz>QS
zX2Og8S@8MSD~M0}5_hWMr4hNiI(Im`>_c4?c(Nb%qxf*P46M`&t$JxA(2p%5O<1<m
zDT_V8RDSU5Pho)mw}1%_zyV#r00kR?KCpP{@0JGIY!yb3JE%)^VCFVx)6E+Ib?o&2
zz|4o>kZ%4L(4*EsGJtU%fg>acK`pK;IS8P7AO}GfS5W!_cjdV5=v+r`IVfGpvDO{X
zf#Qzb+rXGk=+xUVK!Fa?Yy4I7oiINaHvf`kNbQwsZCKeucnA}-IK0BP;=Qc$9;?uo
zl`eY2R!QHrIcd)3tazdm$7sOjqOXw{wmDn7G<(+@`(L`MT)|G_oXRxV)GU6zqV?{g
zH*NK;-I}%gjWwfcY`Ma$5B_8A{-&xv*#kYQIAfCb=AmbP(ZG{5BBbY<_)?E#%SROh
z>4jdk9VMN4=$%&#b78*JE4`oBnMZZVq>%CcN&0X#k>iTV|Kd2wK%XFINI!ZOMV_Rf
ze;!i0_oF=2p?m;Wr-__k`V;uv0YOfalk|tG+TDXN=wELq8AZhSGC0<6IaYCzlvYV$
z#rYTp>918gxk2i%v$e$z+z?%}H`#`e{`Rq^9HKRj?_3dxXhYt63X%E6CN^Y*4H-6<
zA~frGl{^K4)oLZvN>q@i$!TTZRSTS+H5iqBvz$>e%o>ewYSv^dS@aJ}B?d8dGtS;u
zfLJILA~M9ho5&fx&1Tl-EXeGXRzx<~FnUHHrsd^EkCw^^oF&sR%q}!S4>}u@G3n=L
ztota8sukFM>ne<5k8@axLtHC4S0Nt4u9#YyjKMiU9@AzTN6iGpy&S&fCh2+s#_?Jq
zG9lf-t=EAZcCrd`oSbL%3veFq`^knIUW5x<*)gSD7vvO4z(u@P0)M#)`iHZzIxdYD
zN~6-rLR1S&kZZ}O^n)$F>PeW?l8CRuBzr$ZzBIY;*_P*AGEszjEdk6UO&aimZg8tS
z&NWtq20?a{ok;WI?R?2C9V;qasb0E^9@T}CA93Sfx1nGc8a?3AjMs{=OOQRJQ8PYz
zQu0V&{bLmGKUIvxBrX-D4_CysXS7gV)ACah-P>VX`M>|7xV%j}n4}%gf%CRwR<Db=
f5iJHBH;qU8LT$~fy)<0Mo2S+cOFI@E?VR{Gj37F;

diff --git a/examples/sha256/computing_state.ne b/examples/sha256/computing_state.ne
index ad30100..b515736 100644
--- a/examples/sha256/computing_state.ne
+++ b/examples/sha256/computing_state.ne
@@ -32,24 +32,32 @@ state Computing {
 
     on frame {
         if cp_phase < SCHED_PHASES {
-            // Each schedule phase handles BATCH_SIZE words.
-            // First word index for this phase: 16 + phase * 4.
-            var first_idx: u8 = 16 + (cp_phase << 2)
+            // Each schedule phase handles BATCH_SIZE words. The
+            // schedule_one / round_one APIs both want a byte
+            // offset (= word_index * 4), so track that directly
+            // instead of recomputing `index << 2` per iteration:
+            // the byte offset is just incremented by 4 in lieu
+            // of the index by 1.
+            //
+            // First byte offset for this phase: (16 + phase*4)*4
+            // = 64 + phase * 16.
+            var w_byte: u8 = 64 + (cp_phase << 4)
             var step: u8 = 0
             while step < BATCH_SIZE {
-                var i: u8 = first_idx + step
-                schedule_one(i << 2)        // byte offset into w[]
+                schedule_one(w_byte)
+                w_byte += 4
                 step += 1
             }
             cp_phase += 1
         } else if cp_phase < FOLD_PHASE {
-            // Round batch. First round for this phase:
-            // (phase - SCHED_PHASES) * 4.
-            var first_r: u8 = (cp_phase - SCHED_PHASES) << 2
+            // Round batch. First byte offset for this phase:
+            // (phase - SCHED_PHASES) * 4 * 4
+            // = (phase - SCHED_PHASES) << 4.
+            var kw_byte: u8 = (cp_phase - SCHED_PHASES) << 4
             var step2: u8 = 0
             while step2 < BATCH_SIZE {
-                var r: u8 = first_r + step2
-                round_one(r << 2)           // K/W share byte 4*i
+                round_one(kw_byte)
+                kw_byte += 4
                 step2 += 1
             }
             cp_phase += 1