use std::collections::VecDeque;
use kermit_proto::codec::SOH;
use kermit_proto::time::{Duration, Instant};
use saturnus_core::Machine;
pub const TURNAROUND: Duration = Duration::from_millis(200);
pub const MIN_WAIT: Duration = Duration::from_millis(10);
pub const IDLE_WAIT: Duration = Duration::from_millis(100);
pub const TIMEOUT: Duration = Duration::from_secs(6);
pub const RETRIES: u32 = 3;
pub const MAX_BUSY: Duration = Duration::from_secs(600);
pub const STEP: Duration = Duration::from_millis(1);
pub const QUIET: Duration = Duration::from_millis(4);
pub const NAK_STEP: Duration = Duration::from_millis(10);
pub const SERVER_CAP: Duration = Duration::from_secs(15);
pub const FINISH_SETTLE: Duration = Duration::from_millis(2_500);
pub const READ_CAP_MESSAGE: &str = "emulated time limit reached while waiting for the calculator";
pub trait Line {
fn cycles(&self) -> u64;
fn clock_hz(&self) -> u32;
fn run_cycles(&mut self, n: u64) -> crate::Result<()>;
fn serial_drain(&mut self) -> Vec<u8>;
fn serial_push(&mut self, bytes: &[u8]);
fn serial_pending(&self) -> usize;
fn is_shutdown(&self) -> bool;
}
impl Line for Machine {
fn cycles(&self) -> u64 {
Machine::cycles(self)
}
fn clock_hz(&self) -> u32 {
self.model().clock_hz()
}
fn run_cycles(&mut self, n: u64) -> crate::Result<()> {
Ok(Machine::run_cycles(self, n)?)
}
fn serial_drain(&mut self) -> Vec<u8> {
Machine::serial_drain(self)
}
fn serial_push(&mut self, bytes: &[u8]) {
Machine::serial_push(self, bytes);
}
fn serial_pending(&self) -> usize {
Machine::serial_pending(self)
}
fn is_shutdown(&self) -> bool {
Machine::is_shutdown(self)
}
}
pub fn cycles<L: Line + ?Sized>(m: &L, d: Duration) -> u64 {
let c = d.as_nanos() * u128::from(m.clock_hz()) / 1_000_000_000;
u64::try_from(c).unwrap_or(u64::MAX)
}
pub fn opens_transaction(packet: &[u8]) -> bool {
let start = packet.iter().position(|&b| b == SOH);
start
.and_then(|i| packet.get(i + 3))
.is_some_and(|t| matches!(t, b'S' | b'R' | b'I' | b'G' | b'C'))
}
fn reply_started(rx: &[u8]) -> bool {
rx.iter()
.enumerate()
.any(|(i, &b)| b == SOH && rx.get(i + 3).is_some_and(|&t| t != b'N'))
}
fn holds_nak(rx: &[u8]) -> bool {
rx.windows(4).any(|w| w[0] == SOH && w[3] == b'N')
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WireStep {
Quiet(Vec<u8>),
Deadline(Vec<u8>),
Sent,
Pending,
}
#[derive(Clone, Debug)]
enum Job {
Idle,
Write { until: u64, packet: Vec<u8> },
Read {
deadline: Instant,
busy: Duration,
last_byte: u64,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ReadCap {
Off,
Pending(Duration),
Sent(Duration),
Armed(u64),
}
#[derive(Debug)]
pub struct Wire {
rx: VecDeque<u8>,
start: Instant,
idle: Duration,
job: Job,
read_cap: ReadCap,
read_cap_hit: bool,
}
impl Default for Wire {
fn default() -> Self {
Wire::new()
}
}
impl Wire {
pub fn new() -> Wire {
Wire {
rx: VecDeque::new(),
start: Instant::now(),
idle: Duration::ZERO,
job: Job::Idle,
read_cap: ReadCap::Off,
read_cap_hit: false,
}
}
pub fn now(&self) -> Instant {
self.start + self.idle
}
pub fn run<L: Line + ?Sized>(&mut self, m: &mut L, n: u64) -> crate::Result<bool> {
m.run_cycles(n.max(1))?;
let out = m.serial_drain();
self.rx.extend(&out);
Ok(!out.is_empty())
}
pub fn discard<L: Line + ?Sized>(&mut self, m: &mut L) {
self.rx.clear();
m.serial_drain();
self.job = Job::Idle;
}
pub fn nak_step<L: Line + ?Sized>(&mut self, m: &mut L) -> crate::Result<bool> {
self.run(m, cycles(m, NAK_STEP))?;
if holds_nak(self.rx.make_contiguous()) {
self.rx.clear();
return Ok(true);
}
Ok(false)
}
pub fn wait_for_nak<L: Line + ?Sized>(
&mut self,
m: &mut L,
cap: Duration,
) -> crate::Result<bool> {
let end = m.cycles().saturating_add(cycles(m, cap));
while m.cycles() < end {
if self.nak_step(m)? {
return Ok(true);
}
}
self.rx.clear();
Ok(false)
}
pub fn set_read_cap(&mut self, d: Option<Duration>) {
self.read_cap = d.map_or(ReadCap::Off, ReadCap::Pending);
}
pub fn take_read_cap_hit(&mut self) -> bool {
std::mem::take(&mut self.read_cap_hit)
}
fn read_cap_exceeded<L: Line + ?Sized>(&mut self, m: &L) -> bool {
let now = m.cycles();
match self.read_cap {
ReadCap::Sent(d) if m.serial_pending() == 0 => {
self.read_cap = ReadCap::Armed(now.saturating_add(cycles(m, d)));
}
ReadCap::Armed(_) if reply_started(self.rx.make_contiguous()) => {
self.read_cap = ReadCap::Off;
}
ReadCap::Armed(end) if now >= end => {
self.read_cap_hit = true;
return true;
}
_ => {}
}
false
}
pub fn start_write<L: Line + ?Sized>(&mut self, m: &mut L, packet: Vec<u8>) -> bool {
if opens_transaction(&packet) {
let until = m.cycles().saturating_add(cycles(m, TURNAROUND));
self.job = Job::Write { until, packet };
false
} else {
self.push(m, &packet);
true
}
}
fn push<L: Line + ?Sized>(&mut self, m: &mut L, packet: &[u8]) {
m.serial_push(packet);
if let ReadCap::Pending(d) = self.read_cap {
self.read_cap = ReadCap::Sent(d);
}
}
pub fn start_read<L: Line + ?Sized>(&mut self, m: &L, deadline: Instant) {
self.job = Job::Read {
deadline,
busy: Duration::ZERO,
last_byte: m.cycles(),
};
}
pub fn step<L: Line + ?Sized>(&mut self, m: &mut L, budget: u64) -> crate::Result<WireStep> {
let stop = m.cycles().saturating_add(budget);
loop {
match &mut self.job {
Job::Idle => return Err("the wire has no read or write in progress".into()),
Job::Write { until, packet } => {
if m.cycles() >= *until {
let packet = std::mem::take(packet);
self.job = Job::Idle;
self.push(m, &packet);
return Ok(WireStep::Sent);
}
if m.cycles() >= stop {
return Ok(WireStep::Pending);
}
let n = (*until).min(stop) - m.cycles();
self.run(m, n)?;
}
Job::Read {
deadline,
last_byte,
..
} => {
let (deadline, last) = (*deadline, *last_byte);
if self.now() >= deadline {
self.job = Job::Idle;
return Ok(WireStep::Deadline(self.rx.drain(..).collect()));
}
if self.read_cap_exceeded(m) {
self.job = Job::Idle;
return Err(READ_CAP_MESSAGE.into());
}
if !self.rx.is_empty()
&& m.cycles() - last >= cycles(m, QUIET)
&& m.serial_pending() == 0
{
self.job = Job::Idle;
return Ok(WireStep::Quiet(self.rx.drain(..).collect()));
}
if m.cycles() >= stop {
return Ok(WireStep::Pending);
}
let sent = self.run(m, cycles(m, STEP))?;
let silent = self.rx.is_empty() && !m.is_shutdown();
if let Job::Read {
busy, last_byte, ..
} = &mut self.job
{
if sent {
*last_byte = m.cycles();
} else if silent && *busy < MAX_BUSY {
*busy += STEP;
continue;
}
}
self.idle += STEP;
}
}
}
}
fn finish<L: Line + ?Sized>(&mut self, m: &mut L) -> crate::Result<WireStep> {
loop {
match self.step(m, u64::MAX)? {
WireStep::Pending => {}
done => return Ok(done),
}
}
}
pub fn write_packet<L: Line + ?Sized>(
&mut self,
m: &mut L,
packet: &[u8],
) -> crate::Result<()> {
if !self.start_write(m, packet.to_vec()) {
self.finish(m)?;
}
Ok(())
}
pub fn read<L: Line + ?Sized>(
&mut self,
m: &mut L,
deadline: Instant,
) -> crate::Result<Vec<u8>> {
self.start_read(m, deadline);
match self.finish(m)? {
WireStep::Quiet(bytes) | WireStep::Deadline(bytes) => Ok(bytes),
WireStep::Sent | WireStep::Pending => Ok(Vec::new()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const HZ: u32 = 1_000_000;
const MS: u64 = 1_000;
#[derive(Default)]
struct Fake {
cycles: u64,
script: Vec<(u64, u8)>,
out: Vec<u8>,
received: Vec<u8>,
inbound: VecDeque<u8>,
busy_until: u64,
}
impl Fake {
fn sends(mut self, at_ms: u64, bytes: &[u8]) -> Fake {
for (i, &b) in bytes.iter().enumerate() {
self.script.push(((at_ms + i as u64) * MS, b));
}
self
}
}
impl Line for Fake {
fn cycles(&self) -> u64 {
self.cycles
}
fn clock_hz(&self) -> u32 {
HZ
}
fn run_cycles(&mut self, n: u64) -> crate::Result<()> {
let from = self.cycles;
self.cycles += n;
let to = self.cycles;
for &(at, b) in &self.script {
if at >= from && at < to {
self.out.push(b);
}
}
for _ in (from / MS)..(to / MS) {
if let Some(b) = self.inbound.pop_front() {
self.received.push(b);
}
}
Ok(())
}
fn serial_drain(&mut self) -> Vec<u8> {
std::mem::take(&mut self.out)
}
fn serial_push(&mut self, bytes: &[u8]) {
self.inbound.extend(bytes);
}
fn serial_pending(&self) -> usize {
self.inbound.len()
}
fn is_shutdown(&self) -> bool {
self.cycles >= self.busy_until
}
}
fn ms(n: u64) -> Duration {
Duration::from_millis(n)
}
#[test]
fn transaction_openers() {
assert!(opens_transaction(b"\x01& C1 2 +X\r"));
assert!(opens_transaction(b"\x01#\x20S~"));
assert!(!opens_transaction(b"\x01#!Y5\r"));
assert!(!opens_transaction(b""));
}
#[test]
fn replies_start_with_a_packet_other_than_a_nak() {
assert!(reply_started(b"\r\x01+ S~*"));
assert!(!reply_started(b"\x01# N3\r"));
assert!(!reply_started(b"\x01+ "));
assert!(!reply_started(b""));
}
#[test]
fn a_read_ends_once_the_line_is_quiet() {
let mut m = Fake::default().sends(5, b"\x01# Y");
let mut w = Wire::new();
let start = w.now();
let got = w.read(&mut m, start + ms(1_000)).unwrap();
assert_eq!(got, b"\x01# Y");
assert_eq!(m.cycles / MS, 8 + 1 + 4);
assert_eq!(w.now() - start, ms(13), "an idle calculator's time counts");
}
#[test]
fn busy_time_is_not_idle_time() {
let mut m = Fake {
busy_until: 300 * MS,
..Fake::default()
}
.sends(400, b"\x01# Y");
let mut w = Wire::new();
let start = w.now();
let got = w.read(&mut m, start + ms(200)).unwrap();
assert_eq!(got, b"\x01# Y");
assert_eq!(m.cycles / MS, 408);
assert_eq!(w.now() - start, ms(408 - 299));
}
#[test]
fn a_read_ends_at_its_deadline() {
let mut m = Fake::default();
let mut w = Wire::new();
let start = w.now();
assert_eq!(w.read(&mut m, start + ms(20)).unwrap(), b"");
assert_eq!(m.cycles, 20 * MS);
assert_eq!(w.now() - start, ms(20));
w.start_read(&m, start);
assert_eq!(
w.step(&mut m, u64::MAX).unwrap(),
WireStep::Deadline(vec![])
);
assert_eq!(m.cycles, 20 * MS);
}
#[test]
fn a_read_runs_in_turns() {
let mut blocking = Fake::default().sends(5, b"\x01# Y");
let mut stepped = Fake::default().sends(5, b"\x01# Y");
let (mut a, mut b) = (Wire::new(), Wire::new());
let deadline = |w: &Wire| w.now() + ms(1_000);
let want = a.read(&mut blocking, deadline(&a)).unwrap();
b.start_read(&stepped, deadline(&b));
let mut turns = 0;
let got = loop {
turns += 1;
match b.step(&mut stepped, 2 * MS).unwrap() {
WireStep::Pending => {}
WireStep::Quiet(bytes) => break bytes,
other => panic!("{other:?}"),
}
};
assert_eq!(got, want);
assert_eq!(stepped.cycles, blocking.cycles);
assert!(turns > 5, "{turns} turns");
}
#[test]
fn an_opening_packet_waits_for_the_turnaround() {
let mut m = Fake::default();
let mut w = Wire::new();
assert!(w.start_write(&mut m, b"\x01#!Y5\r".to_vec()));
assert_eq!(m.serial_pending(), 6);
assert_eq!(m.cycles, 0);
m.inbound.clear();
assert!(!w.start_write(&mut m, b"\x01& C1 2 +X\r".to_vec()));
assert_eq!(w.step(&mut m, 150 * MS).unwrap(), WireStep::Pending);
assert_eq!(m.serial_pending(), 0);
assert_eq!(w.step(&mut m, 150 * MS).unwrap(), WireStep::Sent);
assert_eq!(m.cycles, 200 * MS);
assert_eq!(m.serial_pending(), 11);
assert!(w.step(&mut m, MS).is_err());
}
#[test]
fn the_read_cap_stops_a_long_computation() {
let mut m = Fake {
busy_until: u64::MAX,
..Fake::default()
};
let mut w = Wire::new();
w.set_read_cap(Some(ms(50)));
w.write_packet(&mut m, b"\x01#!Y5\r").unwrap();
let start = w.now();
let e = w.read(&mut m, start + ms(10)).unwrap_err();
assert_eq!(e.to_string(), READ_CAP_MESSAGE);
assert!(w.take_read_cap_hit());
assert!(!w.take_read_cap_hit());
assert_eq!(m.cycles / MS, 6 + 50);
assert_eq!(w.now(), start, "busy time");
}
#[test]
fn the_read_cap_ends_with_the_reply() {
let mut m = Fake::default().sends(60, b"\x01# N3\r\x01# Y");
let mut w = Wire::new();
w.set_read_cap(Some(ms(70)));
w.write_packet(&mut m, b"\x01#!Y5\r").unwrap();
let start = w.now();
let got = w.read(&mut m, start + ms(1_000)).unwrap();
assert_eq!(got, b"\x01# N3\r\x01# Y");
assert!(!w.take_read_cap_hit());
}
#[test]
fn the_idle_server_naks() {
let mut m = Fake::default().sends(5_000, b"\x01# N3\r");
let mut w = Wire::new();
assert!(w.wait_for_nak(&mut m, SERVER_CAP).unwrap());
assert_eq!(m.cycles, 5_010 * MS);
let mut quiet = Fake::default();
assert!(!w.wait_for_nak(&mut quiet, ms(100)).unwrap());
assert_eq!(quiet.cycles, 100 * MS);
}
}