|
|
|
|
| use crate::memory::{Memory, Address};
|
| use crate::checkpoint::{Checkpoint, CheckpointManager};
|
| use crate::telemetry::{TelemetryEmitter, MutationDelta};
|
| use anyhow::{Result, Context};
|
| use parking_lot::RwLock;
|
| use std::sync::Arc;
|
| use tracing::{trace, debug, warn};
|
|
|
|
|
| #[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| pub struct Instruction {
|
| pub a: Address,
|
| pub b: Address,
|
| pub c: Address,
|
| }
|
|
|
| impl Instruction {
|
| pub const SIZE: usize = 3;
|
|
|
| pub fn from_memory(mem: &Memory, ip: Address) -> Option<Self> {
|
| let a = mem.read(ip)? as Address;
|
| let b = mem.read(ip + 1)? as Address;
|
| let c = mem.read(ip + 2)? as Address;
|
| Some(Self { a, b, c })
|
| }
|
| }
|
|
|
|
|
| #[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| pub enum ExecMode {
|
|
|
| Standard,
|
|
|
| Verified,
|
|
|
| Analysis,
|
| }
|
|
|
|
|
| pub struct SubleqVM {
|
| memory: Arc<RwLock<Memory>>,
|
| ip: Address,
|
| mode: ExecMode,
|
| mutation_log: Vec<MutationDelta>,
|
| checkpoint_mgr: CheckpointManager,
|
| telemetry: Option<Arc<TelemetryEmitter>>,
|
| step_count: u64,
|
| max_steps: Option<u64>,
|
| }
|
|
|
| impl SubleqVM {
|
| pub fn new(memory: Memory, mode: ExecMode) -> Self {
|
| let mem = Arc::new(RwLock::new(memory));
|
| Self {
|
| memory: mem.clone(),
|
| ip: 0,
|
| mode,
|
| mutation_log: Vec::new(),
|
| checkpoint_mgr: CheckpointManager::new(mem),
|
| telemetry: None,
|
| step_count: 0,
|
| max_steps: None,
|
| }
|
| }
|
|
|
| pub fn with_telemetry(mut self, emitter: Arc<TelemetryEmitter>) -> Self {
|
| self.telemetry = Some(emitter);
|
| self
|
| }
|
|
|
| pub fn with_max_steps(mut self, max: u64) -> Self {
|
| self.max_steps = Some(max);
|
| self
|
| }
|
|
|
|
|
| pub fn step(&mut self) -> Result<Option<bool>> {
|
| if let Some(max) = self.max_steps {
|
| if self.step_count >= max {
|
| return Ok(None);
|
| }
|
| }
|
|
|
| let mem = self.memory.read();
|
| let instr = Instruction::from_memory(&mem, self.ip)
|
| .context("Instruction fetch failed: IP out of bounds")?;
|
| drop(mem);
|
|
|
| trace!(ip = self.ip, ?instr, "Executing SUBLEQ");
|
|
|
|
|
| let (val_a, val_b) = {
|
| let mem = self.memory.read();
|
| let val_a = mem.read(instr.a).unwrap_or(0);
|
| let val_b = mem.read(instr.b).unwrap_or(0);
|
| (val_a, val_b)
|
| };
|
|
|
|
|
| let res = val_b.wrapping_sub(val_a);
|
|
|
|
|
| {
|
| let mut mem = self.memory.write();
|
| mem.write(instr.b, res)?;
|
| self.mutation_log.push(MutationDelta {
|
| address: instr.b,
|
| old_value: val_b,
|
| new_value: res,
|
| ip: self.ip,
|
| step: self.step_count,
|
| });
|
| }
|
|
|
|
|
| if let Some(ref tel) = self.telemetry {
|
| tel.emit(MutationDelta {
|
| address: instr.b,
|
| old_value: val_b,
|
| new_value: res,
|
| ip: self.ip,
|
| step: self.step_count,
|
| });
|
| }
|
|
|
|
|
| let branched = res <= 0;
|
| if branched {
|
| self.ip = instr.c;
|
| } else {
|
| self.ip += Instruction::SIZE;
|
| }
|
|
|
| self.step_count += 1;
|
| Ok(Some(branched))
|
| }
|
|
|
|
|
| pub fn run(&mut self) -> Result<()> {
|
| while self.step()?.is_some() {}
|
| Ok(())
|
| }
|
|
|
|
|
| pub fn checkpoint(&mut self) -> Checkpoint {
|
| self.checkpoint_mgr.create(self.ip, self.step_count, self.mutation_log.len())
|
| }
|
|
|
|
|
| pub fn rollback(&mut self, checkpoint: &Checkpoint) -> Result<()> {
|
| self.checkpoint_mgr.restore(checkpoint, &mut self.memory.write())?;
|
| self.ip = checkpoint.ip;
|
| self.step_count = checkpoint.step_count;
|
| self.mutation_log.truncate(checkpoint.mutation_log_len);
|
| warn!(?checkpoint, "Rolled back");
|
| Ok(())
|
| }
|
|
|
| pub fn mutation_log(&self) -> &[MutationDelta] {
|
| &self.mutation_log
|
| }
|
|
|
| pub fn ip(&self) -> Address {
|
| self.ip
|
| }
|
|
|
| pub fn steps(&self) -> u64 {
|
| self.step_count
|
| }
|
|
|
| pub fn memory(&self) -> Arc<RwLock<Memory>> {
|
| self.memory.clone()
|
| }
|
| }
|
|
|
| #[cfg(test)]
|
| mod tests {
|
| use super::*;
|
|
|
| #[test]
|
| fn test_basic_subleq() {
|
| let mut mem = Memory::new(1024);
|
| mem.write(0, 1).unwrap();
|
| mem.write(1, 5).unwrap();
|
| mem.write(2, 6).unwrap();
|
| mem.write(3, 0).unwrap();
|
|
|
| let mut vm = SubleqVM::new(mem, ExecMode::Standard);
|
| vm.run().unwrap();
|
|
|
| let final_mem = vm.memory.read();
|
| assert_eq!(final_mem.read(2), Some(1));
|
| }
|
| }
|
|
|
