Module benchmark

Expand description

On-chip U280 benchmark control for the SHA-256 WOTS signer.

This module keeps the benchmark workload, one-time seed allocation, signer handshakes, frame validation, counters, checksum, and AXI4-Lite control in Rust/RHDL. The generated Vitis-facing Verilog wrapper is wiring only: it maps named ports to the packed AxiLiteBenchmarkInput and AxiLiteBenchmarkOutput fields using RHDL Digital metadata.

§One-time-key boundary

A launch snapshots a 192-bit test nonce and a 64-bit base index. Job j receives the private seed nonce || big_endian(base + j). A nonzero batch is accepted only when base + batch fits in 64 bits, so the half-open range [base, base + batch) is injective and a representable next index remains. The continuously loaded kernel advances its configured base atomically when the launch is accepted. That is not durable allocation: software must reserve and persist the nonce/range before every launch, including warmups and retries, and must restore a never-before-used range after reset or reprogramming.

This is an on-chip compute benchmark. It does not include PCIe, HBM, DDR, or result-DMA traffic, and its 512-bit XOR fold is an observability checksum, not a cryptographic authenticator.

Structs§

AxiLiteBenchmarkConfig: Mutable launch configuration.
AxiLiteBenchmarkControl: Resettable AXI channel ownership and interrupt state.
AxiLiteBenchmarkInput: Packed AXI4-Lite slave inputs consumed by the RHDL kernel adapter.
AxiLiteBenchmarkKernelWithSigner: AXI4-Lite-only benchmark kernel over an injected signer component.
AxiLiteBenchmarkOutput: Packed AXI4-Lite slave outputs produced by the RHDL kernel adapter.
BenchmarkChecksumInput: Input to the 512-bit observability fold.
BenchmarkCounterAuditInput: Counter/ownership audit after all current-cycle admissions and terminals.
BenchmarkCounterAuditOutput: Counter/ownership invariants and exact healthy terminal predicate.
BenchmarkEngineControl: Resettable benchmark ownership and counter state.
BenchmarkEngineData: Resettable run data and retained results.
BenchmarkEngineInput: Configuration offered to the on-chip benchmark engine.
BenchmarkEngineOutput: Complete benchmark status retained for AXI4-Lite reads.
BenchmarkEngineWithSigner: On-chip workload generator, injected signer driver, checker, and counter bank.
BenchmarkFrameValidationInput: Input to the benchmark’s independent frame checker.
BenchmarkJobMaterial: Deterministic private seed and already-hashed benchmark message.
BenchmarkLaunchValidationInput: Launch-range validation input.
BenchmarkLaunchValidationOutput: Launch-range validation result.
BenchmarkLiveJob: One exact live-job ownership record in the three-cluster/four-context signer.
BenchmarkReadDecodeInput: Read-decode input assembled entirely from RHDL state.
BenchmarkReadDecodeOutput: Read-decode result.
BenchmarkScoreboardAdmissionInput: Candidate signer admission offered to the exact ownership scoreboard.
BenchmarkScoreboardAdmissionOutput: Allocation decision for one accepted signer start.
BenchmarkScoreboardAuditInput: Input to the live-job scoreboard integrity audit.
BenchmarkScoreboardAuditOutput: Integrity and population summary for the live-job scoreboard.
BenchmarkScoreboardLookupInput: Lookup request for a data or error completion owner.
BenchmarkScoreboardLookupOutput: Exact live-owner lookup result.
ExternalModularSha256SignerTop: Behavioral production signer with an unresolved external HDL definition.
InlineBenchmarkSigner: Copyable adapter that expands an ordinary SignerTop into its parent.

Constants§

