🥮 mooncakes.io
README

mokomoking2501/lockwire/sim does not have a README file

#
ArbitratedBusErrorState

source
pub(all) enum ArbitratedBusErrorState {
  ErrorActive
  ErrorPassive
  BusOff
  Recovering
} derive(Eq, 
Debug)

#
ArbitratedBusErrorState::code

source

#
ArbitratedBusErrorState::label

source

#
ArbitratedBusEventKind

source
pub(all) enum ArbitratedBusEventKind {
  ArbitrationWin
  ArbitrationLost
  FrameRx
  ErrorFrame
  AutoRetransmit
  BusOffEvent
  RecoveryEvent
  ReorderRejected
} derive(Eq, 
Debug)

#
ArbitratedBusEventKind::code

source

#
ArbitratedBusEventKind::direction

source

#
ArbitratedBusEventKind::label

source

#
ArbitratedBusFrame

source
pub(all) struct ArbitratedBusFrame {
  frame_id : Int
  sender : 
EndpointId
  target : 
EndpointId
  arbitration_id : Int
  payload_len : Int
  submitted_at : 
VTime
  label : String
} derive(Eq, 
Debug)

#
ArbitratedBusFrame::make

source
fn ArbitratedBusFrame::make(frame_id~ : Int, sender~ : 
EndpointId, target~ : 
EndpointId, arbitration_id~ : Int, payload_len~ : Int, submitted_at~ : 
VTime, label~ : String) -> ArbitratedBusFrame

#
ArbitratedBusFrameSlot

source
pub(all) struct ArbitratedBusFrameSlot {
  slot_id : Int
  start : 
VTime
  end : 
VTime
  winner_frame_id : Int
  winner_arbitration_id : Int
  loser_frame_ids : Array[Int]
  error_state_before : ArbitratedBusErrorState
  error_state_after : ArbitratedBusErrorState
  error_frame : Bool
  auto_retransmit : Bool
  bus_off : Bool
  recovered : Bool
  rejected_reorder_fault : Bool
} derive(Eq, 
Debug)

#
ArbitratedBusMedium

source
pub struct ArbitratedBusMedium {
  // private fields
}

#
ArbitratedBusMedium::arbitrate

source

#
ArbitratedBusMedium::frame_duration

source

#
ArbitratedBusMedium::new

source

#
ArbitratedBusMedium::offline_default

source
fn ArbitratedBusMedium::offline_default() -> ArbitratedBusMedium

#
ArbitratedBusMedium::profile

source

#
ArbitratedBusOfflineReport

source
pub(all) struct ArbitratedBusOfflineReport {
  profile_name : String
  seed : Int
  trace_event_count : Int
  replay_count : Int
  same_seed_stable : Bool
  digest : 
SimDigest
  slot_count : Int
  arbitration_count : Int
  arbitration_lost_count : Int
  delivered_count : Int
  error_frame_count : Int
  retransmit_count : Int
  bus_off_count : Int
  recovery_count : Int
  reorder_rejected_count : Int
  frame_level_duration_estimate : Bool
  live_io_evidence : Bool
  socketcan_vcan_evidence : Bool
  protocol_semantics_present : Bool
} derive(Eq, 
Debug)

#
ArbitratedBusOfflineReport::passes

source

#
ArbitratedBusOfflineRun

source
pub(all) struct ArbitratedBusOfflineRun {
  seed : Int
  profile : ArbitratedBusProfile
  slots : Array[ArbitratedBusFrameSlot]
  trace : 
TraceLog
  digest : 
SimDigest
  replay_count : Int
  arbitration_count : Int
  arbitration_lost_count : Int
  delivered_count : Int
  error_frame_count : Int
  retransmit_count : Int
  bus_off_count : Int
  recovery_count : Int
  reorder_rejected_count : Int
} derive(
Debug)

#
ArbitratedBusOfflineRun::passes

source

#
ArbitratedBusOfflineRun::timeline_text

source
fn ArbitratedBusOfflineRun::timeline_text(self : ArbitratedBusOfflineRun) -> String

#
ArbitratedBusProfile

source
pub(all) struct ArbitratedBusProfile {
  name : String
  bit_time_ns : Int64
  stuff_bit_divisor : Int
  tec_error_increment : Int
  bus_off_threshold : Int
  error_passive_threshold : Int
  supports_reorder : Bool
  frame_level_duration_estimate : Bool
  live_io_evidence : Bool
  socketcan_vcan_evidence : Bool
  protocol_semantics_present : Bool
} derive(Eq, 
Debug)

