Silk #3079: decoding faster without losing the boundaries
Optimize the existing streaming decoder and CRC-32 implementation while retaining Decoder.step, resource limits and a 64 KiB memory bound. Read the unsafe fast-loop proof and handoff first, CRC dispatch second, and correctness/measurement evidence last. Source analysis and an independent CRC model support understanding; native execution and speedup remain unverified in this run.
Purpose
Optimize the existing streaming decoder and CRC-32 implementation while retaining Decoder.step, resource limits and a 64 KiB memory bound. Read the unsafe fast-loop proof and handoff first, CRC dispatch second, and correctness/measurement evidence last. Source analysis and an independent CRC model support understanding; native execution and speedup remain unverified in this run.
Evidence (38 references)
Before and after
Before: Fast decoding under an explicit buffer proof: The base already had table decoding, a fast path, two literal decoding and 8-byte copies. This PR specializes and removes checks from that path rather than introducing streaming DEFLATE. Fast-loop exits preserve the incremental decoder: The old fast path returned a boolean and stopped before exceptional work. CPU-gated CRC folding with a table tail: CRC-32 used slice-by-8 tables already; the old module comment incorrectly described one table lookup per byte. Separate replay equivalence from warm-process timing: One differential run was used for update timing as well as semantic equivalence, and the two fanout entries were smaller. After: Fast decoding under an explicit buffer proof: The head uses 10-bit literal and 8-bit distance roots, packed flags/skip/take entries, pointer refills, a third root literal, and 8/16-byte match copies. Fast-loop exits preserve the incremental decoder: Three explicit outcomes distinguish block end, normal handoff and pending-distance handoff while leaving the public step and limit contract in place. CPU-gated CRC folding with a table tail: x86-64 pclmul and AArch64 aes/PMULL kernels fold 64 or 128 bytes per step. Other targets or missing CPU features use the existing table algorithm. Separate replay equivalence from warm-process timing: The checker detects differential rows, skips only the update-us limit for that mode, still requires differences=0, and CI runs the same short stdlib replay again without --differential for timing.
Evidence (38 references)
Review order
1. Fast decoding under an explicit buffer proof: Review the 32/320 entry guards, extra refill after literals, maximum 258-byte match and up to 29 speculative copy bytes together. Table-index masking is a bounds control, not a substitute for valid tables. 2. Fast decoding under an explicit buffer proof: Read the current 10-bit literal root from source; the PR description still says 11. 3. Fast-loop exits preserve the incremental decoder: Check saved bit/count state on malformed root and subtable distances, and verify public consumed/written offsets. 4. Fast-loop exits preserve the incremental decoder: The fast loop writes within the clipped output limit; the unit path distinguishes NeedOutput from OutputLimit. Output remains provisional until Finished verifies the trailer. 5. CPU-gated CRC folding with a table tail: Check initial/final inversion, fold distances and reduction order, 64/512-byte transitions, residual 16-byte blocks and split-update equivalence. 6. CPU-gated CRC folding with a table tail: AArch64 aes represents the feature bundle that includes PMULL; available() also depends on target/profile runtime detection support. Windows profiles currently rely on build-selected features. 7. Separate correctness, measurement and documentation: Buffer widths straddle 31/32/33 input bytes and 319/320/321 output bytes; not every cross-product runs. Gzip dynamic, raw fixed and small-window zlib are generated by Silk Encoder. 8. Separate correctness, measurement and documentation: The benchmark uses fastest observed rounds and aggregate output bytes divided by summed per-entry times. It is a manual measurement tool, not a native correctness CI gate or a proof that the title is achieved. 9. Separate correctness, measurement and documentation: The final checksum reference now matches the source: it documents 64 or 128 bytes per folding step. The earlier mismatch is resolved. 10. Separate replay equivalence from warm-process timing: Confirm that a plain replay still executes and enforces update time; differential mode retains count, rejection and zero-difference checks. 11. Separate replay equivalence from warm-process timing: The Markdown ledger changes stdlib +116 to +133; YAML changes +19 to +42. These are accounting changes, not gzip throughput measurements.
Evidence (27 references)
Extension guidance
Proposed extension · Fast decoding under an explicit buffer proof: When changing unrolling or copy width, recalculate FAST_INPUT and FAST_ROOM and extend boundary fixtures before changing the constants. Proposed extension · Fast-loop exits preserve the incremental decoder: Add independent compressed fixtures and error cases when altering a handoff; retain byte-for-byte output and consumed/written checks. Proposed extension · CPU-gated CRC folding with a table tail: Test both feature-enabled and table-only target profiles; retain a bitwise oracle and add split updates crossing the eight-accumulator threshold. Proposed extension · Separate correctness, measurement and documentation: Publish x86-64 and AArch64 before/after results with compiler and CPU information, and keep correctness fixtures independent of timing assertions. Proposed extension · Separate replay equivalence from warm-process timing: Keep semantic equivalence checks and timing measurements as separate runs when extending replay verification.
Evidence (9 references)
Pack the work into a table word
The head stores flags, skip and total take bits in one u32. Literal and distance roots are 10 and 8 bits, and power-of-two capacities allow masked subtable access. buildCode must still construct valid entries and reject capacity overflow. The PR prose saying 11 root bits is stale.
// - `skip` (4 bits) is the length of the code within those bits, so the extra bits of a length
// or a distance are the consumed bits from bit `skip`.
// - `value` is a literal byte, a code-length symbol, or the base of a length or a distance.
//
// An entry with `ENTRY_LITERAL` is a literal. An entry with `ENTRY_SPECIAL` is one of three
// things: with `ENTRY_LINK`, a link whose `take` is the root bits, whose `skip` is the index
// width of a second-level part and whose `value` is the offset of that part; with `ENTRY_END`,
// the end of the block; with neither, a code that is not valid, whose `value` is a `BAD_` cause.
// An entry with no flag is a length, a distance or a code-length symbol.
const ENTRY_LITERAL: u32 = 0x80000000
const ENTRY_SPECIAL: u32 = 0x8000
const ENTRY_LINK: u32 = 0x4000
const ENTRY_END: u32 = 0x2000
const BAD_CODE: u32 = 0
const BAD_LENGTH: u32 = 1
const BAD_DISTANCE: u32 = 2
Check the complete window before a pass
fastLoop clamps logical ends to the actual buffers, then requires 32 input bytes and 320 output bytes. FAST_ROOM covers two literals, a maximum 258-byte match and the overcopy allowance. These shared bounds permit unchecked pointer reads and writes inside a pass.
fn fastLoop(state: &mut Decoder, input: &[u8], output: &mut [u8]) -> u32 {
// The ends are inside the buffers, whatever the state holds.
let mut inputEnd = state.inputEnd
if inputEnd > input.length {
inputEnd = input.length
}
let mut outputEnd = state.outputEnd
if outputEnd > output.length {
outputEnd = output.length
}
let mut position = state.inputPosition
let mut at = state.outputPosition
let flushed = state.flushed
if position > inputEnd || inputEnd - position < FAST_INPUT || at > outputEnd
|| outputEnd - at < FAST_ROOM
|| flushed > at
|| state.count > 63 {
return FAST_MORE
}
let inputLimit = inputEnd - FAST_INPUT
let outputLimit = outputEnd - FAST_ROOM
let tables = words(&state.tables)
let literals = Slice.view<u32>(tables, LITERAL_BASE, LITERAL_CAPACITY)
let distances = Slice.view<u32>(tables, DISTANCE_BASE, DISTANCE_CAPACITY)// The input the fast loop needs ahead of one pass, which is more than its refills read.
const FAST_INPUT: usize = 32
// The output room the fast loop needs for one pass: two literals, the longest match, and the
// 29 bytes that the copy of a short match can write after it.
const FAST_ROOM: usize = 320
const LITERAL_ROOT_MASK: usize = 1023
const DISTANCE_ROOT_MASK: usize = 255
// The fast loop reads and writes through pointers, with no bounds checks. Before each pass, itIssue up to three root literals
A branchless refill makes at least 56 bits consumable. Root literals are emitted in an unrolled run of up to three. If a length follows one or two literals, another refill restores enough bits for the length-plus-distance case. This refill is part of the safety argument.
count = count | 56
if entry & ENTRY_LITERAL != 0 {
// A literal from the root takes at most 10 bits, so three of them consume at most 30.
// Each pass writes at most two literals before a match, inside the `FAST_ROOM` bytes
// ahead.
acc = u64.shiftRight(acc, u32.toU64(entry & 63))
count = u32.wrappingSubtract(count, entry & 255)
unsafe pokeByte(out, at, u32.wrappingToU8(u32.shiftRight(entry, 16)))
at = usize.wrappingAdd(at, 1)
entry = literals[u64.wrappingToUsize(acc) & LITERAL_ROOT_MASK]
if entry & ENTRY_LITERAL != 0 {
acc = u64.shiftRight(acc, u32.toU64(entry & 63))
count = u32.wrappingSubtract(count, entry & 255)
unsafe pokeByte(out, at, u32.wrappingToU8(u32.shiftRight(entry, 16))) // `entry` stays right, because a refill only adds bits above those it read.
acc = acc | u64.shiftLeft(unsafe peek(source, position), u32.toU64(count & 63))
position = usize.wrappingAdd(position, u32.toUsize(u32.shiftRight(count ^ 63, 3)))
count = count | 56
}
// `entry` is not a literal, and at least 56 bits can be consumed: at most 20 for a length
// and 28 for a distance.
if entry & ENTRY_SPECIAL != 0 {
if entry & ENTRY_LINK == 0 {
if entry & ENTRY_END != 0 {
acc = u64.shiftRight(acc, u32.toU64(entry & 63))
count = u32.wrappingSubtract(count, entry & 255)
result = FAST_END
}
break
}
let linkAcc = acc
let linkCount = count
acc = u64.shiftRight(acc, u32.toU64(entry & 63))
count = u32.wrappingSubtract(count, entry & 255)
let part = usize.wrappingAdd(
u32.toUsize(u32.shiftRight(entry, 16)),
u64.wrappingToUsize(acc & lowMask(u32.shiftRight(entry, 8) & 15)),
)Match overlap determines copy width
Distances of at least 16 use 16-byte pieces; 8–15 use ordered 8-byte pieces, distance 1 repeats one byte, and smaller periods advance by their distance. Reads may consume bytes just produced by the preceding write. The logical output position advances only by the match length.
unsafe fn fastCopy(out: [*]mut u8, at: usize, found: usize, length: usize) -> () {
unsafe {
let read = Intrinsic.pointerRequalify<[*]mut u8, [*]const u8>(out)
let end = usize.wrappingAdd(at, length)
let mut target = at
let mut source = usize.wrappingSubtract(at, found)
if found >= 16 {
wideCopy(out, at, read, source, length)
return ()
}
if found >= 8 {
// Most matches are short, so three pieces go without a test. A piece can read what the
// piece before it wrote, which is what a match of a distance under 16 needs.
poke(out, target, peek(read, source))
poke(out, usize.wrappingAdd(target, 8), peek(read, usize.wrappingAdd(source, 8)))
poke(out, usize.wrappingAdd(target, 16), peek(read, usize.wrappingAdd(source, 16)))
target = usize.wrappingAdd(target, 24)
source = usize.wrappingAdd(source, 24)
while target < end {
poke(out, target, peek(read, source))
target = usize.wrappingAdd(target, 8)
source = usize.wrappingAdd(source, 8)
}Three exits reconnect the unit path
FAST_END calls endBlock. FAST_DISTANCE means a length is already decoded, so symbol enters PHASE_DISTANCE. FAST_MORE resumes normal symbol work, including short buffers. A boolean return would not distinguish that pending-length state.
fn symbol(state: &mut Decoder, input: &[u8], output: &mut [u8]) -> u32 {
let fast = fastBlock(&mut state, input, &mut output)
if fast == FAST_END {
endBlock(&mut state, &output)
return GO
}
if fast == FAST_DISTANCE {
state.phase = PHASE_DISTANCE
return GO
}
fill(&mut state, input)
let mut entry = lookup(words(&state.tables), LITERAL_BASE, LITERAL_ROOT, state.acc)
let mut take = entry & 255
// A run of literals stays here, which is most of what the end of an output buffer holds.Restore only the distance state
For unreachable history or a window violation, the fast loop restores the bits/count saved before distance decoding, saves the pending length, and lets distance produce the public error. The corpus asserts error kind and precise consumed/written offsets.
unsafe fastCopy(out, at, found, length)
at = usize.wrappingAdd(at, length)
continue
}
if found > window || usize.wrappingSubtract(found, fresh) > reach {
acc = lengthAcc
count = lengthCount
pending = length
result = FAST_DISTANCE
break
}
acc = u64.shiftRight(acc, u32.toU64(far & 63))
count = u32.wrappingSubtract(count, far & 255)
// The match starts `back` bytes before the end of the history, at `from` in the ring. }
at = usize.wrappingAdd(at, length)
}
if result == FAST_DISTANCE {
state.matchLength = pending
}
// The unit path needs zeros above the count.
state.acc = acc & lowMask(count)
state.count = count
state.inputPosition = position
state.outputPosition = at
return result
}Commit logical output, then validate the trailer
commit updates only output from flushed to outputPosition, stores the last 32 KiB in the history ring and advances counters. Gzip output is provisional until the trailer CRC and size pass and the stream reaches Finished. Wide-copy padding is not committed as logical output.
fn commit(state: &mut Decoder, output: &[u8]) -> () {
let start = state.flushed
let end = state.outputPosition
if end == start {
return ()
}
let fresh = Slice.view<u8>(output, start, end - start)
if state.format == Format.Zlib {
state.adler = CompressionChecksum.adler32Update(state.adler, fresh)
}
if state.format == Format.Gzip {
state.crc = CompressionChecksum.crc32Update(state.crc, fresh)
state.memberSize = u32.wrappingAdd(state.memberSize, usize.wrappingToU32(fresh.length))
}
let next = state.historyNext
let ring = bytesMut(&mut state.ring)
if fresh.length >= RING {
Slice.copyInto<u8>(&mut ring, 0, Slice.view<u8>(output, end - RING, RING)) if state.value != state.crc {
return reject(&mut state, ErrorKind.ChecksumMismatch)
}
state.phase = PHASE_GZIP_SIZE
return GO
}
if phase == PHASE_GZIP_SIZE {
if readBits(&mut state, input, 32) == false {
return starve(&mut state, input)
}
if state.value != state.memberSize {
return reject(&mut state, ErrorKind.SizeMismatch)
}
state.phase = PHASE_MEMBER
return GO
}
if phase == PHASE_MEMBER {
// The trailer ends on a byte boundary, so the buffer holds only whole bytes of this call.
giveBack(&mut state)
if state.inputPosition == input.length {
if state.finalSeen {
return DONE
}Feature checks guard specialized kernels
crc32Update preserves its external complemented checksum convention. At 64 bytes or more it can fold the multiple-of-16 prefix on x86-64 pclmul or AArch64 aes/PMULL. Otherwise all bytes go through tables. Runtime detection support depends on the target profile; it is not universally available on every OS.
pub fn crc32Update(crc: u32, bytes: &[u8]) -> u32 {
let mut value = crc ^ 0xffffffff
let mut rest = bytes
static if Target.arch() == Arch.X86_64 {
if bytes.length >= FOLD_MINIMUM && CpuFeatures.available("pclmul") {
let whole = bytes.length - bytes.length % 16
value = unsafe crc32Fold(value, Slice.view<u8>(bytes, 0, whole))
rest = Slice.view<u8>(bytes, whole, bytes.length - whole)
}
}
static if Target.arch() == Arch.Aarch64 {
if bytes.length >= FOLD_MINIMUM && CpuFeatures.available("aes") {
let whole = bytes.length - bytes.length % 16
value = unsafe crc32Fold(value, Slice.view<u8>(bytes, 0, whole))
rest = Slice.view<u8>(bytes, whole, bytes.length - whole)
}
}
return crc32Tables(value, rest) ^ 0xffffffffFour accumulators become eight at 512 bytes
The first 64 bytes seed four lanes. At least 448 remaining bytes select eight lanes, so the wide path begins at 512 bytes. FOLD_128 advances lanes in 128-byte groups, then FOLD_64 merges eight lanes into four and FOLD_16 collapses to one block. Table processing reduces that block and the final tail.
let mut two = block(head, 16)
let mut three = block(head, 32)
let mut four = block(head, 48)
let mut rest = Slice.view<u8>(bytes, 64, bytes.length - 64)
if rest.length >= FOLD_WIDE_MINIMUM {
// Eight accumulators, 128 bytes per step: a step waits for one multiplication, so more
// accumulators keep more of them in flight.
let wide = u64x2.fromArray(FOLD_128)
let second = Slice.view<u8>(rest, 0, 64)
let mut five = block(second, 0)
let mut six = block(second, 16)
let mut seven = block(second, 32)
let mut eight = block(second, 48)
rest = Slice.view<u8>(rest, 64, rest.length - 64)
while rest.length >= 128 {
let step = Slice.view<u8>(rest, 0, 128)
one = unsafe fold(one, wide, block(step, 0))
two = unsafe fold(two, wide, block(step, 16))
three = unsafe fold(three, wide, block(step, 32))
four = unsafe fold(four, wide, block(step, 48))
five = unsafe fold(five, wide, block(step, 64))
six = unsafe fold(six, wide, block(step, 80))
seven = unsafe fold(seven, wide, block(step, 96))
eight = unsafe fold(eight, wide, block(step, 112))
rest = Slice.view<u8>(rest, 128, rest.length - 128) one = unsafe fold(one, far, block(step, 0))
two = unsafe fold(two, far, block(step, 16))
three = unsafe fold(three, far, block(step, 32))
four = unsafe fold(four, far, block(step, 48))
rest = Slice.view<u8>(rest, 64, rest.length - 64)
}
one = unsafe fold(one, near, two)
one = unsafe fold(one, near, three)
one = unsafe fold(one, near, four)
while rest.length >= 16 {
one = unsafe fold(one, near, block(rest, 0))
rest = Slice.view<u8>(rest, 16, rest.length - 16)
}
let last = u8x16.toArray(u64x2.bitcastToU8x16(one))
return crc32Tables(0, &last)Straddle the fast-path thresholds
The native fixture uses input widths 31, 32 and 33 and output widths 319, 320 and 321, as well as larger and smaller buffers. It checks every output byte for dynamic gzip, fixed raw DEFLATE and small-window zlib; selected combinations avoid redundant unit-path work. Malformed fixed streams check exact failure offsets.
let inputs: [usize; 5] = [1000000, 4096, 33, 32, 31]
let outputs: [usize; 7] = [200000, 65536, 4096, 321, 320, 319, 40]
let mut input: usize = 0
while input < inputs.length {
let mut output: usize = 0
while output < outputs.length {
// A narrow input with a narrow output only repeats the unit path.
if input < 2 || output == 0 || output == 4 {
let view = Slice.viewMut<u8>(&mut room, 0, outputs[output])
if !decodes(&mut decoder, format, encoded, expected, inputs[input], &mut view) {
return usize.toI32(input * 10 + output) + 1
}
}
output = output + 1
}
input = input + 1
}
return 0Read benchmark results as measurements
306 pinned npm tarballs feed the same pack into Silk and three C implementations. Each decoder must agree on output length and CRC. The report uses fastest rounds; aggregate throughput divides total output bytes by summed best entry times. No benchmark was run here and no speed factor is claimed.
rows = measure(commands[name], mode, arguments.rounds, path)
crcs = {key: row["crc"] for key, row in rows.items()}
reference = reference or crcs
if crcs != reference or any(rows[key]["raw"] != lengths[key] for key in rows):
raise SystemExit(f"{name} {mode}: output differs from the reference")
for key, row in rows.items():
best[name, mode][key] = min(best[name, mode].get(key, row["ns"]), row["ns"])
results = {}
for name, mode in runs:
result = {"groups": {
label: sum(lengths[key] for key in keys) * 1000 / sum(best[name, mode][key] for key in keys)
for label, keys in groups}}
if arguments.callgrind:
result["instructionsPerByte"] = (
instructions(commands[name], mode, 2, path) - instructions(commands[name], mode, 1, path)
) / sum(lengths.values())
results[f"{name} {mode}"] = result
total = sum(lengths.values())
print(f"{platform.machine()}, {len(entries)} tarballs, {total / 1e6:.1f} MB decoded, "
f"fastest of {arguments.passes} x {arguments.rounds} rounds, MB/s of output\n")
labels = [label for label, _ in groups]
header = ["", *labels] + (["instr/byte"] if arguments.callgrind else [])
print("| " + " | ".join(header) + " |")Keep review findings separate from runtime evidence
The independent Python folding model matched binascii.crc32 in 1,626 comparisons; package metadata, Python syntax and offline artifacts passed checks. Native execution was not run locally. Final PR-associated CI succeeded. The checksum reference was regenerated and now matches 64/128-byte folding. The PR body still describes an 11-bit root although source uses 10.
//!
//! # Details
//! No function allocates. CRC-32 folds 64 or 128 bytes per step with carry-less multiplication
//! when the running CPU has it (`pclmul` on x86-64, `aes` on AArch64), and otherwise reads eight## Details
No function allocates. CRC-32 folds 64 or 128 bytes per step with carry-less multiplication
when the running CPU has it (`pclmul` on x86-64, `aes` on AArch64), and otherwise reads eight
table entries per 8 bytes. Both paths return the same value.Separate replay equivalence from update timing
The final PR also repairs replay verification: differential mode compares stores and checks zero differences without enforcing its update-us values. CI then runs a plain replay to enforce warm-process update timing. Count, fanout and rejection budgets remain checked. The Markdown and YAML fanout ledger entries are corrected. This is compiler verification infrastructure, separate from gzip throughput.
const over = 'outdatedOverFanout' in budget ? ` (the ${fanout.of} fanout's ${fanoutBudget.limit} ${budget.outdatedOverFanout >= 0 ? '+' : ''}${budget.outdatedOverFanout})` : '';
failures.push(`${label}: marked-outdated=${step['marked-outdated']} exceeds its budget of ${outdatedLimit}${over}`);
}
}
if (fraction > budget.demandsFraction) {
failures.push(`${label}: demands are ${fraction.toFixed(3)} of the initial check's, over the budget of ${budget.demandsFraction}`);
}
if (!differential && Number(step['update-us']) > entry.updateMicroseconds) {
failures.push(`${label}: update-us=${step['update-us']} exceeds the per-update limit of ${entry.updateMicroseconds}`);
}
}
if ('unchanged' in budget && !(Number(step.unchanged) >= budget.unchanged)) {
failures.push(`${label}: unchanged=${step.unchanged} is under its floor of ${budget.unchanged}`);
}
if ('verified' in budget && !(Number(step.verified) >= budget.verified)) {
failures.push(`${label}: verified=${step.verified} is under its floor of ${budget.verified}`);
}
if ('rejections' in budget && Number(step.rejections) !== budget.rejections) {
failures.push(`${label}: rejections=${step.rejections}, expected ${budget.rejections}`);
}
if (differences.size > 0 && differences.get(at) !== 0) {
failures.push(`${label}: the differential check reported differences=${differences.get(at)}`);
}Evidence (6 references)
Use ← → to navigate, Space to play or pause, and Home / End to jump. Start with the overview, then open a deep-dive chapter.
Coverage and evidence
20 captured files · 118 source references. Coverage describes the supplied snapshot; it does not establish complete runtime behavior.
- .changes/28193b6f5fec597d848818e31cd54498.md supporting
User-facing speed claims are recorded; this run does not establish the claimed factors.
Topics: verification
- .github/scripts/check-replay-budgets.mjs substantive
Separates differential correctness verification from plain replay timing.
Topics: replay-budgets
.github/scripts/check-replay-budgets.mjs:1–194 · .github/scripts/check-replay-budgets.mjs:1–191 · .github/scripts/check-replay-budgets.mjs:41–44 · .github/scripts/check-replay-budgets.mjs:50–73 · .github/scripts/check-replay-budgets.mjs:75–82 · .github/scripts/check-replay-budgets.mjs:169–169 · .github/scripts/check-replay-budgets.mjs:6–23 · .github/scripts/check-replay-budgets.mjs:81–97 · .github/scripts/check-replay-budgets.mjs:146–168 - .github/workflows/selfhost.yml substantive
Separates differential correctness verification from plain replay timing.
Topics: replay-budgets
- compiler/fixtures/replay/fanout/markdown.txt supporting
Corrects Markdown/YAML Bytes-reader fanout accounting.
Topics: replay-budgets
- compiler/fixtures/replay/fanout/yaml-stdlib.txt supporting
Corrects Markdown/YAML Bytes-reader fanout accounting.
Topics: replay-budgets
- compiler/scripts/selfhost-track.json supporting
Registers inflate-fast-loop for selfhost corpus tracking.
Topics: verification
- corpus/native/inflate-fast-loop/main.silk substantive
Byte equality, format, error-offset and independent bitwise CRC fixture.
Topics: verification, crc-folding, streaming-handoff
corpus/native/inflate-fast-loop/main.silk:1–330 · corpus/native/inflate-fast-loop/main.silk:87–167 · corpus/native/inflate-fast-loop/main.silk:192–240 · corpus/native/inflate-fast-loop/main.silk:256–296 · corpus/native/inflate-fast-loop/main.silk:297–323 · corpus/native/inflate-fast-loop/main.silk:142–167 · corpus/native/inflate-fast-loop/main.silk:87–139 · corpus/native/inflate-fast-loop/main.silk:213–240 · corpus/native/inflate-fast-loop/main.silk:149–166 - corpus/native/inflate-fast-loop/outcome.json supporting
Declares successful native fixture exit code 42.
Topics: verification
- integration/inflate-benchmark/README.md supporting
Defines measurement modes, comparison policy and manual use.
Topics: verification
- integration/inflate-benchmark/baseline.c substantive
Manual repeatable benchmark generation, implementation and result comparison.
Topics: verification
- integration/inflate-benchmark/corpus.lock.json supporting
Reviewed package counts, uniqueness, HTTPS URLs and SHA-512 pins; individual dependency versions are supporting data.
Topics: verification
- integration/inflate-benchmark/corpus.py substantive
Manual repeatable benchmark generation, implementation and result comparison.
Topics: verification
- integration/inflate-benchmark/run substantive
Manual repeatable benchmark generation, implementation and result comparison.
Topics: verification
- integration/inflate-benchmark/silk.toml supporting
Names the benchmark package and binary.
Topics: verification
- integration/inflate-benchmark/src/main.silk substantive
Manual repeatable benchmark generation, implementation and result comparison.
Topics: verification
- reference/stdlib/compress-checksum.md supporting
Regenerated final reference matches source 64/128-byte folding documentation; earlier mismatch resolved.
Topics: verification
- stdlib/silk/compress/checksum.silk substantive
CPU-specialized CRC kernels and unchanged external update convention.
Topics: crc-folding
stdlib/silk/compress/checksum.silk:1–822 · stdlib/silk/compress/checksum.silk:1–620 · stdlib/silk/compress/checksum.silk:1–13 · stdlib/silk/compress/checksum.silk:511–546 · stdlib/silk/compress/checksum.silk:548–564 · stdlib/silk/compress/checksum.silk:566–638 · stdlib/silk/compress/checksum.silk:640–709 · stdlib/silk/compress/checksum.silk:719–750 · stdlib/silk/compress/checksum.silk:513–550 · stdlib/silk/compress/checksum.silk:732–750 · stdlib/silk/compress/checksum.silk:514–541 · stdlib/silk/compress/checksum.silk:582–637 · stdlib/silk/compress/checksum.silk:653–708 · stdlib/silk/compress/checksum.silk:732–749 · stdlib/silk/compress/checksum.silk:587–611 · stdlib/silk/compress/checksum.silk:622–636 · stdlib/silk/compress/checksum.silk:7–10 - stdlib/silk/compress/inflate.silk substantive
Core table encoding, guarded fast loop, unit handoff and copies.
Topics: fast-inflate, streaming-handoff
stdlib/silk/compress/inflate.silk:1–2088 · stdlib/silk/compress/inflate.silk:1–1821 · stdlib/silk/compress/inflate.silk:459–543 · stdlib/silk/compress/inflate.silk:505–523 · stdlib/silk/compress/inflate.silk:585–642 · stdlib/silk/compress/inflate.silk:580–613 · stdlib/silk/compress/inflate.silk:746–789 · stdlib/silk/compress/inflate.silk:754–765 · stdlib/silk/compress/inflate.silk:732–744 · stdlib/silk/compress/inflate.silk:915–930 · stdlib/silk/compress/inflate.silk:1014–1066 · stdlib/silk/compress/inflate.silk:1289–1335 · stdlib/silk/compress/inflate.silk:1338–1360 · stdlib/silk/compress/inflate.silk:1453–1469 · stdlib/silk/compress/inflate.silk:1522–1540 · stdlib/silk/compress/inflate.silk:1541–1586 · stdlib/silk/compress/inflate.silk:1596–1620 · stdlib/silk/compress/inflate.silk:1630–1676 · stdlib/silk/compress/inflate.silk:1682–1704 · stdlib/silk/compress/inflate.silk:1694–1730 · stdlib/silk/compress/inflate.silk:1740–1828 · stdlib/silk/compress/inflate.silk:1830–1848 · stdlib/silk/compress/inflate.silk:1901–2063 · stdlib/silk/compress/inflate.silk:480–544 · stdlib/silk/compress/inflate.silk:915–1068 · stdlib/silk/compress/inflate.silk:1289–1335 · stdlib/silk/compress/inflate.silk:1338–1359 · stdlib/silk/compress/inflate.silk:1602–1609 · stdlib/silk/compress/inflate.silk:1616–1618 · stdlib/silk/compress/inflate.silk:1630–1828 · stdlib/silk/compress/inflate.silk:1545–1587 · stdlib/silk/compress/inflate.silk:1527–1538 · stdlib/silk/compress/inflate.silk:1592–1594 · stdlib/silk/compress/inflate.silk:1832–1849 · stdlib/silk/compress/inflate.silk:749–785 · stdlib/silk/compress/inflate.silk:1901–2064 · stdlib/silk/compress/inflate.silk:607–624 · stdlib/silk/compress/inflate.silk:1630–1653 · stdlib/silk/compress/inflate.silk:1458–1468 · stdlib/silk/compress/inflate.silk:1682–1695 · stdlib/silk/compress/inflate.silk:1707–1730 · stdlib/silk/compress/inflate.silk:1545–1567 · stdlib/silk/compress/inflate.silk:1289–1302 · stdlib/silk/compress/inflate.silk:1794–1807 · stdlib/silk/compress/inflate.silk:1816–1828 · stdlib/silk/compress/inflate.silk:749–766 · stdlib/silk/compress/inflate.silk:1025–1047 - stdlib/silk/simd/cpu.silk context
No teaching-coverage classification was supplied.
- stdlib/silk/encoding/endian.silk context
No teaching-coverage classification was supplied.
Limits of this explanation
- PR metadata is a recorded snapshot of the final merged PR head.
- Native Silk tests, SIMD execution and performance benchmarks were not run locally: the required Silk/Clang 22 toolchain is absent in the inspected environments.
- The independent CRC polynomial model passed 1,626 comparisons against binascii.crc32. It validates the folding math, not Silk compilation, pointer safety or SIMD lowering.
- codebase-memory coverage excludes integration, .github/scripts and replay fixture paths, and does not track Silk functions. Material explanations use pinned direct source; the manually added map relationships are bounded, not exhaustive.
- No measured before/after speedup is asserted. The changeset speed claims and PR title require machine-specific benchmark evidence.
- The PR description remains stale: final source uses a 10-bit literal root and includes corpus, changeset and regenerated reference artifacts.
- Resolved during the PR: commit 3a635a98fffe0c675faea588ac4e1b9f7c58b495 regenerated the checksum reference to match 64/128-byte folding. The earlier stale-reference finding is not open at this final head.
- Final PR-associated CI run 43427126253 succeeded, including Native selfhost cases, Incremental replay budgets, Focused Linux Silk and all four native release-archive platform checks. This is observed CI evidence, separate from local execution. The PR merged as a4ea55e44e7830819bd97ef1c3e3f982fa33ca6f.