video: keep the beam step per clock count instead of dividing each time 12673a41ba17

video_step() runs after every instruction and worked out how far the
beam moves, PIXEL_FREQ * steps / mhz, twice, in double precision, with
two divisions. The clock count is almost always a handful, so the
quotient for each count below 32 is now kept in a table filled with the
same expression whenever mhz changes, and the two counters share one
result. The same expression gives the same double, so the beam position
is bit-for-bit what it was; larger counts (after a HostFS call) still
use the formula.

Measured as before (CPU seconds per emulated second, median of 3):

    narvi  idle  2.032 -> 2.046  (49%, within run-to-run spread)
    narvi  busy  1.884 -> 1.846  (53% -> 54% of a real X16)

x86 was within this machine's noise. The determinism check matches on
x86 and riscv64.

Author

Andy McCall @andymccall <[email protected]>

via

↳ agent agent:claude@andymccall <[email protected]> · keyless, under your grant for changes,refs,seal · key 3d452845da48

When

15 days ago · 2026-10-21 01:41 UTC

Signature

◈ sealed by agent:claude@andymccall

Hash

12673a41ba171e8324048662eae7ffd77c14453bb43edca023026f60f34d4978

Depends on

03a3459e6372

Depended on by

8e8d9cad1884

In bookmarks

main riscv-1

Edits

4 atoms, 0 tree operations, 1 file

Browse the tree at this change

1236 unchanged lines

	}

}

// How far the beam moves in `steps` CPU clocks: PIXEL_FREQ * steps / mhz.

// video_step() runs after every instruction, almost always for a handful

// of clocks, so the quotient for each small count is kept rather than

// divided out again; it is the same expression, so the same value.

static double

scan_pixels(float mhz, float steps)

{

	static float table_mhz;

	static double table[32];

	if (mhz != table_mhz) {

		for (int i = 0; i < 32; i++) {

			table[i] = PIXEL_FREQ * (float)i / mhz;

		}

		table_mhz = mhz;

	}

	if (steps >= 0 && steps < 32) {

		uint32_t s = (uint32_t)steps;

		if (s == steps) {

			return table[s];

		}

	}

	return PIXEL_FREQ * steps / mhz;

}

bool

video_step(float mhz, float steps, bool midline)

{

	uint16_t y = 0;

	bool ntsc_mode = reg_composer[0] & 2;

	bool new_frame = false;

	vga_scan_pos_x += PIXEL_FREQ * steps / mhz;

	const double pixels = scan_pixels(mhz, steps);

	vga_scan_pos_x += pixels;

	if (vga_scan_pos_x > VGA_SCAN_WIDTH) {

		vga_scan_pos_x -= VGA_SCAN_WIDTH;

		if (!ntsc_mode) {

15 unchanged lines

			render_line(vga_scan_pos_y - VGA_Y_OFFSET, vga_scan_pos_x);

		}

	}

	ntsc_half_cnt += PIXEL_FREQ * steps / mhz;

	ntsc_half_cnt += pixels;

	if (ntsc_half_cnt > NTSC_HALF_SCAN_WIDTH) {

		ntsc_half_cnt -= NTSC_HALF_SCAN_WIDTH;

		if (ntsc_mode) {

1186 unchanged lines