wots_rhdl/

lib.rs

//! Profile-specific `HashSigsRS` WOTS+ schedulers and synthesizable RHDL tops.
//!
//! This crate is the hardware protocol layer of the workspace. It turns one
//! already-hashed 32-byte message and one one-time private seed into a canonical
//! fused signature/public-key stream, and it provides a separate public-data
//! verifier for the SHA-256 profile. Hash primitives live in `keccak-rhdl` and
//! `sha256-rhdl`; profile-safe host values and the independent software oracle
//! live in `hashsigs-types` and `hashsigs-reference`.
//!
//! # Start with the security boundary
//!
//! `HashSigsRS` uses `n = 32`, `w = 16`, and 67 hash chains. Its inputs and
//! encodings have several non-negotiable properties:
//!
//! - **Every private seed and derived private key is one-time.** Reusing either
//!   value to sign another message can expose enough chain positions to permit a
//!   forgery. The RHDL interfaces consume bytes, but they cannot know whether a
//!   caller has submitted those bytes before. Durable one-time-use enforcement
//!   is a system responsibility.
//! - The message input is already a 32-byte digest. The caller owns application
//!   prehashing, collision resistance, and domain separation.
//! - Serialized keys, signatures, and 512-bit frames contain no profile tag. A
//!   protocol must authenticate the selected build profile out of band.
//! - The custom shared-mask/address construction is not XMSS, SLH-DSA, FIPS
//!   205, or a many-time signature system. This crate does not claim the proof
//!   of a standardized parameter set or an independent cryptographic audit.
//! - Resetless secret/data registers are meaningful only while separately reset
//!   ownership bits say so. Architectural overwrite is not physical
//!   zeroization, remanence resistance, or side-channel evidence.
//!
//! # Profiles and implemented operations
//!
//! Profiles are different Rust types and different hardware build targets;
//! there is no runtime hash-profile mux.
//!
//! | Profile | Compatibility | RHDL signing | RHDL verification |
//! |---|---|---|---|
//! | `LEGACY_KECCAK` | Byte-compatible with pinned `HashSigsRS`; legacy Keccak-256 `0x01` padding, not SHA3-256 | [`legacy::LegacyFusedPrivateSeedEngine`] and [`legacy::LegacyFusedPrivateKeyEngine`] | Not implemented; use the software oracle for legacy verification |
//! | `HASHSIGS_SHA256_GENERIC_V1` | Deliberately incompatible with legacy keys and signatures | [`top::Sha256SignerTop`] | [`verify::top::Sha256VerifierTop`] |
//!
//! The private-key legacy ingress exists for pinned upstream vectors. The
//! production SHA signer accepts a private seed. The SHA verifier consumes only
//! public material. No legacy Keccak verifier top exists in this crate.
//!
//! All cryptographic datapaths are authored in Rust/RHDL. The modular signer
//! and verifier aliases use a typed unresolved compression-lane leaf so the
//! exact separately generated RHDL lane can be linked by an external HDL tool;
//! they are not invitations to replace the lane with handwritten cryptographic
//! RTL. Tcl, XDC, testbenches, and a future board shell remain outside this
//! crate's cryptographic implementation boundary.
//!
//! # Signing work and selected topology
//!
//! Fused private-seed signing always advances every chain through all fifteen
//! transitions. A signature segment is captured when the chain reaches the
//! message/checksum digit, while the final value becomes a public-key endpoint:
//!
//! ```text
//! private seed -> private key
//!                       +-> public seed -> 16 masks
//!                       +-> 67 secret PRFs
//!                             -> 67 secret hashes
//!                             -> 67 x 15 chain hashes
//!                                  +-> capture 67 signature segments
//!                                  +-> hash 67 endpoints into the public key
//! ```
//!
//! Under `HASHSIGS_SHA256_GENERIC_V1`, this graph contains exactly 1,258
//! SHA-256 compression tasks. [`engine::SingleContextWorkEngine`] represents one
//! dependency-tracked job. Four contexts share one exact-latency compression
//! lane inside [`cluster::LaneLocalCluster`], and the production top replicates
//! that complete cluster three times:
//!
//! ```text
//! top::Sha256SignerTop
//!   +-- cluster 0: 4 contexts + 1 SHA-256 lane
//!   +-- cluster 1: 4 contexts + 1 SHA-256 lane
//!   +-- cluster 2: 4 contexts + 1 SHA-256 lane
//!   +-- registered, frame-locked 3-to-1 data merge
//!   +-- independent registered error merge
//! ```
//!
//! The twelve contexts overlap independent dependency graphs; each context can
//! issue at most once every two cycles because request construction includes a
//! synchronous-memory prefetch. Complete tags carry local context, task class,
//! task coordinates, and generation through the lane. Job IDs remain outside
//! cryptographic state.
//!
//! [`sequencer::SingleContextSequencer`] and [`fabric::ShaTransportFabric`] are
//! retained foundations from an earlier serial/central nine-context
//! architecture. They are useful focused control oracles, but neither is
//! instantiated by the selected three-cluster production signer.
//!
//! # Signer interface and output frame
//!
//! [`top::SignerTopInput`] and [`top::SignerTopOutput`] are the production SHA
//! signer contract:
//!
//! | Signal group | Contract |
//! |---|---|
//! | `start_valid`, `start_ready`, `private_seed`, `message`, `job_id` | Accept one new one-time job when valid and ready are both true |
//! | `output_valid`, `output_ready`, `output` | Transfer one registered 512-bit result beat when valid and ready are both true |
//! | `error_valid`, `error_ready`, `error` | Transfer one independent identified error completion |
//! | `fault` | Sticky structural/transport failure; shared reset is required before accepting more trusted work |
//!
//! Once admitted, a job owns a context until either its final successful beat is
//! captured or its identified error is released. Output backpressure is a
//! correctness contract: a stalled beat and its metadata remain stable. Frames
//! never interleave. The successful stream is 2,208 bytes in 35 beats:
//!
//! | Beat | Low 32 bytes | High 32 bytes | `keep` / `last` |
//! |---:|---|---|---|
//! | 0 through 32 | Signature segment `2b` | Signature segment `2b + 1` | All bytes valid; not last |
//! | 33 | Signature segment 66 | Public seed | All bytes valid; not last |
//! | 34 | Public-key endpoint hash | Zero padding | Low half valid; last |
//!
//! [`framing::pack_fused_output`] and [`framing::unpack_fused_output`] are the
//! independent host framing oracles. [`cluster::LaneLocalResultFramer`] reserves
//! output capacity before exposing a result and releases local context credit
//! only after ownership has moved safely to the next registered stage.
//!
//! Shared reset flushes all valid, allocation, request, result, and ownership
//! state and suppresses transfers on the reset edge. Resetless wide data is
//! ignored while its resettable valid bit is clear. A signer transport fault
//! invalidates immediately preceding and outstanding work until shared reset;
//! consumers must not treat a coincident data/error payload as trusted merely
//! because its bytes are present.
//!
//! # SHA-256 verification
//!
//! Verification receives `signature`, `public_seed`, `public_key_hash`, and the
//! 32-byte message digest as one exact 2,240-byte frame. It advances each
//! signature segment only from its message digit to chain position fifteen,
//! hashes all endpoints, and compares all 256 bits of the resulting public-key
//! hash.
//!
//! Let `S` be the sum of `15 - digit` across the 64 message digits and let
//! `h(S)` be the sum of the three hexadecimal checksum digits. Real verifier
//! chain work is `S + 45 - h(S)`, ranging from 45 to 990 hashes. Including 16
//! masks and 34 endpoint-stream blocks, a SHA verifier job emits between 95 and
//! 1,040 compression tasks. Bypassed positions are idle state preservation, not
//! hidden hash work.
//!
//! The selected verifier mirrors the signer hierarchy: four
//! [`verify::sha::VerifySingleContextSha`] contexts share one lane inside
//! [`verify::cluster::VerifierCluster`], and
//! [`verify::top::Sha256VerifierTop`] replicates three clusters. The ingress
//! frame contains exactly 35 full-valid beats:
//!
//! | Beats | Bytes |
//! |---:|---|
//! | 0 through 32 | Signature segments 0 through 65 |
//! | 33 | Signature segment 66 followed by the public seed |
//! | 34 | Public-key endpoint hash followed by the message digest |
//!
//! [`verify::top::VerifierTopInput`] uses a ready/valid stream and an independent
//! `result_ready`. [`verify::top::VerifierTopOutput`] returns one registered
//! [`verify::cluster::VerifyResult`] containing the opaque job ID, a `verified`
//! decision, and an error code. Nonzero framing, transport, or audit errors
//! always force `verified` false.
//!
//! Verifier transport is fail closed. A 64-entry expected-tag delay line checks
//! the lane's exact 64-cycle return contract. Missing, extra, mistimed, swapped,
//! malformed, unowned, or rejected tokens poison the owning cluster. The top
//! registers that fault, aborts peers without a combinational sibling loop, and
//! drains every already-accepted identity as a nonzero error. New admission and
//! lane launch remain blocked until shared reset.
//!
//! # Evidence vocabulary and current status
//!
//! Evidence from one level never implies the next:
//!
//! | Tier | What it establishes | What it does not establish |
//! |---:|---|---|
//! | 1. Rust/RHDL source simulation | Source behavior and modeled cycle contracts | Generated RTL, mapping, timing, route, or hardware |
//! | 2. Generated-Verilog simulation | Lowering equivalence for exercised traces | Formal equivalence, synthesis, timing, route, or card behavior |
//! | 3. U280 synthesis | Mapping and utilization estimates | Routed timing or hardware throughput |
//! | 4. U280 placement and routing | Routed utilization and achieved timing for the constrained design | Card/runtime behavior |
//! | 5. Reserved-card execution | Measured behavior for the loaded artifact and workload | Other commits, constraints, or workloads |
//!
//! Current production-signer evidence reaches tier 2. A sustained
//! generated-Verilog trace measured one 23,121-cycle aggregate interval spanning
//! 48 results, or 481.6875 cycles/result. Normalizing that simulated aggregate
//! interval at 250 MHz gives 519,008.693 signatures/second. This is arithmetic
//! normalization, not evidence that the RTL synthesizes, fits, routes, meets 250
//! or 300 MHz, or
//! executes at that rate on a U280. The exact trace assumes an always-ready
//! output; arbitrary stalls remain a correctness property, not a throughput
//! guarantee.
//!
//! The production SHA verifier reaches tier 1. Its complete three-cluster source
//! simulation admits twelve worst-case jobs, accepts and routes exactly 12,480
//! SHA tasks, checks all results under stalls, and reaches quiescence. Its
//! modular descriptor also has a bounded unresolved-skeleton check. It does not
//! yet have linked generated-Verilog simulation, synthesis, timing, route, or
//! card evidence.
//!
//! Legacy engines match the pinned upstream vectors in source/RHDL tests. That
//! compatibility result does not establish synthesis, physical zeroization,
//! side-channel behavior, timing, or card execution. No U280 utilization,
//! timing-closure, routed, or hardware-throughput claim is made by this crate.
//!
//! # Newcomer reading order
//!
//! Follow the active path from protocol bytes to composed hardware:
//!
//! 1. [`crate::framing`] and [`crate::verify::framing`] define the exact output
//!    and verification-input bytes before control logic is introduced.
//! 2. [`crate::digits`] explains message/checksum digits; [`crate::blocks`]
//!    defines every fixed SHA-256 preimage and byte-order boundary; and
//!    [`crate::tag`] defines the sole 32-bit lane-tag encoding.
//! 3. [`crate::engine`] is one active SHA signer context. Read its dependency,
//!    reset, request-prefetch, response-validation, and secret-ownership
//!    contracts before changing scheduling.
//! 4. [`crate::cluster`] composes four contexts, one compression lane, and the
//!    local result framer. [`crate::top`] composes exactly three such clusters
//!    and owns only narrow global admission/data/error merges.
//! 5. For verification, read [`crate::verify`] and then its `framing`, `tasks`,
//!    `sha`, `transport`, `cluster`, and `top` modules in that order.
//! 6. For byte-compatible signing, read [`crate::legacy`] after `keccak-rhdl`.
//!    It is a separate serial engine, not a SHA signer mode.
//! 7. Read [`crate::tasks`], [`crate::sequencer`], and [`crate::fabric`] when
//!    auditing the serial task oracle or historical central-fabric experiments;
//!    do not infer the production topology from them.
//!
//! # Source, test, and evidence map
//!
//! | Concern | Source | Focused tests / evidence |
//! |---|---|---|
//! | Profile-safe bytes and software semantics | `hashsigs-types`, `hashsigs-reference` | Upstream compatibility vectors and randomized differential tests |
//! | Legacy signer | [`crate::legacy`] | `tests/legacy.rs` |
//! | SHA block/digit/tag semantics | [`crate::blocks`], [`crate::digits`], [`crate::tag`] | `tests/tag_and_blocks.rs`, `tests/digits.rs` |
//! | One SHA signer context | [`crate::engine`] | `tests/engine.rs` |
//! | Active signer cluster and top | [`crate::cluster`], [`crate::top`] | `tests/cluster.rs`, `tests/top.rs`, `tests/top_full.rs` |
//! | SHA verifier | [`crate::verify`] | `tests/verify_framing.rs` through `tests/verify_top_full.rs` |
//! | Generated RTL and immutable manifests | `rhdl-gen` | `crates/rhdl-gen/tests/cli.rs` and date-stamped files under `evidence/rtl` |
//! | U280 boundary | `fpga/u280` | Staged source manifest plus Vivado reports; none may be inferred from simulation |
//!
//! # Contributor workflow
//!
//! Start at the smallest owning layer and preserve its public contracts:
//!
//! 1. Add or update an independent host oracle before changing a cryptographic
//!    kernel, framing rule, task count, or tag encoding.
//! 2. Run the focused leaf test, then its context, cluster, and top tests. A
//!    change is not integrated merely because its final digest matches; exact
//!    task cardinality, identity, latency, reset flushing, fault behavior, and
//!    backpressure also matter.
//! 3. Keep `LEGACY_KECCAK` and `HASHSIGS_SHA256_GENERIC_V1` as distinct types and
//!    build targets. Never introduce a runtime profile mux or silently reinterpret
//!    serialized bytes.
//! 4. Generate Verilog through `rhdl-gen`; do not patch generated cryptographic
//!    RTL. Any unresolved modular skeleton must be linked with the exact
//!    separately generated RHDL lane before an external parse or simulation.
//! 5. Record negative results and promote claims only with matching source/RTL
//!    provenance. A logical storage count is not mapped area, an output interval
//!    is not clock closure, and synthesis is not a routed or card result.
//!
//! On memory-constrained hosts, use one Cargo job and one test thread. Expensive
//! ignored gates document their own memory limits and evidence boundaries; they
//! should never be folded into an ordinary quick test run.
#![forbid(unsafe_code)]

