Functions
	copy_fn (B, U, timed=True)

	set_fn (U, timed=True)

	thunk_fn (target)

	build ()

Variables
str	LICENSE

list	COPIES = [(2, 2), (4, 4), (8, 8), (8, 16), (8, 32), (2, 32), (4, 32), (16, 16), (16, 32)]

list	SETS = [1, 2, 4, 8, 16, 32, 64]

list	TREGS = ["$t%d" % i for i in range(8)]

list	SREGS = ["$s%d" % i for i in range(8)]

list	TIMER_START = [" lui $t9, 0x1f80", " lhu $t8, 0x1120($t9)"]

list	TIMER_STOP

list	BARE_COPIES = [(8, 8)]

list	BARE_SETS = [4]

list	THUNKS = ["__wrap_memcpy", "__wrap_memset", "copy_b8_u8_bare", "set_u4_bare"]

	text = build()

	cur = open("kernels.s").read()

Detailed Description

Regenerates kernels.s.

The sweep is a grid, so its assembly is data: nine copy kernels crossing batch
depth with unroll depth, seven set kernels, and an icache-sized block of nops.
Writing those by hand is 1700 lines of transcription and every one of them is a
chance to get an offset wrong - which is the bug the whole test exists to find.
Edit the COPIES and SETS lists below and re-run; do not hand-edit kernels.s.

    ./gen.py            rewrite kernels.s
    ./gen.py --check    exit non-zero if kernels.s is not what this would write

Function Documentation

◆ build()

gen.build ( )

◆ copy_fn()

gen.copy_fn	(	B,
		U,
		timed = `True`
	)

B words loaded before any is stored, U words per loop iteration.

Both pointers are bumped at the top and the block is addressed with negative
displacements, so the branch delay slot can carry the block's final store
and the loop tail is 2 addiu + 1 bltu with nothing wasted. The loop ends on
start + count-with-remainder-removed; see the note in memory-s.s about why
it must not be written as end - blocksize.

◆ set_fn()

gen.set_fn	(	U,
		timed = `True`
	)

◆ thunk_fn()

gen.thunk_fn ( target )

time_<target>(a0, a1, a2): calls target directly, returns its ticks.

For routines that cannot carry their own bracket: the shipped crt0 ones, and
untimed copies of the bare kernels they are compared against, so that both
sides of that comparison sit inside the same bracket. The start count is
spilled because the callee may clobber $t8.

Variable Documentation

◆ BARE_COPIES

list gen.BARE_COPIES = [(8, 8)]

◆ BARE_SETS

list gen.BARE_SETS = [4]

◆ COPIES

list gen.COPIES = [(2, 2), (4, 4), (8, 8), (8, 16), (8, 32), (2, 32), (4, 32), (16, 16), (16, 32)]

◆ cur

gen.cur = open("kernels.s").read()

◆ LICENSE

str gen.LICENSE

Initial value:

=  """/*
 
MIT License
 
Copyright (c) 2026 PCSX-Redux authors
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
*/
"""

◆ SETS

list gen.SETS = [1, 2, 4, 8, 16, 32, 64]

◆ SREGS

list gen.SREGS = ["$s%d" % i for i in range(8)]

◆ text

gen.text = build()

◆ THUNKS

list gen.THUNKS = ["__wrap_memcpy", "__wrap_memset", "copy_b8_u8_bare", "set_u4_bare"]

◆ TIMER_START

list gen.TIMER_START = [" lui $t9, 0x1f80", " lhu $t8, 0x1120($t9)"]

◆ TIMER_STOP

list gen.TIMER_STOP