QOS
An Operating System for Noisy Qubits

// src/main.rs
use std::collections::HashSet;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::io::AsRawFd;
use std::sync::{Arc, Mutex, Condvar, RwLock};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::thread;
use std::time::{Instant, Duration};
use libc::{mmap, PROT_READ, PROT_WRITE, MAP_SHARED};
use serde::Deserialize;

// =====================================================================
// 1. DATA LAYOUT & CONFIGURATION STRUCTURES
// =====================================================================

#[derive(Debug, Deserialize)]
struct CalibrationData {
    qubit_error_rates: Vec<f64>,
}

#[derive(Debug, Deserialize, Clone)]
struct CouplingEdge {
    u: usize,
    v: usize,
    weight: f32,
}

#[derive(Debug, Deserialize)]
struct QpuTopology {
    topology_type: String,
    total_qubits: usize,
    calibration_data: CalibrationData,
    coupling_map: Vec<CouplingEdge>,
}

#[derive(Debug, Clone, Copy, Default)]
pub struct DmaPacket {
    pub syndrome_bitfield: u32,
    pub analog_confidence_voltages: [f32; 8],
}

// =====================================================================
// 2. INTERRUPT SERVICE ROUTINE & LOCK-FREE MEMORY PIPELINING
// =====================================================================

struct InterruptVector {
    triggered: Mutex<bool>,
    condvar: Condvar,
}

impl InterruptVector {
    fn new() -> Self {
        Self { triggered: Mutex::new(false), condvar: Condvar::new() }
    }

    fn wait_for_interrupt(&self) {
        let mut triggered = self.triggered.lock().unwrap();
        while !*triggered {
            triggered = self.condvar.wait(triggered).unwrap();
        }
        *triggered = false;
    }

    fn emit_hardware_interrupt(&self) {
        let mut triggered = self.triggered.lock().unwrap();
        *triggered = true;
        self.condvar.notify_one();
    }
}

const RING_BUFFER_CAPACITY: usize = 1024;

struct LockFreeDmaRingBuffer {
    buffer: Vec<Mutex<DmaPacket>>,
    head: AtomicUsize,
    tail: AtomicUsize,
}

impl LockFreeDmaRingBuffer {
    fn new() -> Self {
        let mut vec = Vec::with_capacity(RING_BUFFER_CAPACITY);
        for _ in 0..RING_BUFFER_CAPACITY {
            vec.push(Mutex::new(DmaPacket::default()));
        }
        Self { buffer: vec, head: AtomicUsize::new(0), tail: AtomicUsize::new(0) }
    }

    fn push(&self, packet: DmaPacket) -> bool {
        let current_head = self.head.load(Ordering::Relaxed);
        let current_tail = self.tail.load(Ordering::Acquire);

        if current_head.wrapping_sub(current_tail) >= RING_BUFFER_CAPACITY {
            return false;
        }

        let idx = current_head & (RING_BUFFER_CAPACITY - 1);
        if let Ok(mut slot) = self.buffer[idx].lock() {
            *slot = packet;
        }
        self.head.store(current_head.wrapping_add(1), Ordering::Release);
        true
    }

    fn pop(&self, current_tail: usize) -> Option<DmaPacket> {
        let current_head = self.head.load(Ordering::Acquire);
        if current_tail == current_head {
            return None;
        }

        let idx = current_tail & (RING_BUFFER_CAPACITY - 1);
        let packet = if let Ok(slot) = self.buffer[idx].lock() {
            *slot
        } else {
            DmaPacket::default()
        };

        self.tail.store(current_tail.wrapping_add(1), Ordering::Release);
        Some(packet)
    }
}

// =====================================================================
// 3. LIVE STREAMING TELEMETRY DAEMON
// =====================================================================

#[derive(Debug, Clone, Default)]
pub struct LiveCalibrationState {
    pub lattice_drift_rates: Vec<f64>,
}

pub struct LiveTelemetryServer {
    pub shared_state: Arc<RwLock<LiveCalibrationState>>,
}

impl LiveTelemetryServer {
    pub fn new(initial_state: Arc<RwLock<LiveCalibrationState>>) -> Self {
        Self { shared_state: initial_state }
    }

