use super::types::{Marking, PetriNet, Transition};
use std::collections::HashMap;
#[derive(Debug, Clone)]
pub struct ColoredPetriVM {
pub net: PetriNet,
pub marking: Marking,
pub fire_history: Vec<String>,
}
impl ColoredPetriVM {
pub fn new(net: PetriNet) -> Self {
let marking = net.initial_marking();
Self {
net,
marking,
fire_history: Vec::new(),
}
}
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
}
pub fn enabled_transitions(&self) -> Vec<String> {
self.net
.transitions
.iter()
.filter(|t| self.is_enabled(t))
.map(|t| t.id.clone())
.collect()
}
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));
}
for inp in &t.inputs {
if let Some(tokens) = self.marking.get_mut(inp) {
*tokens = tokens.saturating_sub(1);
}
}
for out in &t.outputs {
*self.marking.entry(out.clone()).or_insert(0) += 1;
}
self.fire_history.push(transition_id.to_string());
Ok(())
}
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
}
}
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);
}
}