#
ArbitratedBusProfile::offline_default

source

#
BenchmarkSample

source
pub(all) struct BenchmarkSample {
  events_per_run : Int
  nominal_events_per_second : Int
  copies_per_frame : Int
} derive(Eq, 
Debug)

#
FabricBackgroundFlow

source
pub(all) struct FabricBackgroundFlow {
  flow_id : Int
  source : 
EndpointId
  target : 
EndpointId
  label : String
  frame_size_octets : Int
  period_ns : Int64
  load_class : FabricLoadClass
} derive(Eq, 
Debug)

#
FabricBackgroundFlow::is_background

source
fn FabricBackgroundFlow::is_background(self : FabricBackgroundFlow) -> Bool

#
FabricBackgroundFlow::is_rt

source
fn FabricBackgroundFlow::is_rt(self : FabricBackgroundFlow) -> Bool

#
FabricCapabilities

source
pub(all) struct FabricCapabilities {
  single_initiator : Bool
  bounded_delay : Bool
  total_order_delivery : Bool
  partitionable : Bool
  clock_sync_guarantee : Bool
  background_load : Bool
} derive(Eq, 
Debug)

#
FabricCapabilities::minimal_partitionable

source
fn FabricCapabilities::minimal_partitionable() -> FabricCapabilities

#
FabricCapabilities::unlocks_partition_faults

source
fn FabricCapabilities::unlocks_partition_faults(self : FabricCapabilities) -> Bool

#
FabricDelivery

source

#
FabricLoadClass

source
pub(all) enum FabricLoadClass {
  ProfinetRtLoad
  BackgroundBestEffortLoad
  AcyclicRecordLoad
  NetloadPlaceholderLoad
} derive(Eq, 
Debug)

#
FabricLoadClass::label

source
fn FabricLoadClass::label(self : FabricLoadClass) -> String

#
FabricLoadProfile

source
pub(all) struct FabricLoadProfile {
  name : String
  flows : Array[FabricBackgroundFlow]
  netload_semantics : String
  complete_switched_fabric : Bool
  real_netload_evidence : Bool
  art_pi_certification_evidence : Bool
} derive(Eq, 
Debug)

#
FabricLoadProfile::background_load_enabled

source
fn FabricLoadProfile::background_load_enabled(self : FabricLoadProfile) -> Bool

#
FabricLoadProfile::declared_fixture_octets

source
fn FabricLoadProfile::declared_fixture_octets(self : FabricLoadProfile) -> Int

#
FabricLoadProfileRun

source
pub(all) struct FabricLoadProfileRun {
  seed : Int
  profile : FabricLoadProfile
  fabric_event_count : Int
  rt_event_count : Int
  background_event_count : Int
  netload_placeholder_event_count : Int
  trace : 
TraceLog
  digest : 
SimDigest
} derive(
Debug)

#
FabricLoadProfileRun::passes

source
fn FabricLoadProfileRun::passes(self : FabricLoadProfileRun) -> Bool

#
FabricNode

source
pub(all) struct FabricNode {
  id : 
EndpointId
  name : String
} derive(Eq, 
Debug)

#
FabricNode::new

source

#
FabricPartitionScript

source
pub(all) struct FabricPartitionScript {
  seed : Int
  partition_at : 
VTime
  heal_at : 
VTime
  groups : Array[PortGroup]
} derive(Eq, 
Debug)

#
FabricPartitionScript::minimal

source
fn FabricPartitionScript::minimal(seed~ : Int) -> FabricPartitionScript

#
FabricRun

source
pub(all) struct FabricRun {
  seed : Int
  capabilities : FabricCapabilities
  script : FabricPartitionScript
  deliveries : Array[FabricDelivery]
  trace : 
TraceLog
  digest : 
SimDigest
  partition_count : Int
  heal_count : Int
  drop_count : Int
  late_count : Int
  reorder_count : Int
} derive(
Debug)

#
FabricRun::timeline_text

source
fn FabricRun::timeline_text(self : FabricRun) -> String

#
FrameWindow

