kr580 1.0.0

Desktop KR580VM80 / Intel 8080 emulator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::backend::{AppCommand, AppError, AppEvent, AppSnapshot, Emulator, RunMode};
use crossbeam_channel::{Receiver, Sender, after, never, select, tick};
use std::thread;
use std::time::{Duration, Instant};

pub struct EmulatorHandle {
    command_tx: Sender<AppCommand>,
    event_rx: Receiver<AppEvent>,
}

impl EmulatorHandle {
    pub fn send(&self, command: AppCommand) -> Result<(), AppError> {
        self.command_tx
            .send(command)
            .map_err(|_| AppError::WorkerStopped)
    }

    pub fn drain_events(&self) -> Vec<AppEvent> {
        self.event_rx.try_iter().collect()
    }

    /// Blocks until at least one `StateChanged` is observed (or the
    /// timeout elapses). Without this, UI handlers that read
    /// `self.snapshot` after dispatch race the channel.
    pub fn drain_until_state_change(&self, timeout: std::time::Duration) -> Vec<AppEvent> {
        let deadline = std::time::Instant::now() + timeout;
        let mut events = Vec::new();
        loop {
            for event in self.event_rx.try_iter() {
                let is_state_change = matches!(event, AppEvent::StateChanged(_));
                events.push(event);
                if is_state_change {
                    return events;
                }
            }
            let remaining = deadline.saturating_duration_since(std::time::Instant::now());
            if remaining.is_zero() {
                return events;
            }
            match self.event_rx.recv_timeout(remaining) {
                Ok(event) => {
                    let is_state_change = matches!(event, AppEvent::StateChanged(_));
                    events.push(event);
                    if is_state_change {
                        return events;
                    }
                }
                Err(_) => return events,
            }
        }
    }

    pub fn command_sender(&self) -> Sender<AppCommand> {
        self.command_tx.clone()
    }

    pub fn event_receiver(&self) -> Receiver<AppEvent> {
        self.event_rx.clone()
    }
}

pub fn spawn_emulator() -> EmulatorHandle {
    let (command_tx, command_rx) = crossbeam_channel::unbounded::<AppCommand>();
    let (event_tx, event_rx) = crossbeam_channel::unbounded::<AppEvent>();
    thread::spawn(move || run_worker(command_rx, event_tx));
    EmulatorHandle {
        command_tx,
        event_rx,
    }
}

pub fn initial_snapshot() -> AppSnapshot {
    Emulator::default().snapshot()
}

fn run_worker(command_rx: Receiver<AppCommand>, event_tx: Sender<AppEvent>) {
    let mut emulator = Emulator::default();
    let initial = emulator.snapshot();
    let mut published_network = initial.devices.network.clone();
    let mut published_printer = initial.devices.printer.clone();
    publish(&event_tx, AppEvent::StateChanged(Box::new(initial)));
    let device_poll = tick(Duration::from_millis(50));
    let mut next_run_at: Option<Instant> = None;
    loop {
        let run_tick: Receiver<Instant> = if let Some(deadline) = next_run_at {
            after(deadline.saturating_duration_since(Instant::now()))
        } else {
            never()
        };
        select! {
            recv(command_rx) -> command => {
                let Ok(command) = command else { break };
                let shutdown = matches!(command, AppCommand::Shutdown);
                for event in emulator.handle_command(command) {
                    if let AppEvent::StateChanged(snapshot) = &event {
                        published_network = snapshot.devices.network.clone();
                        published_printer = snapshot.devices.printer.clone();
                    }
                    publish(&event_tx, event);
                }
                next_run_at = schedule_run_tick(&emulator);
                if shutdown {
                    break;
                }
            }
            recv(run_tick) -> _ => {
                for event in emulator.tick() {
                    if let AppEvent::StateChanged(snapshot) = &event {
                        published_network = snapshot.devices.network.clone();
                        published_printer = snapshot.devices.printer.clone();
                    }
                    publish(&event_tx, event);
                }
                next_run_at = schedule_run_tick(&emulator);
            }
            recv(device_poll) -> _ => {
                emulator.bus_mut().printer.poll();
                let snapshot = emulator.snapshot();
                if snapshot.devices.network != published_network
                    || snapshot.devices.printer != published_printer
                {
                    published_network = snapshot.devices.network.clone();
                    published_printer = snapshot.devices.printer.clone();
                    publish(&event_tx, AppEvent::StateChanged(Box::new(snapshot)));
                }
            }
        }
    }
}

fn schedule_run_tick(emulator: &Emulator) -> Option<Instant> {
    emulator.is_running().then(|| {
        let deadline = match emulator.run_mode() {
            RunMode::Paced => emulator.step_interval(),
            RunMode::Burst { slice } => slice,
        };
        Instant::now() + deadline
    })
}

fn publish(event_tx: &Sender<AppEvent>, event: AppEvent) {
    if event_tx.send(event).is_err() {
        tracing::debug!("UI event receiver dropped");
    }
}

pub const MIN_STEP_INTERVAL: Duration = Duration::from_millis(1);