pub mod benchmark;
pub mod blocks;
pub mod cluster;
pub mod digits;
pub mod engine;
pub mod fabric;
pub mod framing;
pub mod legacy;
pub mod sequencer;
pub mod tag;
pub mod tasks;
pub mod top;
pub mod verify;

pub use benchmark::{
    AXI_RESP_OKAY, AXI_RESP_SLVERR, AxiLiteBenchmarkConfig, AxiLiteBenchmarkControl,
    AxiLiteBenchmarkInput, AxiLiteBenchmarkKernel, AxiLiteBenchmarkOutput, BENCHMARK_ABI_VERSION,
    BENCHMARK_AXI_ADDR_BITS, BENCHMARK_AXI_RANGE_BYTES, BENCHMARK_CHECKSUM_WORDS,
    BENCHMARK_FAULT_ADMISSION, BENCHMARK_FAULT_COUNTER, BENCHMARK_FAULT_ERROR,
    BENCHMARK_FAULT_FRAME, BENCHMARK_FAULT_NONE, BENCHMARK_FAULT_SIGNER, BENCHMARK_LIVE_JOB_SLOTS,
    BENCHMARK_NONCE_WORDS, BENCHMARK_REJECT_INDEX_OVERFLOW, BENCHMARK_REJECT_NONE,
    BENCHMARK_REJECT_ZERO_BATCH, BenchmarkChecksumInput, BenchmarkCounterAuditInput,
    BenchmarkCounterAuditOutput, BenchmarkEngine, BenchmarkEngineControl, BenchmarkEngineData,
    BenchmarkEngineInput, BenchmarkEngineOutput, BenchmarkFrameValidationInput,
    BenchmarkJobMaterial, BenchmarkLaunchValidationInput, BenchmarkLaunchValidationOutput,
    BenchmarkLiveJob, BenchmarkReadDecodeInput, BenchmarkReadDecodeOutput,
    BenchmarkScoreboardAdmissionInput, BenchmarkScoreboardAdmissionOutput,
    BenchmarkScoreboardAuditInput, BenchmarkScoreboardAuditOutput, BenchmarkScoreboardLookupInput,
    BenchmarkScoreboardLookupOutput, ModularWotsSha256AxiLiteBenchmarkKernel,
    ModularWotsSha256BenchmarkEngine, REG_ABI_VERSION, REG_ACCEPTED_LO, REG_AP_CTRL, REG_BASE_HI,
    REG_BASE_LO, REG_BATCH, REG_BEATS_LO, REG_CHECKSUM_0, REG_CODES, REG_COMPLETED_LO,
    REG_COMPLETION_SPAN_LO, REG_ELAPSED_LO, REG_ERRORS_LO, REG_FIRST_COMPLETION_LO, REG_GIE,
    REG_IER, REG_ISR, REG_LAST_COMPLETION_LO, REG_NONCE_0, REG_PAYLOAD_CYCLES_LO, REG_RUN_BASE_HI,
    REG_RUN_BASE_LO, REG_STATUS, WotsSha256AxiLiteBenchmarkKernel, WotsSha256BenchmarkEngine,
    axi_lite_benchmark_kernel, benchmark_checksum_kernel, benchmark_counter_audit_kernel,
    benchmark_engine_kernel, benchmark_frame_is_canonical_kernel, benchmark_job_material_kernel,
    benchmark_launch_validation_kernel, benchmark_merge_write_kernel, benchmark_read_decode_kernel,
    benchmark_scoreboard_admission_kernel, benchmark_scoreboard_audit_kernel,
    benchmark_scoreboard_lookup_kernel,
};
pub use blocks::{
    ChainBlockInput, EndpointPairInput, HashBytes, HashWords, PrfBlockInput, SecretDataInput,
    ShaBlock, chain_block_kernel, endpoint_final_block_kernel, endpoint_pair_block_kernel,
    hash_words_to_bytes_kernel, initial_state_words_kernel, prf_block_kernel,
    private_seed_block_kernel, secret_data_block_kernel, secret_padding_block_kernel,
    sha256_32_byte_block_kernel,
};
pub use cluster::{
    AssembleLaneLocalBeatInput, CompressionLaneComponent, LANE_LOCAL_BEAT_BUFFER_DEPTH,
    LANE_LOCAL_CONTEXTS, LANE_LOCAL_OUTPUT_BEATS, LaneFramerContextInput, LaneIssueControlInput,
    LaneIssueControlOutput, LaneIssueInput, LaneIssueOutput, LaneLocalBeat, LaneLocalCluster,
    LaneLocalClusterControl, LaneLocalClusterInput, LaneLocalClusterOutput, LaneLocalFramerControl,
    LaneLocalResultFramer, LaneLocalResultFramerInput, LaneLocalResultFramerOutput,
    LaneResponseRouteOutput, LaneResultSelection, LaneStartSelection,
    ModularSha256LaneLocalCluster, Sha256LaneLocalCluster, assemble_lane_local_beat_kernel,
    issue_lane_request_kernel, lane_issue_control_kernel, lane_local_cluster_kernel,
    lane_local_result_framer_kernel, route_lane_response_kernel, select_lane_result_kernel,
    select_lane_start_kernel,
};

