# 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
Evidence record
experiments/cmoc-benchmarks/reference.py
From Windows Application to Portable Emulation Platform
7,185 bytes
SHA-256ebff53967c86a8f9956e2e6f8ad9fbf17c3d1335bae08910510eed769b8daae1