    pub fn spawn_listener(&self, address: &str) {
        let listener = TcpListener::bind(address).expect("ERR: cannot bind telemetry socket");
        let state_handle = Arc::clone(&self.shared_state);

        thread::spawn(move || {
            for stream_result in listener.incoming() {
                if let Ok(mut stream) = stream_result {
                    let current_state = Arc::clone(&state_handle);
                    thread::spawn(move || {
                        let mut read_buffer = [0u8; 128];
                        if let Ok(bytes_read) = stream.read(&mut read_buffer) {
                            if bytes_read > 0 {
                                let payload = String::from_utf8_lossy(&read_buffer[..bytes_read]);
                                let raw_floats: Vec<f64> = payload
                                    .trim()
                                    .split(',')
                                    .filter_map(|s| s.parse::<f64>().ok())
                                    .collect();

                                if !raw_floats.is_empty() {
                                    let mut state_writer = current_state.write().unwrap();
                                    state_writer.lattice_drift_rates = raw_floats;
                                    let _ = stream.write_all(b"ACK_STREAM_OK\n");
                                }
                            }
                        }
                    });
                }
            }
        });
    }
}

// =====================================================================
// 4. TOPOLOGICAL CORE: WEIGHT-AWARE SYNDROME DECODER
// =====================================================================

struct FastDisjointSet {
    parent: Vec<usize>,
}

impl FastDisjointSet {
    fn new(size: usize) -> Self {
        Self { parent: (0..size).collect() }
    }

    fn find(&mut self, mut i: usize) -> usize {
        while i != self.parent[i] {
            self.parent[i] = self.parent[self.parent[i]];
            i = self.parent[i];
        }
        i
    }

    fn union(&mut self, i: usize, j: usize) -> bool {
        let root_i = self.find(i);
        let root_j = self.find(j);
        if root_i != root_j {
            self.parent[root_i] = root_j;
            return true;
        }
        false
    }
}

pub struct WeightAwareDecoder {
    node_count: usize,
}

impl WeightAwareDecoder {
    pub fn new(nodes: usize) -> Self {
        Self { node_count: nodes }
    }

    fn decode_syndromes(
        &self,
        bitfield: u32,
        confidence_weights: &[f32],
        coupling_map: &[CouplingEdge],
    ) -> Vec<(usize, usize)> {
        let mut dsf = FastDisjointSet::new(self.node_count);
        let mut corrections_applied = Vec::new();

        // Sort edges by weight so the decoder checks high-probability error paths first
        let mut sorted_edges = coupling_map.to_vec();
        sorted_edges.sort_by(|a, b| a.weight.partial_cmp(&b.weight).unwrap());

        for edge in sorted_edges {
            let bit_u = (bitfield & (1 << edge.u)) != 0;
            let bit_v = (bitfield & (1 << edge.v)) != 0;

            if bit_u || bit_v {
                // Fold live analog confidence directly into the lookup pass
                if confidence_weights[edge.u] < 0.5 || confidence_weights[edge.v] < 0.5 {
                    if dsf.union(edge.u, edge.v) {
                        if bit_u && bit_v {
                            corrections_applied.push((edge.u, edge.v));
                        }
                    }
                }
            }
        }
        corrections_applied
    }
}

// =====================================================================
// 5. THE RUNTIME EMULATION SUITE
// =====================================================================

pub struct HardwareEmulator;

impl HardwareEmulator {
    pub fn spin_up_mock_registers(file_path: &str) -> std::io::Result<()> {
        let mut file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(true)
            .mode(0o666)
            .open(file_path)?;

        let blank_register_page = vec![0u8; 4096];
        file.write_all(&blank_register_page)?;
        file.flush()?;
        Ok(())
    }
}

// =====================================================================
// 6. PIPELINE HARNESS EXECUTION
// =====================================================================

