This is a cache of https://vccplus.brianholman.com/publications/vcc-plus-architecture/evidence/experiments/cmoc-benchmarks/reference-py/. It is a snapshot of the page as it appeared on 2026-11-21T00:02:54.497+0000.
experiments/cmoc-benchmarks/reference.py — supporting evidence · VCC Plus
← Supporting evidence

Evidence record

experiments/cmoc-benchmarks/reference.py

From Windows Application to Portable Emulation Platform

7,185 bytes

# SPDX-License-Identifier: GPL-3.0-or-later
"""Independent host models for authored 16-bit CMOC workloads.

The returned serialized bytes cover all mutable result state. Inputs and unsigned wrapping are explicit;
reference results never come from a compiler-produced executable.
"""
CASES = [
    "fixed_math", "sprites", "memory_crc", "sort_state",
    "framebuffer", "audio_mix", "input_scan", "sector_directory",
]
OUTPUT_CAPACITY = 264


def expected(seed, case):
    """Return the expected output bytes for integer case ID and 16-bit seed."""
    if not 0 <= seed <= 0xffff or not 0 <= case < len(CASES):
        raise ValueError("seed must be 16-bit and case must be 0..7")
    result = []

    def byte(value):
        result.append(value & 255)

    def word(value):
        byte(value >> 8)
        byte(value)

    def long(value):
        word(value >> 16)
        word(value)

    if case == 0:
        values = [(seed * 37 + i * 257 + 100) & 0xffff for i in range(16)]
        factors = [(seed + i * 13 + 17) & 255 for i in range(16)]
        accumulated = 0
        for round in range(8):
            for i in range(16):
                product = values[i] * (factors[i] + 1) + (i << 16)
                accumulated = (accumulated + product) & 0xffffffff
                values[i] = (product >> 8) & 0xffff
                factors[i] = (factors[i] + i + round + 3) & 255
        for value, factor in zip(values, factors):
            word(value)
            word(factor)
        long(accumulated)
    elif case == 1:
        sprites = [[(seed + i * 17) & 255, (seed * 3 + i * 11) & 255,
                    (seed + i * 3) & 7, (seed + i * 5) & 7, 0]
                   for i in range(12)]
        for _ in range(12):
            for sprite in sprites:
                sprite[0] = (sprite[0] + sprite[2]) & 255
                sprite[1] = (sprite[1] + sprite[3]) & 255
            for i in range(12):
                for j in range(i + 1, 12):
                    if abs(sprites[i][0] - sprites[j][0]) < 8 and abs(sprites[i][1] - sprites[j][1]) < 8:
                        sprites[i][4] += 1
                        sprites[j][4] += 1
        for x, y, vx, vy, hits in sprites:
            word(x)
            word(y)
            byte(vx)
            byte(vy)
            word(hits)
    elif case == 2:
        source = [(seed + i * 19) & 255 for i in range(128)]
        crc = seed
        for round in range(4):
            destination = [value - 32 if 97 <= value <= 122 else value for value in source]
            for value in destination:
                crc ^= value << 8
                for _ in range(8):
                    crc = ((crc << 1) ^ (0x1021 if crc & 0x8000 else 0)) & 0xffff
            source = [(value + round + 1) & 255 for value in source]
        for original, copied in zip(source, destination):
            byte(original)
            byte(copied)
        word(crc)
    elif case == 3:
        values = sorted((seed * 11 + i * 73) & 255 for i in range(32))
        state = seed & 3
        counters = [0] * 4
        for round in range(8):
            for i, value in enumerate(values):
                if state == 0:
                    counters[0] = (counters[0] + value) & 0xffff
                    state = (value + round) & 3
                elif state == 1:
                    counters[1] ^= value << (round & 3)
                    state = (i + round) & 3
                elif state == 2:
                    counters[2] = (counters[2] + i + round) & 0xffff
                    state = value & 3
                else:
                    counters[3] = (counters[3] + (value ^ round)) & 0xffff
                    state = (state + i) & 3
        for value in values:
            byte(value)
        for value in counters:
            word(value)
        byte(state)
    elif case == 4:
        pixels = [(seed + i * 7) & 255 for i in range(256)]
        tile = [(seed * 3 + i * 11) & 255 for i in range(64)]
        positions = [(seed + i * 23) & 255 for i in range(8)]
        for frame in range(4):
            for sprite in range(8):
                left, top = positions[sprite] & 15, positions[sprite] >> 4
                for y in range(8):
                    for x in range(8):
                        pixels[(((top + y) & 15) << 4) | ((left + x) & 15)] ^= tile[y * 8 + x]
                positions[sprite] = (positions[sprite] + sprite + frame + 1) & 255
        result.extend(pixels + positions)
    elif case == 5:
        phases = [(seed * 113 + i * 997) & 0xffff for i in range(4)]
        steps = [101 + (seed & 255) + i * 173 for i in range(4)]
        for _ in range(128):
            mix = 0
            for channel in range(4):
                phases[channel] = (phases[channel] + steps[channel]) & 0xffff
                value = phases[channel] >> 8
                mix += value * 2 if value < 128 else (255 - value) * 2
            byte(mix >> 2)
        for value in phases:
            word(value)
    elif case == 6:
        axes = [(seed + i * 13) & 255 for i in range(8)]
        centers = [96 + (seed & 31) + i * 3 for i in range(8)]
        totals = [0, 0]
        history = []
        buttons = seed & 255
        for n in range(32):
            index = (n & 3) * 2
            for channel in range(2):
                delta = abs(axes[index + channel] - centers[index + channel])
                if delta > 3:
                    totals[channel] = (totals[channel] + delta) & 0xffff
            axes[index] = (axes[index] + n + 1) & 255
            axes[index + 1] = (axes[index + 1] + n + 3) & 255
            buttons = ((buttons << 1) | (buttons >> 7)) & 255
            history.append(buttons ^ axes[index] ^ axes[index + 1])
        for axis, center in zip(axes, centers):
            byte(axis)
            byte(center)
        result.extend(history)
        word(totals[0])
        word(totals[1])
        byte(buttons)
    else:
        sector = [0] * 256
        for entry in range(8):
            base = entry * 32
            for i in range(11):
                # CMOC unsigned arithmetic wraps before the remainder.
                sector[base + i] = 65 + (((seed + entry * 7 + i) & 0xffff) % 26)
            sector[base + 11] = entry & 3
            sector[base + 12] = ((seed + entry * 9) & 0xffff) % 68
            sector[base + 13] = 255 if entry & 1 else 0
            last = 1 + ((seed + entry * 17) & 255)
            sector[base + 14] = last >> 8
            sector[base + 15] = last & 255
        sector[32] = 0
        sector[160] = 255
        active = last_bytes = name_hash = granule_sum = 0
        for _ in range(16):
            for entry in range(8):
                p = sector[entry * 32:(entry + 1) * 32]
                if p[0] in (0, 255):
                    continue
                active += 1
                last_bytes = (last_bytes + (p[14] << 8) + p[15]) & 0xffff
                granule_sum = (granule_sum + p[12]) & 0xffff
                for value in p[:11]:
                    name_hash = ((name_hash << 1) ^ value) & 0xffff
        result.extend(sector)
        for value in (active, last_bytes, name_hash, granule_sum):
            word(value)

    return result

SHA-256ebff53967c86a8f9956e2e6f8ad9fbf17c3d1335bae08910510eed769b8daae1

A closer look

Open original