Struct RoundPipeline 

pub struct RoundPipeline<const ROUNDS: usize>
where
    W<ROUNDS>: BitWidth,
{ /* private fields */ }

A resetless, fully registered prefix of the 64-round SHA-256 pipeline.

ROUNDS = 64 is the complete round datapath. It accepts one prepared PipelineWord on every rising edge and produces the corresponding final working state after 64 registered round transfers. There is no backpressure; invalid bubbles are represented solely by the resettable valid pipeline.

The data registers use [NoResetDff]. Only the 64 valid bits use the stock resettable [DFF]. A resetless opaque 32-bit tag follows every token. The input chaining value is intentionally absent from this internal token; the complete lane::CompressionLane aligns it in synchronous memory.

Trait Implementations

impl<const ROUNDS: usize> Clone for RoundPipeline<ROUNDS>

where W<ROUNDS>: BitWidth,

fn clone(&self) -> RoundPipeline<ROUNDS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const ROUNDS: usize> Debug for RoundPipeline<ROUNDS>

where W<ROUNDS>: BitWidth,

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

Formats the value using the given formatter.

impl<const ROUNDS: usize> Default for RoundPipeline<ROUNDS>

where W<ROUNDS>: BitWidth,

fn default() -> Self

Returns the “default value” for a type.

impl<const ROUNDS: usize> Synchronous for RoundPipeline<ROUNDS>

where W<ROUNDS>: BitWidth,

type S = (<RoundPipeline<ROUNDS> as SynchronousDQ>::Q, <[NoResetDff<RoundState>; ROUNDS] as Synchronous>::S, <[NoResetDff<Bits<32>>; ROUNDS] as Synchronous>::S, <[DFF<bool>; ROUNDS] 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<const ROUNDS: usize> SynchronousDQ for RoundPipeline<ROUNDS>

where W<ROUNDS>: BitWidth,

type Q = Q<ROUNDS>

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

type D = D<ROUNDS>

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

impl<const ROUNDS: usize> SynchronousIO for RoundPipeline<ROUNDS>

where W<ROUNDS>: BitWidth,

type I = PipelineWord

The type of the input to the circuit.

type O = PipelineWord

The type of the output from the circuit.

type Kernel = round_pipeline_kernel<ROUNDS>

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.