Struct SliceFactory 

pub struct SliceFactory<const TABLE_MASK: usize> { /* private fields */ }

The factory: one BLAKE3 lane, one chain engine and their bookkeeping.

TABLE_MASK is the chain-lane area knob, passed through to SliceChainEngine: it chooses which AES rounds of the Haraka lane use table ROMs. See crate::chain_step.

Trait Implementations

impl<const TABLE_MASK: usize> Clone for SliceFactory<TABLE_MASK>

fn clone(&self) -> SliceFactory<TABLE_MASK>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const TABLE_MASK: usize> Debug for SliceFactory<TABLE_MASK>

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

Formats the value using the given formatter.

impl<const TABLE_MASK: usize> Default for SliceFactory<TABLE_MASK>

A factory at power-up: control state zeroed, data registers don’t-care.

fn default() -> Self

Builds every child in its default state.

impl<const TABLE_MASK: usize> Synchronous for SliceFactory<TABLE_MASK>

type S = (<SliceFactory<TABLE_MASK> as SynchronousDQ>::Q, <InlineCompressionPipeline as Synchronous>::S, <SliceChainEngine<TABLE_MASK> as Synchronous>::S, <ElementPacker<COMMITMENT_PREFIX> as Synchronous>::S, <ContextRams as Synchronous>::S, <SyncBRAM<[Bits<32>; 16], 6> as Synchronous>::S, <SyncBRAM<[Bits<8>; 64], { CTX_BITS + 5 }> as Synchronous>::S, <DFF<FactoryControl> as Synchronous>::S, <DFF<FactoryData> 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 TABLE_MASK: usize> SynchronousDQ for SliceFactory<TABLE_MASK>

type Q = SliceFactoryQ<TABLE_MASK>

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

type D = SliceFactoryD<TABLE_MASK>

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

impl<const TABLE_MASK: usize> SynchronousIO for SliceFactory<TABLE_MASK>

Connects SliceFactory to its port types and wiring kernel.

type I = SliceFactoryInput

Run control, configuration and the two external slot requests.

type O = SliceFactoryOutput

Cache writes, finished keys and slot results.

type Kernel = slice_factory_kernel<TABLE_MASK>

The factory’s wiring, slice_factory_kernel.