clm-kernel 0.0.21

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Rust SavepointGuard Rollback Benchmark (CRD-04).
//! Measures 1,000 rollback iterations with SQLite in-memory, verifying <1ms p99 and zero state leakage.

use clm_rust_core::fiber::savepoint_guard::SavepointGuard;
use rusqlite::Connection;
use std::sync::{Arc, Mutex};
use std::time::Instant;

fn main() {
    let conn = Arc::new(Mutex::new(Connection::open_in_memory().unwrap()));
    conn.lock()
        .unwrap()
        .execute(
            "CREATE TABLE card (hash TEXT PRIMARY KEY, content BLOB NOT NULL, g_time TEXT NOT NULL);",
            [],
        )
        .unwrap();

    let iterations = 1000;
    let mut durations_us = Vec::with_capacity(iterations);

    for i in 0..iterations {
        let mut sp = SavepointGuard::new(conn.clone(), format!("sp_bench_{}", i)).unwrap();

        // Dirty insert
        conn.lock()
            .unwrap()
            .execute(
                "INSERT INTO card (hash, content, g_time) VALUES (?1, ?2, datetime('now'));",
                rusqlite::params![format!("hash_{}", i), b"test_payload"],
            )
            .unwrap();

        let disposed = Arc::new(std::sync::atomic::AtomicBool::new(false));
        let flag = disposed.clone();
        sp.add_disposer(move || {
            flag.store(true, std::sync::atomic::Ordering::SeqCst);
            Ok(())
        });

        let t0 = Instant::now();
        sp.rollback().unwrap();
        let elapsed_us = t0.elapsed().as_nanos() as f64 / 1000.0;
        durations_us.push(elapsed_us);

        assert!(disposed.load(std::sync::atomic::Ordering::SeqCst), "Disposer must execute on rollback");

        let count: i64 = conn
            .lock()
            .unwrap()
            .query_row("SELECT count(*) FROM card;", [], |r| r.get(0))
            .unwrap();
        assert_eq!(count, 0, "card table must be empty after rollback");
    }

    durations_us.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let min = durations_us[0];
    let max = durations_us[durations_us.len() - 1];
    let mean = durations_us.iter().sum::<f64>() / durations_us.len() as f64;
    let median = durations_us[(iterations as f64 * 0.5) as usize];
    let p95 = durations_us[(iterations as f64 * 0.95) as usize];
    let p99 = durations_us[(iterations as f64 * 0.99) as usize];

    println!(
        r#"{{
  "runtime": "rust",
  "iterations": {},
  "min_us": {:.2},
  "mean_us": {:.2},
  "median_us": {:.2},
  "p95_us": {:.2},
  "p99_us": {:.2},
  "max_us": {:.2},
  "p99_ms": {:.4},
  "sub_millisecond_compliant": {},
  "zero_leakage_verified": true
}}"#,
        iterations,
        min,
        mean,
        median,
        p95,
        p99,
        max,
        p99 / 1000.0,
        p99 < 1000.0
    );
}