clm-kernel 0.0.12

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Layer 1: Colored Petri Net (CPN) Virtual Machine Execution Engine
//! Canonical Path: kernel/clm_rust_core/src/layer1/vm.rs

use super::types::{Marking, PetriNet, Transition};
use std::collections::HashMap;

/// Colored Petri Net Virtual Machine (Layer 1 execution runtime).
#[derive(Debug, Clone)]
pub struct ColoredPetriVM {
    pub net: PetriNet,
    pub marking: Marking,
    pub fire_history: Vec<String>,
}

impl ColoredPetriVM {
    /// Initializes VM with a PetriNet and its initial marking.
    pub fn new(net: PetriNet) -> Self {
        let marking = net.initial_marking();
        Self {
            net,
            marking,
            fire_history: Vec::new(),
        }
    }

    /// Checks if a transition is enabled under current marking:
    /// M(p) >= W(p, t) for all p in inputs(t).
    pub fn is_enabled(&self, t: &Transition) -> bool {
        let mut required = HashMap::new();
        for inp in &t.inputs {
            *required.entry(inp.clone()).or_insert(0u32) += 1;
        }
        for (p, req) in required {
            let available = self.marking.get(&p).copied().unwrap_or(0);
            if available < req {
                return false;
            }
        }
        true
    }

    /// Returns list of all transitions currently enabled to fire.
    pub fn enabled_transitions(&self) -> Vec<String> {
        self.net
            .transitions
            .iter()
            .filter(|t| self.is_enabled(t))
            .map(|t| t.id.clone())
            .collect()
    }

    /// Fires a single named transition: consumes input tokens, produces output tokens.
    /// M' = M + D(·, t)
    pub fn fire(&mut self, transition_id: &str) -> Result<(), String> {
        let t = self
            .net
            .transitions
            .iter()
            .find(|tr| tr.id == transition_id)
            .cloned()
            .ok_or_else(|| format!("Transition not found: {}", transition_id))?;

        if !self.is_enabled(&t) {
            return Err(format!("Transition '{}' is not enabled under current marking", transition_id));
        }

        // Consume tokens from inputs
        for inp in &t.inputs {
            if let Some(tokens) = self.marking.get_mut(inp) {
                *tokens = tokens.saturating_sub(1);
            }
        }

        // Produce tokens to outputs
        for out in &t.outputs {
            *self.marking.entry(out.clone()).or_insert(0) += 1;
        }

        self.fire_history.push(transition_id.to_string());
        Ok(())
    }

    /// Executes one enabled transition if available.
    pub fn step(&mut self) -> Option<String> {
        let next_t = self.enabled_transitions().into_iter().next()?;
        if self.fire(&next_t).is_ok() {
            Some(next_t)
        } else {
            None
        }
    }

    /// Runs the Petri net to completion or until max_steps reached.
    pub fn run_to_completion(&mut self, max_steps: usize) -> usize {
        let mut steps = 0;
        while steps < max_steps {
            if self.step().is_none() {
                break;
            }
            steps += 1;
        }
        steps
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::time::Instant;

    #[test]
    fn test_vm_transition_latency_benchmark() {
        let net = PetriNet {
            places: vec![
                super::super::types::Place { id: "p1".to_string(), initial_tokens: 1, initial_color: None },
                super::super::types::Place { id: "p2".to_string(), initial_tokens: 0, initial_color: None },
            ],
            transitions: vec![
                Transition { id: "t1".to_string(), inputs: vec!["p1".to_string()], outputs: vec!["p2".to_string()] },
                Transition { id: "t2".to_string(), inputs: vec!["p2".to_string()], outputs: vec!["p1".to_string()] },
            ],
        };

        let mut vm = ColoredPetriVM::new(net);
        let iterations = 10000;
        let start = Instant::now();
        let steps = vm.run_to_completion(iterations);
        let elapsed = start.elapsed();
        let per_trans_micros = elapsed.as_micros() as f64 / steps as f64;
        println!("[RUST BENCHMARK] CPN VM {} transitions in {:?} ({:.4} µs/transition)", steps, elapsed, per_trans_micros);
        assert!(per_trans_micros <= 50.0, "Rust transition latency must be <= 50µs, got {:.4}µs", per_trans_micros);
    }
}