Struct IterativeKeccak 

pub struct IterativeKeccak { /* private fields */ }

A synthesizable Keccak-f[1600] engine that reuses one round cell.

Handshake and latency:

1. Present start = true and state while ready = true.
2. The request is captured on that rising edge.
3. Exactly 24 subsequent rising edges apply rounds 0 through 23.
4. After the round-23 edge, done = true, busy = false, and state is the completed result. done clears on the following edge.

Thus the hardware acceptance-edge to result-visible-edge latency is 24 clock periods. RHDL’s synchronous_sample() observes values immediately before each rising edge: its accepted-start sample has index S, busy occupies samples S+1..=S+24, and it first observes done at sample S+25. The extra sample index is an observation convention, not an extra datapath round or clock period.

A start asserted while busy is true is ignored. This baseline uses the 1,600-bit state uses a resetless datapath register. Only the round counter and handshake control have architectural reset; the state is ignored unless busy or done says it is valid.

Trait Implementations

impl Clone for IterativeKeccak

fn clone(&self) -> IterativeKeccak

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IterativeKeccak

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

Formats the value using the given formatter.

impl Default for IterativeKeccak

fn default() -> Self

Returns the “default value” for a type.

impl Synchronous for IterativeKeccak

type S = (<IterativeKeccak as SynchronousDQ>::Q, <NoResetDff<[Bits<64>; 25]> as Synchronous>::S, <DFF<Bits<5>> as Synchronous>::S, <DFF<bool> as Synchronous>::S, <DFF<bool> as Synchronous>::S)

The simulation state type. This type is used to represent the internal state of the circuit during simulation. It must be PartialEq and Clone. It holds whatever state is needed to compute the output of the circuit given it’s input. This state is typically auto-derived by the Synchronous derive macro, and it’s typically a struct containing the states of all the subcircuits, along with their last know outputs.

fn init(&self) -> Self::S

Initialize the simulation state. This method returns the initial state of the circuit for simulation. This is typically auto-derived by the Synchronous derive macro, and it typically initializes the states of all the subcircuits to their initial states.

fn children( &self, parent_scope: &ScopedName, ) -> impl Iterator<Item = Result<Descriptor<SyncKind>, RHDLError>>

Iterate over the child circuits of this circuit.

fn sim( &self, clock_reset: ClockReset, input: <Self as SynchronousIO>::I, state: &mut Self::S, ) -> <Self as SynchronousIO>::O

Simulate the circuit given it’s input, clock reset, and current state.

fn descriptor( &self, scoped_name: ScopedName, ) -> Result<Descriptor<SyncKind>, RHDLError>

Provides run time reflection of the circuit.

impl SynchronousDQ for IterativeKeccak

type Q = Q

The type of the internal data output from the children of the circuit.

type D = D

The type of the internal data input to the children of the circuit.

impl SynchronousIO for IterativeKeccak

type I = IterativeInput

The type of the input to the circuit.

type O = IterativeOutput

The type of the output from the circuit.

type Kernel = iterative_kernel

The type of the kernel function used to compute the output and feedback. The kernel function must be a synthesizable function that takes a clock and reset signal, the input signal, and the feedback signal Q, and produces the output signal and feedback signal D.