AXI_RESP_OKAY: AXI4-Lite OKAY response.
AXI_RESP_SLVERR: AXI4-Lite SLVERR response.
BENCHMARK_ABI_VERSION: Stable register-map version: major 1, minor 0.
BENCHMARK_AXI_ADDR_BITS: AXI4-Lite address width used by the named Vitis wrapper.
BENCHMARK_AXI_RANGE_BYTES: AXI4-Lite register aperture in bytes.
BENCHMARK_CHECKSUM_WORDS: Number of 32-bit words in the observable 512-bit checksum.
BENCHMARK_FAULT_ADMISSION: A signer admission pulse violated the benchmark ownership contract.
BENCHMARK_FAULT_COUNTER: A completion counter exceeded the accepted batch contract.
BENCHMARK_FAULT_ERROR: A transferred error completion had invalid identity or handshake metadata.
BENCHMARK_FAULT_FRAME: A transferred output beat violated canonical control or frame identity.
BENCHMARK_FAULT_NONE: No structural fault.
BENCHMARK_FAULT_SIGNER: The wrapped signer reported a sticky structural fault.
BENCHMARK_LIVE_JOB_SLOTS: Exact number of live signer contexts represented by the ownership scoreboard.
BENCHMARK_NONCE_WORDS: Number of 32-bit words in the test-only 192-bit nonce prefix.
BENCHMARK_REJECT_INDEX_OVERFLOW: base + batch required a 65th bit and was rejected.
BENCHMARK_REJECT_NONE: No launch rejection.
BENCHMARK_REJECT_ZERO_BATCH: A zero-length batch was rejected.
BENCHMARK_SIGNER_TOP_MODULE: Canonical separately generated production signer module used by Phase A.
REG_ABI_VERSION: Read-only ABI version.
REG_ACCEPTED_LO: Accepted-job counter, low word; high word follows.
REG_AP_CTRL: Standard Vitis control register.
REG_BASE_HI: Current base/next-index high word.
REG_BASE_LO: Current base/next-index low word.
REG_BATCH: Requested batch size.
REG_BEATS_LO: Transferred-beat counter, low word; high word follows.
REG_CHECKSUM_0: First checksum word; sixteen consecutive words end at 0x0cc.
REG_CODES: Low byte is structural fault code; next byte is last rejection code.
REG_COMPLETED_LO: Successful-frame completion counter, low word; high word follows.
REG_COMPLETION_SPAN_LO: Last-minus-first successful completion span, low word.
REG_ELAPSED_LO: Active run cycles, low word; high word follows.
REG_ERRORS_LO: Identified error-completion counter, low word; high word follows.
REG_FIRST_COMPLETION_LO: Zero-based cycle of the first successful final beat, low word.
REG_GIE: Global interrupt enable.
REG_IER: Per-event interrupt enable (done, fault).
REG_ISR: Toggle-on-write interrupt status (done, fault).
REG_LAST_COMPLETION_LO: Zero-based cycle of the last successful final beat, low word.
REG_NONCE_0: First nonce-prefix word; words are consecutive through 0x02c.
REG_PAYLOAD_CYCLES_LO: Inclusive first-to-last transferred-payload span, low word.
REG_RUN_BASE_HI: Base index latched by the most recently accepted launch, high word.
REG_RUN_BASE_LO: Base index latched by the most recently accepted launch, low word.
REG_STATUS: Packed busy/fault/rejection status.

Traits§

BenchmarkSignerComponent: Exact synchronous signer interface accepted by the benchmark engine.

Functions§

axi_lite_benchmark_kernel: State transition for AxiLiteBenchmarkKernelWithSigner.
benchmark_checksum_kernel: XOR-fold one transferred 512-bit beat plus its job/cluster/beat identity.
benchmark_counter_audit_kernel: Cross-check counters against the exact live-job scoreboard.
benchmark_engine_kernel: State transition for BenchmarkEngineWithSigner.
benchmark_frame_is_canonical_kernel: Independently validate canonical framing and batch identity.
benchmark_job_material_kernel: Construct one deterministic benchmark job.
benchmark_launch_validation_kernel: Reject zero batches and any reservation whose exclusive end needs 65 bits.
benchmark_merge_write_kernel: Merge one AXI write word according to byte strobes.
benchmark_read_decode_kernel: Decode the stable benchmark register map.
benchmark_scoreboard_admission_kernel: Allocate the first free capacity slot in the admitted cluster.
benchmark_scoreboard_audit_kernel: Audit cluster partitioning and count live ownership in one linear pass.
benchmark_scoreboard_lookup_kernel: Match a returned (job_id, cluster) against exactly one live owner.

Type Aliases§

AxiLiteBenchmarkKernel: Const-generic inline-signer AXI kernel retained for source compatibility.
BenchmarkEngine: Const-generic inline-signer benchmark engine retained for source compatibility.
ModularWotsSha256AxiLiteBenchmarkKernel: Production AXI4-Lite benchmark linked to the external RHDL signer top.
ModularWotsSha256BenchmarkEngine: Production benchmark engine linked to the separately generated signer top.
WotsSha256AxiLiteBenchmarkKernel: Production inline-lane AXI4-Lite benchmark kernel.
WotsSha256BenchmarkEngine: Production inline-lane benchmark engine.