pub use digits::{
    MessageBytes, MessageDigitArray, SignatureCaptureInput, message_digits_kernel,
    signature_capture_kernel,
};
pub use engine::{
    CONTEXT_LOGICAL_RAM_BITS, ContextEngineInput, ContextEngineOutput, ENGINE_SEGMENTS,
    EngineControl, MASK_STORAGE_BITS, PRIVATE_KEY_CONSUMERS, PUBLIC_KEY_FOCUS_BLOCKS,
    PrepareRequestInput, SEGMENT_GROUPS, SEGMENT_STAGE_CHAIN_FIRST, SEGMENT_STAGE_CHAIN_LAST,
    SEGMENT_STAGE_ENDPOINT, SEGMENT_STAGE_PRF, SEGMENT_STAGE_SECRET_DATA,
    SEGMENT_STAGE_SECRET_PADDING, SIGNATURE_STORAGE_BITS, STATE_STORAGE_BITS, SegmentGroups,
    SegmentSelection, SegmentStages, SignatureBanks, SignatureBanksInput, SignatureBanksOutput,
    SingleContextWorkEngine, exclude_segment_groups_kernel, increment_segment_group_kernel,
    prepare_request_kernel, public_key_endpoints_ready_kernel, segment_bit_kernel,
    segment_required_mask_kernel, segment_task_fields_kernel,
    select_public_key_focus_segment_kernel, select_ready_segment_kernel, set_segment_bit_kernel,
    signature_banks_kernel, single_context_work_engine_kernel, state_pair_exclusion_kernel,
    union_segment_groups_kernel, wake_segments_for_mask_kernel,
};
pub use fabric::{
    CONTEXT_COUNT, IssueControlInput, IssueControlOutput, IssueInput, IssueOutput, LANE_COUNT,
    ResponseControlInput, ResponseControlOutput, ResponseRouterInput, ResponseRouterOutput,
    ShaTransportFabric, TransportInput, TransportOutput, host_issue_oracle,
    host_response_router_oracle, issue_control_kernel, issue_requests_kernel,
    response_control_kernel, route_responses_kernel, sha_transport_fabric_kernel,
};
pub use framing::{
    FUSED_OUTPUT_BEATS, FusedBeat, FusedFrame, OUTPUT_BEAT_BYTES, OutputFrameError,
    pack_fused_output, unpack_fused_output,
};
pub use legacy::{
    LEGACY_CHAIN_STEPS, LEGACY_ENDPOINT_BLOCKS, LEGACY_FUSED_OUTPUT_BEATS,
    LEGACY_FUSED_PERMUTATIONS, LEGACY_FUSED_PRIVATE_KEY_PERMUTATIONS, LEGACY_HASH_BYTES,
    LEGACY_MASK_COUNT, LegacyBeatBytes, LegacyChainStateInput, LegacyEndpointBlockInput,
    LegacyFusedBeat, LegacyFusedInput, LegacyFusedOutput, LegacyFusedPrivateKeyEngine,
    LegacyFusedPrivateKeyInput, LegacyFusedPrivateSeedEngine, LegacyHashLanes, LegacyMaskStore,
    LegacyOutputBeatInput, LegacyPrfStateInput, LegacyPrivateSeedBytes, LegacySecretStateInput,
    LegacySegmentStore, legacy_bytes_to_lanes_kernel, legacy_chain_state_kernel,
    legacy_digest_lanes_kernel, legacy_endpoint_block_state_kernel,
    legacy_fused_private_key_kernel, legacy_fused_private_seed_kernel, legacy_hash32_state_kernel,
    legacy_output_beat_kernel, legacy_prf_state_kernel, legacy_secret_state_kernel,
};
pub use sequencer::{
    HardwareTaskCounts, SequencerInput, SequencerOutput, SingleContextSequencer,
    decode_hardware_counts_kernel, encode_hardware_counts_kernel, single_context_sequencer_kernel,
};
pub use tag::{
    DecodedTaskTag, TagFields, TaskKind, TaskTagError, decode_tag_kernel, decode_task_tag,
    encode_tag_kernel, tag_is_well_formed_kernel,
};
pub use tasks::{TaskAudit, TaskCounts, TaskTraceError, audit_task_trace, canonical_task_trace};
pub use top::{
    GlobalBeatValidationInput, GlobalErrorMerge, GlobalErrorMergeControl, GlobalErrorMergeInput,
    GlobalErrorMergeOutput, GlobalErrorSource, GlobalFrameMerge, GlobalFrameMergeControl,
    GlobalFrameMergeInput, GlobalFrameMergeOutput, GlobalFrameSource, GlobalLaneSelection,
    ModularSha256SignerTop, SIGNER_CLUSTER_COUNT, SIGNER_FRAME_BEATS, Sha256SignerTop,
    SignerErrorCompletion, SignerOutputBeat, SignerTop, SignerTopControl, SignerTopInput,
    SignerTopOutput, global_beat_is_canonical_kernel, global_error_merge_kernel,
    global_frame_merge_kernel, select_global_lane_kernel, signer_top_kernel,
};
pub use verify::*;

/// Maximum average simulated cycles per fused private-seed result in the sustained gate.
///
/// The gate measures one aggregate interval spanning 48 completed results; it
/// does not assert that every individual inter-completion interval is at most
/// this value. At the 250 MHz normalization frequency, an average of 500
/// simulated cycles per result corresponds to 500,000 results per second. This
/// is a generated-RTL simulation acceptance threshold, not evidence of an
/// achievable clock, synthesis timing, route timing, or hardware throughput.
pub const MAX_AVERAGE_CYCLES_PER_RESULT: usize = 500;