source
pub(all) struct FrameWindow {
  node_id : 
EndpointId
  offset : Int
  length : Int
  before_digest : Int
  after_digest : Int
} derive(Eq, 
Debug)

#
MinimalFabric

source
pub(all) struct MinimalFabric {
  nodes : Array[FabricNode]
  base_delay : 
Duration
  partitioned : Bool
  groups : Array[PortGroup]
} derive(
Debug)

#
MinimalFabric::can_deliver

source

#
MinimalFabric::heal

source
fn MinimalFabric::heal(self : MinimalFabric) -> Unit

#
MinimalFabric::is_partitioned

source
fn MinimalFabric::is_partitioned(self : MinimalFabric) -> Bool

#
MinimalFabric::isolate

source
fn MinimalFabric::isolate(self : MinimalFabric, groups : Array[PortGroup]) -> Unit

#
MinimalFabric::new

source

#
PortGroup

source
pub(all) struct PortGroup {
  name : String
  members : Array[
EndpointId]
} derive(Eq, 
Debug)

#
PortGroup::contains

source

#
PortGroup::new

source

#
ProfinetRtLoadTraceReport

source
pub(all) struct ProfinetRtLoadTraceReport {
  trace_event_count : Int
  replay_count : Int
  same_seed_stable : Bool
  digest : 
SimDigest
  rt_event_count : Int
  background_event_count : Int
  netload_placeholder_event_count : Int
  complete_switched_fabric : Bool
  real_netload_evidence : Bool
  art_pi_certification_evidence : Bool
} derive(Eq, 
Debug)

#
ProfinetRtLoadTraceReport::passes

source

#
SegmentHop

source

#
SegmentLine

source
pub(all) struct SegmentLine {
  name : String
  nodes : Array[SegmentNode]
} derive(Eq, 
Debug)

#
SegmentLine::new

source
fn SegmentLine::new(name~ : String, nodes~ : Array[SegmentNode]) -> SegmentLine

#
SegmentLine::run

source
fn SegmentLine::run(self : SegmentLine, payload~ : Bytes, start~ : 
VTime, seed~ : Int) -> SegmentRun

#
SegmentNode

source
pub(all) struct SegmentNode {
  id : 
EndpointId
  name : String
  port_delay : 
Duration
  window_offset : Int
  window_length : Int
  rewrite_value : Byte?
} derive(Eq, 
Debug)

#
SegmentNode::new

source

#
SegmentNode::with_window_write

source
fn SegmentNode::with_window_write(self : SegmentNode, offset~ : Int, length~ : Int, value~ : Byte) -> SegmentNode

#
SegmentRun

source
pub(all) struct SegmentRun {
  seed : Int
  line_name : String
  hops : Array[SegmentHop]
  final_payload : Bytes
  total_delay : 
Duration
  digest : 
SimDigest
} derive(Eq, 
Debug)

#
SegmentRun::timeline_text

source
fn SegmentRun::timeline_text(self : SegmentRun) -> String

#
SimRun

source

#
SwitchedFabricFrameRecord

source
pub(all) struct SwitchedFabricFrameRecord {
  record_id : Int
  flow_id : Int
  flow_label : String
  source : 
EndpointId
  target : 
EndpointId
  output_port : 
PortId
  priority : Int
  frame_size_octets : Int
  enqueue_time : 
VTime
  depart_time : 
VTime?
  arrive_time : 
VTime?
  serialization_delay : 
Duration
  queue_occupancy_before : Int
  queue_occupancy_after : Int
  jitter_ns : Int64
  dropped : Bool
  reordered : Bool
  background : Bool
} derive(Eq, 
Debug)

#
SwitchedFabricIrtPhaseKind

source
pub(all) enum SwitchedFabricIrtPhaseKind {
  IrtGreenPhase
  IrtRedPhase
} derive(Eq, 
Debug)

#
SwitchedFabricIrtPhaseKind::label

source

#
SwitchedFabricIrtPhaseWindow

source
pub(all) struct SwitchedFabricIrtPhaseWindow {
  start_ns : Int64
  end_ns : Int64
  phase : SwitchedFabricIrtPhaseKind
} derive(Eq, 
Debug)

#
SwitchedFabricOfflineProfile

