|
|
|
|
| use crate::memory::{Memory, Address};
|
| use anyhow::{Result, Context};
|
| use std::sync::Arc;
|
| use parking_lot::RwLock;
|
| use uuid::Uuid;
|
|
|
| #[derive(Debug, Clone)]
|
| pub struct Checkpoint {
|
| pub id: String,
|
| pub ip: Address,
|
| pub step_count: u64,
|
| pub mutation_log_len: usize,
|
| pub memory_snapshot: Vec<i64>,
|
| pub timestamp: u64,
|
| }
|
|
|
| impl Checkpoint {
|
| pub fn id(&self) -> &str {
|
| &self.id
|
| }
|
| }
|
|
|
| pub struct CheckpointManager {
|
| memory: Arc<RwLock<Memory>>,
|
| checkpoints: Vec<Checkpoint>,
|
| }
|
|
|
| impl CheckpointManager {
|
| pub fn new(memory: Arc<RwLock<Memory>>) -> Self {
|
| Self {
|
| memory,
|
| checkpoints: Vec::new(),
|
| }
|
| }
|
|
|
| pub fn create(&mut self, ip: Address, step_count: u64, mutation_log_len: usize) -> Checkpoint {
|
| use std::time::{SystemTime, UNIX_EPOCH};
|
|
|
| let mem = self.memory.read();
|
| let timestamp = SystemTime::now()
|
| .duration_since(UNIX_EPOCH)
|
| .unwrap()
|
| .as_secs();
|
|
|
| let checkpoint = Checkpoint {
|
| id: Uuid::new_v4().to_string(),
|
| ip,
|
| step_count,
|
| mutation_log_len,
|
| memory_snapshot: mem.as_slice().to_vec(),
|
| timestamp,
|
| };
|
|
|
| self.checkpoints.push(checkpoint.clone());
|
| checkpoint
|
| }
|
|
|
| pub fn restore(&self, checkpoint: &Checkpoint, memory: &mut Memory) -> Result<()> {
|
| if checkpoint.memory_snapshot.len() != memory.size() {
|
| return Err(anyhow::anyhow!("Checkpoint memory size mismatch"));
|
| }
|
|
|
| for (addr, &word) in checkpoint.memory_snapshot.iter().enumerate() {
|
| memory.write(addr, word)?;
|
| }
|
|
|
| Ok(())
|
| }
|
|
|
| pub fn list_checkpoints(&self) -> &[Checkpoint] {
|
| &self.checkpoints
|
| }
|
| }
|
|
|
| #[cfg(test)]
|
| mod tests {
|
| use super::*;
|
|
|
| #[test]
|
| fn test_checkpoint_create_restore() {
|
| let mut mem = Memory::new(1024);
|
| mem.write(0, 42).unwrap();
|
| mem.write(1, 100).unwrap();
|
|
|
| let mem = Arc::new(RwLock::new(mem));
|
| let mut mgr = CheckpointManager::new(mem.clone());
|
|
|
| let cp = mgr.create(0, 0, 0);
|
| assert_eq!(cp.step_count, 0);
|
|
|
| {
|
| let mut m = mem.write();
|
| m.write(0, 999).unwrap();
|
| }
|
|
|
| {
|
| let mut m = mem.write();
|
| mgr.restore(&cp, &mut m).unwrap();
|
| }
|
|
|
| let m = mem.read();
|
| assert_eq!(m.read(0), Some(42));
|
| }
|
| }
|
|
|
