🥮 mooncakes.io

    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 issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io