Struct Build 

pub struct Build {
    pub slices: u32,
    pub uram_per_lane: u32,
    pub bram_per_lane: u32,
}

One buildable configuration.

It is exactly the set of compile-time choices that change cost and speed: the DSIG_SLICES and DSIG_SBOX_PLACEMENT build variables. Build::command prints the command that builds it.

Fields

slices: u32

Slices (2, 4 or 8).

Each slice is one complete signer; more slices means more signatures per second and proportionally more LUTs.

uram_per_lane: u32

S-boxes per lane in UltraRAM.

Count out of SBOXES_PER_LANE; the same number in every lane.

bram_per_lane: u32

S-boxes per lane in block RAM.

Count out of SBOXES_PER_LANE; two share one BRAM18 (a quarter of a tile each). uram_per_lane + bram_per_lane never exceeds 494 in builds made by Build::fill.

Implementations

impl Build

pub const fn lut_only(slices: u32) -> Build

All S-boxes in LUTs.

The baseline build: no RAM placement, closest to the routed measurement.

pub fn fill(slices: u32) -> Build

The most S-boxes per lane that spare UltraRAM, then spare block RAM, can hold.

UltraRAM is filled first, block RAM takes the remainder. Both keep RAM_HEADROOM free.

pub fn fill_within(slices: u32, uram: f64, bram36: f64) -> Build

Like Build::fill, but only uram UltraRAMs and bram36 BRAM36 tiles are available in total (the share the chip planner gives DSig).

Why: on a shared chip DSig gets part of the RAM, not the whole device. Filling the whole device’s spare RAM would make every partial share look too small.

pub fn all() -> Vec<Build>

The all-LUT and the RAM-filled build of every slice count.

Six candidates in total: the two ends of the placement range for each of the three slice counts. In this model, moving more S-boxes into free RAM only lowers LUTs, so the partial placements in between are not listed.

pub fn features(self) -> String

A short name: the slice feature plus the placement, if any.

Used as the row label in sweep, for example slices-2 or slices-4 uram=… bram=….

pub fn command(self) -> String

The command that builds it.

So a reader can copy the planner’s answer straight into a shell.

pub fn resources(self) -> Resources

Predicted kernel resources.

The cost model, one line per resource:

lut    = slices × SLICE_LUT − lanes × (placed × 32 − loader) + Ed25519 + glue
bram36 = slices × SLICE_BRAM36 + lanes × bram_per_lane / 2 + Ed25519 + glue
uram   = slices × 72 + lanes × uram_per_lane
dsp    = Ed25519 only

lanes = slices × 3, placed = uram_per_lane + bram_per_lane, and loader is LOADER_LUT when the lane has UltraRAM S-boxes.

pub fn fits(self, lut_percent: f64) -> bool

Whether the build fits a LUT budget (percent of LUT_CAP) and the device’s block RAM, UltraRAM and DSPs.

lut_percent is a percentage, so 100.0 means the full 420,000-LUT cap. The RAM and DSP limits are the whole device, because the cap only applies to LUTs.

pub fn signatures_per_second(self, mhz: f64) -> (f64, &'static str)

Predicted steady-state signatures per second at mhz, and the stage that limits it.

The engine is a pipeline of three stages that all must keep up, so the slowest one sets the rate:

 slices ─────────▶ certificates ─────────▶ frame writes
 SLICES × f / 68    128 × f / 895           SLICES × 64 B × f / (26 × 64 B)
         └──────────────── min(...) × STEADY_STATE_EFFICIENCY ──▶ sig/s

The returned name ("slices", "certificates" or "frame writes") tells you which stage to improve next.

Trait Implementations

impl Clone for Build

fn clone(&self) -> Build

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Build

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Build

fn eq(&self, other: &Build) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Build

impl Eq for Build

impl StructuralPartialEq for Build