source
pub(all) struct SwitchedFabricOfflineProfile {
  name : String
  queue_discipline : SwitchedFabricQueueDiscipline
  ports : Array[SwitchedFabricPort]
  flows : Array[SwitchedFabricTrafficFlow]
  reorder_window_ns : Int64
  complete_switched_fabric : Bool
  live_io_evidence : Bool
  real_netload_evidence : Bool
} derive(Eq, 
Debug)

#
SwitchedFabricOfflineProfile::background_flow_count

source
fn SwitchedFabricOfflineProfile::background_flow_count(self : SwitchedFabricOfflineProfile) -> Int

#
SwitchedFabricOfflineReport

source
pub(all) struct SwitchedFabricOfflineReport {
  profile_name : String
  seed : Int
  queue_discipline : SwitchedFabricQueueDiscipline
  trace_event_count : Int
  replay_count : Int
  same_seed_stable : Bool
  digest : 
SimDigest
  delivered_count : Int
  dropped_count : Int
  reordered_count : Int
  jittered_count : Int
  background_frame_count : Int
  netload_octets : Int
  max_queue_occupancy_octets : Int
  complete_switched_fabric : Bool
  live_io_evidence : Bool
  real_netload_evidence : Bool
} derive(Eq, 
Debug)

#
SwitchedFabricOfflineReport::passes

source

#
SwitchedFabricOfflineRun

source
pub(all) struct SwitchedFabricOfflineRun {
  seed : Int
  profile : SwitchedFabricOfflineProfile
  frames : Array[SwitchedFabricFrameRecord]
  trace : 
TraceLog
  digest : 
SimDigest
  replay_count : Int
  delivered_count : Int
  dropped_count : Int
  reordered_count : Int
  jittered_count : Int
  background_frame_count : Int
  total_payload_octets : Int
  total_background_octets : Int
  netload_octets : Int
  max_queue_occupancy_octets : Int
} derive(
Debug)

#
SwitchedFabricOfflineRun::passes

source

#
SwitchedFabricOfflineRun::timeline_text

source
fn SwitchedFabricOfflineRun::timeline_text(self : SwitchedFabricOfflineRun) -> String

#
SwitchedFabricPort

source
pub(all) struct SwitchedFabricPort {
  port_id : 
PortId
  endpoint : 
EndpointId
  name : String
  capacity_octets_per_tick : Int
  queue_limit_octets : Int
  base_delay : 
Duration
} derive(Eq, 
Debug)

#
SwitchedFabricPort::new

source
fn SwitchedFabricPort::new(port_id~ : 
PortId, endpoint~ : 
EndpointId, name~ : String, capacity_octets_per_tick~ : Int, queue_limit_octets~ : Int, base_delay~ : 
Duration) -> SwitchedFabricPort

#
SwitchedFabricQosIrtFrameRecord

source
pub(all) struct SwitchedFabricQosIrtFrameRecord {
  record_id : Int
  flow_id : Int
  flow_label : String
  output_port : 
PortId
  priority : Int
  enqueue_time : 
VTime
  effective_enqueue_time : 
VTime
  depart_time : 
VTime?
  arrive_time : 
VTime?
  phase_at_enqueue : SwitchedFabricIrtPhaseKind
  held_by_red_phase : Bool
  dropped_by_red_phase : Bool
  released_in_green_phase : Bool
  queue_occupancy_before : Int
  queue_occupancy_after : Int
  frame_size_octets : Int
  background : Bool
} derive(Eq, 
Debug)

#
SwitchedFabricQosIrtProfile

source
pub(all) struct SwitchedFabricQosIrtProfile {
  name : String
  queue_discipline : SwitchedFabricQueueDiscipline
  ports : Array[SwitchedFabricPort]
  flows : Array[SwitchedFabricTrafficFlow]
  phase_table : Array[SwitchedFabricIrtPhaseWindow]
  red_phase_drop_priority_floor : Int
  complete_switched_fabric : Bool
  live_io_evidence : Bool
  real_netload_evidence : Bool
  real_irt_evidence : Bool
} derive(Eq, 
Debug)

#
SwitchedFabricQosIrtReport

source
pub(all) struct SwitchedFabricQosIrtReport {
  profile_name : String
  seed : Int
  queue_discipline : SwitchedFabricQueueDiscipline
  trace_event_count : Int
  replay_count : Int
  same_seed_stable : Bool
  digest : 
SimDigest
  delivered_count : Int
  dropped_count : Int
  red_phase_hold_count : Int
  red_phase_drop_count : Int
  green_phase_release_count : Int
  strict_priority_selection_count : Int
  netload_octets : Int
  high_priority_before_low_priority : Bool
  complete_switched_fabric : Bool
  live_io_evidence : Bool
  real_netload_evidence : Bool
  real_irt_evidence : Bool
} derive(Eq, 
Debug)

