Struct ProtocolState 

pub struct ProtocolState<const N: usize, const G: usize> {

    pub st: b6,
    pub sub: b2,
    pub args: Args,
    pub n: b5,
    pub id: b5,
    pub f: b5,
    pub quorum: b5,
    pub qbase: b24,
    pub mb_prepare: b32,
    pub mb_will_cert: b32,
    pub mb_will_commit: b32,
    pub mb_commit: b32,
    pub mb_certify_valid: b32,
    pub mb_certify: b32,
    pub mb_vc: b32,
    pub mb_vc_valid: b32,
    pub mb_newview: b32,
    pub mb_newview_valid: b32,
    pub view: b32,
    pub leader: b5,
    pub stop: bool,
    pub seq: b32,
    pub slot: b4,
    pub m: b32,
    pub local_wait: b32,
    pub issued: bool,
    pub bc_done: bool,
    pub wissued: bool,
    pub second: bool,
    pub prop: [b32; G],
    pub prop_valid: [bool; G],
    pub enq: b4,
    pub out_sent: bool,
    pub rem_sent: bool,
    pub slowed: bool,
    pub share_beat: b5,
    pub checked: [bool; N],
    pub good: b5,
    pub peer: b5,
    pub reading: bool,
    pub vbeats: b2,
    pub voted_k: b32,
    pub voted_m: b32,
    pub voted_phase: b2,
    pub rec: b5,
    pub rec_k: [b32; N],
    pub rec_m: [b32; N],
    pub rec_ok: [bool; N],
    pub nv_k: b32,
    pub nv_m: b32,
    pub status: Status,
    pub slot_start: b32,
}

The controller’s registers. N is the most replicas the build supports, G the window.

Fields

st: b6

State (one of st).

sub: b2

Submachine (one of sub), for the host.

args: Args

The run’s arguments.

n: b5

Replicas in this run.

id: b5

This replica.

f: b5

Faults tolerated, (n − 1) / 2.

quorum: b5

Quorum, 2f + 1.

qbase: b24

First queue pair, (n − 1) · id (peer j at rank j or j − 1).

mb_prepare: b32

Mailbox bases (words).

mb_will_cert: b32

will_cert.

mb_will_commit: b32

will_commit.

mb_commit: b32

commit.

mb_certify_valid: b32

certify_valid.

mb_certify: b32

certify.

mb_vc: b32

vc.

mb_vc_valid: b32

vc_valid.

mb_newview: b32

newview.

mb_newview_valid: b32

newview_valid.

view: b32

Current view.

leader: b5

Its leader.

stop: bool

The run must stop at the end of this cycle (time up, a bound or a fault).

seq: b32

The slot’s sequence number (k = seq + 1).

slot: b4

seq mod G.

m: b32

The slot’s value, once its prepare is seen.

local_wait: b32

Polls without progress.

issued: bool

This state’s broadcast was started.

bc_done: bool

This state’s broadcast is done; its local record is next.

wissued: bool

This state’s local write was started.

second: bool

Unused (kept for the register layout).

prop: [b32; G]

Proposals waiting, one per window slot.

prop_valid: [bool; G]

Which window slots hold a proposal.

enq: b4

Window slot the next proposal goes to.

out_sent: bool

Decision beats sent: output, remoteUpdate.

rem_sent: bool

remoteUpdate sent.

slowed: bool

This slot took the slow path.

share_beat: b5

Signature beats received (share RAM write address).

checked: [bool; N]

Peers whose share was checked this slot.

good: b5

Valid shares counted (ours included).

peer: b5

The peer being verified.

reading: bool

The share read was started.

vbeats: b2

Verify beats sent.

voted_k: b32

What this replica voted for in the slot: k, m, phase (0 none, 1 will_cert, 2 will_commit or commit).

voted_m: b32

Its m.

voted_phase: b2

Its phase.

rec: b5

Record being read.

rec_k: [b32; N]

The records: reported k.

rec_m: [b32; N]

Reported m.

rec_ok: [bool; N]

The record is for this view and slot and reports a vote.

nv_k: b32

The chosen (k, m) (k = 0: none).

nv_m: b32

Its m.

status: Status

Measurements for the host.

slot_start: b32

Cycle the current slot started.

Implementations

impl<const N: usize, const G: usize> ProtocolState<N, G>

pub fn idle() -> Self

Power-on: stopped, nothing known.

Trait Implementations

impl<const N: usize, const G: usize> Clone for ProtocolState<N, G>

fn clone(&self) -> ProtocolState<N, G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, const G: usize> Debug for ProtocolState<N, G>

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

Formats the value using the given formatter.

impl<const N: usize, const G: usize> Digital for ProtocolState<N, G>

const BITS: usize

Associated constant that gives the total number of bits needed to represent the value.

fn static_kind() -> Kind

Returns the [Kind] (run time type descriptor) of the value as a static method

fn bin(self) -> Box<[BitX]>

Returns the binary representation of the value as a vector of [BitX].

fn dont_care() -> Self

Returns a “don’t care” value for the type.

fn bits() -> usize

Returns the number of bits needed to represent the value.

fn kind(&self) -> Kind

Returns the [Kind] (run time type descriptor) of the value.

fn typed_bits(self) -> TypedBits

Returns the value as a [TypedBits], which includes both the bits and the kind.

fn discriminant(self) -> TypedBits

Returns the discriminant of the value as a [TypedBits].

fn variant_kind(self) -> Kind

Returns the [Kind] of the variant if the value is an enum with variants.

fn binary_string(self) -> String

Returns the binary representation of the value as a string of ‘0’, ‘1’, and ‘X’.

impl<const N: usize, const G: usize> PartialEq for ProtocolState<N, G>

fn eq(&self, other: &ProtocolState<N, G>) -> 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<const N: usize, const G: usize> Copy for ProtocolState<N, G>

impl<const N: usize, const G: usize> StructuralPartialEq for ProtocolState<N, G>