fn main() -> std::io::Result<()> {
    println!("=== INITIALISING FULL-STACK PRODUCTION QUANTUM OS PLATFORM ===");

    // 1. Load the QPU topology configuration
    let config_data = r#"{
      "topology_type": "Heavy-Hex-8",
      "total_qubits": 8,
      "calibration_data": { "qubit_error_rates": [0.01, 0.01, 0.02, 0.01, 0.01, 0.08, 0.01, 0.01] },
      "coupling_map": [
         {"u": 0, "v": 1, "weight": 0.12}, {"u": 1, "v": 2, "weight": 0.45},
         {"u": 2, "v": 3, "weight": 0.08}, {"u": 4, "v": 5, "weight": 0.19},
         {"u": 5, "v": 6, "weight": 0.05}, {"u": 6, "v": 7, "weight": 0.33},
         {"u": 0, "v": 4, "weight": 0.15}, {"u": 1, "v": 5, "weight": 0.22}
      ]
    }"#;
    let qpu: QpuTopology = serde_json::from_str(config_data).unwrap();
    println!("[BOOT] QPU topology map loaded: {}", qpu.topology_type);

    // 2. Stand up the mock hardware register page for user-space mmap
    let target_mock_dev = "/tmp/qos_mmap_plane";
    HardwareEmulator::spin_up_mock_registers(target_mock_dev)?;
    let dev_file = OpenOptions::new().read(true).write(true).open(target_mock_dev)?;
    let raw_fd = dev_file.as_raw_fd();

    let mapped_address = unsafe {
        mmap(std::ptr::null_mut(), 4096, PROT_READ | PROT_WRITE, MAP_SHARED, raw_fd, 0) as *mut u32
    };
    assert_ne!(mapped_address, std::ptr::null_mut(), "CRITICAL: mmap allocation failed");
    println!("[USER CORE] Zero-copy register space mapped at: {:?}", mapped_address);

    // 3. Mount async components and the streaming telemetry daemon
    let interrupt_line = Arc::new(InterruptVector::new());
    let ring_buffer = Arc::new(LockFreeDmaRingBuffer::new());
    let live_calibration = Arc::new(RwLock::new(LiveCalibrationState::default()));
    let system_shutdown = Arc::new(AtomicBool::new(false));

    let telemetry_server = LiveTelemetryServer::new(Arc::clone(&live_calibration));
    telemetry_server.spawn_listener("127.0.0.1:9899");

    // 4. Spawn the physical hardware execution thread (the producer)
    let prod_isr = Arc::clone(&interrupt_line);
    let prod_ring = Arc::clone(&ring_buffer);
    let prod_shutdown = Arc::clone(&system_shutdown);

    let producer_handle = thread::spawn(move || {
        let mut hardware_cycles = 1;
        while !prod_shutdown.load(Ordering::Relaxed) && hardware_cycles <= 2 {
            thread::sleep(Duration::from_millis(60));
            let packet = DmaPacket {
                syndrome_bitfield: 0b0011_0011,
                analog_confidence_voltages: [0.95, 0.98, 0.22, 0.94, 0.96, 0.18, 0.97, 0.99],
            };
            if prod_ring.push(packet) {
                prod_isr.emit_hardware_interrupt();
            }
            hardware_cycles += 1;
        }
    });

    // 5. Spawn the OS-side processing thread (the consumer)
    let cons_isr = Arc::clone(&interrupt_line);
    let cons_ring = Arc::clone(&ring_buffer);
    let cons_shutdown = Arc::clone(&system_shutdown);
    let decoder = WeightAwareDecoder::new(qpu.total_qubits);
    let coupling_map = qpu.coupling_map.clone();

    let consumer_handle = thread::spawn(move || {
        let mut local_tail = 0;
        while !cons_shutdown.load(Ordering::Relaxed) {
            cons_isr.wait_for_interrupt();
            let start_time = Instant::now();

            if let Some(packet) = cons_ring.pop(local_tail) {
                let corrections = decoder.decode_syndromes(
                    packet.syndrome_bitfield,
                    &packet.analog_confidence_voltages,
                    &coupling_map,
                );
                let elapsed = start_time.elapsed();
                println!(
                    " -> [QOS REAL-TIME ISR] corrected lattice coordinates: {:?} | core latency: {:?}",
                    corrections, elapsed
                );
                assert!(elapsed < Duration::from_micros(50), "CRITICAL: QEC loop breached coherence deadline");

                local_tail += 1;
                if local_tail >= 2 {
                    cons_shutdown.store(true, Ordering::Release);
                }
            }
        }
    });

    producer_handle.join().unwrap();
    consumer_handle.join().unwrap();

    let _ = std::fs::remove_file(target_mock_dev);
    println!("\n=== END-TO-END CONCURRENT QUANTUM OS EXECUTION SUCCESSFUL ===");
    Ok(())
}