#
SwitchedFabricQosIrtReport::passes

source

#
SwitchedFabricQosIrtRun

source
pub(all) struct SwitchedFabricQosIrtRun {
  seed : Int
  profile : SwitchedFabricQosIrtProfile
  frames : Array[SwitchedFabricQosIrtFrameRecord]
  trace : 
TraceLog
  digest : 
SimDigest
  replay_count : Int
  delivered_count : Int
  dropped_count : Int
  red_phase_hold_count : Int
  red_phase_drop_count : Int
  green_phase_release_count : Int
  strict_priority_selection_count : Int
  netload_octets : Int
  high_priority_before_low_priority : Bool
} derive(
Debug)

#
SwitchedFabricQosIrtRun::passes

source

#
SwitchedFabricQosIrtRun::timeline_text

source
fn SwitchedFabricQosIrtRun::timeline_text(self : SwitchedFabricQosIrtRun) -> String

#
SwitchedFabricQueueDiscipline

source
pub(all) enum SwitchedFabricQueueDiscipline {
  FifoQueue
  StrictPriorityQueue
} derive(Eq, 
Debug)

#
SwitchedFabricQueueDiscipline::label

source

#
SwitchedFabricTrafficFlow

source
pub(all) struct SwitchedFabricTrafficFlow {
  flow_id : Int
  source : 
EndpointId
  target : 
EndpointId
  label : String
  priority : Int
  frame_size_octets : Int
  start_ns : Int64
  period_ns : Int64
  burst_count : Int
  background : Bool
} derive(Eq, 
Debug)

#
SwitchedFabricTrafficFlow::is_background

source
fn SwitchedFabricTrafficFlow::is_background(self : SwitchedFabricTrafficFlow) -> Bool

#
arbitrated_bus_offline_report

source
fn arbitrated_bus_offline_report(seed? : Int) -> ArbitratedBusOfflineReport

#
p2p_benchmark_report

source

#
package_id

source
fn package_id() -> String

#
profinet_rt_load_profile

source
fn profinet_rt_load_profile(seed? : Int) -> FabricLoadProfile

#
profinet_rt_load_profile_report

source
fn profinet_rt_load_profile_report(seed? : Int) -> ProfinetRtLoadTraceReport

#
profinet_rt_load_trace_fixture

source
fn profinet_rt_load_trace_fixture(seed? : Int) -> 
TraceLog

#
run_arbitrated_bus_offline

source
fn run_arbitrated_bus_offline(seed? : Int) -> ArbitratedBusOfflineRun

#
run_fabric_partition_heal

source
fn run_fabric_partition_heal(seed~ : Int) -> FabricRun

#
run_p2p_demo

source
fn run_p2p_demo(seed~ : Int) -> SimRun

#
run_profinet_rt_load_profile

source
fn run_profinet_rt_load_profile(seed? : Int) -> FabricLoadProfileRun

#
run_segment_toy

source
fn run_segment_toy(seed~ : Int) -> SegmentRun

#
run_switched_fabric_offline

source
fn run_switched_fabric_offline(seed? : Int) -> SwitchedFabricOfflineRun

#
run_switched_fabric_qos_irt_offline

source
fn run_switched_fabric_qos_irt_offline(seed? : Int) -> SwitchedFabricQosIrtRun

#
same_seed_digest_stable

source
fn same_seed_digest_stable(seed~ : Int) -> Bool

#
switched_fabric_offline_profile

source
fn switched_fabric_offline_profile(seed? : Int) -> SwitchedFabricOfflineProfile

#
switched_fabric_offline_report

source
fn switched_fabric_offline_report(seed? : Int) -> SwitchedFabricOfflineReport

#
switched_fabric_qos_irt_profile

source
fn switched_fabric_qos_irt_profile(seed? : Int) -> SwitchedFabricQosIrtProfile

#
switched_fabric_qos_irt_report

source
fn switched_fabric_qos_irt_report(seed? : Int) -> SwitchedFabricQosIrtReport

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io