Process Management

VeridianOS implements a lightweight process model with capability-based isolation and a multi-class scheduler designed for performance, scalability, and real-time responsiveness.

Process Model

Design Philosophy

Lightweight Threads: Minimal overhead thread creation and switching
Capability-Based Isolation: Process isolation through capabilities, not permissions
Zero-Copy Communication: Efficient inter-process data transfer
Real-Time Support: Predictable scheduling for time-critical tasks
Scalability: Support for 1000+ concurrent processes

Thread Control Block (TCB)

Each thread is represented by a compact control block:

#![allow(unused)]
fn main() {
#[repr(C)]
pub struct ThreadControlBlock {
    // Identity
    tid: ThreadId,
    pid: ProcessId,
    name: [u8; 32],
    
    // Scheduling
    state: ThreadState,
    priority: Priority,
    sched_class: SchedClass,
    cpu_affinity: CpuSet,
    
    // Timing
    cpu_time: u64,
    last_run: Instant,
    time_slice: Duration,
    deadline: Option<Instant>,
    
    // Memory
    address_space: AddressSpace,
    kernel_stack: VirtAddr,
    user_stack: VirtAddr,
    
    // CPU Context
    saved_context: Context,
    
    // IPC
    ipc_state: IpcState,
    message_queue: MessageQueue,
    
    // Capabilities
    cap_space: CapabilitySpace,
}
}

Thread States

#![allow(unused)]
fn main() {
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ThreadState {
    /// Currently executing on CPU
    Running,
    
    /// Ready to run, waiting for CPU
    Ready,
    
    /// Blocked waiting for resource
    Blocked(BlockReason),
    
    /// Suspended by debugger/admin
    Suspended,
    
    /// Terminated, awaiting cleanup
    Terminated,
}

#[derive(Debug, Clone, Copy)]
pub enum BlockReason {
    /// Waiting for IPC message
    IpcReceive(EndpointId),
    
    /// Waiting for IPC reply
    IpcReply(ReplyToken),
    
    /// Waiting for memory allocation
    Memory,
    
    /// Sleeping for specified duration
    Sleep(Instant),
    
    /// Waiting for child process
    WaitChild(ProcessId),
    
    /// Waiting for I/O completion
    Io(IoHandle),
    
    /// Waiting for mutex/semaphore
    Synchronization(SyncHandle),
}
}

CPU Context Management

Architecture-Specific Context

#![allow(unused)]
fn main() {
// x86_64 context structure
#[repr(C)]
pub struct Context {
    // General purpose registers
    rax: u64, rbx: u64, rcx: u64, rdx: u64,
    rsi: u64, rdi: u64, rbp: u64, rsp: u64,
    r8: u64,  r9: u64,  r10: u64, r11: u64,
    r12: u64, r13: u64, r14: u64, r15: u64,
    
    // Control registers
    rip: u64,         // Instruction pointer
    rflags: u64,      // Flags register
    cr3: u64,         // Page table base
    
    // Segment registers
    cs: u16, ds: u16, es: u16, fs: u16, gs: u16, ss: u16,
    
    // Extended state
    fpu_state: Option<Box<FpuState>>,
    avx_state: Option<Box<AvxState>>,
}

// AArch64 context structure
#[cfg(target_arch = "aarch64")]
#[repr(C)]
pub struct Context {
    // General purpose registers
    x: [u64; 31],     // x0-x30
    sp: u64,          // Stack pointer
    pc: u64,          // Program counter
    pstate: u64,      // Processor state
    
    // System registers
    ttbr0_el1: u64,   // Translation table base
    ttbr1_el1: u64,
    tcr_el1: u64,     // Translation control
    
    // FPU/SIMD state
    fpu_state: Option<Box<FpuState>>,
}
}

Context Switching

Fast context switching is critical for performance:

#![allow(unused)]
fn main() {
/// Switch between threads on same CPU
pub fn context_switch(from: &mut ThreadControlBlock, to: &ThreadControlBlock) -> Result<()> {
    // 1. Save current thread state
    save_context(&mut from.saved_context)?;
    
    // 2. Update scheduling metadata
    from.last_run = Instant::now();
    from.cpu_time += from.last_run.duration_since(from.last_scheduled);
    
    // 3. Switch address space if needed
    if from.pid != to.pid {
        switch_address_space(&to.address_space)?;
    }
    
    // 4. Restore new thread state
    restore_context(&to.saved_context)?;
    
    // 5. Update current thread pointer
    set_current_thread(to.tid);
    
    Ok(())
}

/// Architecture-specific context save/restore
#[cfg(target_arch = "x86_64")]
unsafe fn save_context(context: &mut Context) -> Result<()> {
    asm!(
        "mov {rax}, rax",
        "mov {rbx}, rbx",
        "mov {rcx}, rcx",
        // ... save all registers
        rax = out(reg) context.rax,
        rbx = out(reg) context.rbx,
        rcx = out(reg) context.rcx,
        // ... other register outputs
    );
    
    // Save FPU state if used
    if thread_uses_fpu() {
        save_fpu_state(&mut context.fpu_state)?;
    }
    
    Ok(())
}
}

Scheduling System

Multi-Level Feedback Queue (MLFQ)

VeridianOS uses a sophisticated scheduler with multiple priority levels:

#![allow(unused)]
fn main() {
pub struct Scheduler {
    /// Real-time run queue (priorities 0-99)
    rt_queue: RealTimeQueue,
    
    /// Interactive run queue (priorities 100-139)
    interactive_queue: InteractiveQueue,
    
    /// Normal time-sharing queue (priorities 140-179)
    normal_queue: NormalQueue,
    
    /// Batch processing queue (priorities 180-199)
    batch_queue: BatchQueue,
    
    /// Idle tasks (priority 200)
    idle_queue: IdleQueue,
    
    /// Currently running thread
    current: Option<ThreadId>,
    
    /// Scheduling statistics
    stats: SchedulerStats,
}
}

Scheduling Classes

Real-Time Scheduling (0-99)

#![allow(unused)]
fn main() {
impl RealTimeQueue {
    /// Add real-time thread with deadline
    pub fn enqueue(&mut self, thread: ThreadId, deadline: Instant) -> Result<()> {
        // Earliest Deadline First (EDF) scheduling
        let insertion_point = self.queue.binary_search_by_key(&deadline, |t| t.deadline)?;
        self.queue.insert(insertion_point, RtTask { thread, deadline });
        Ok(())
    }
    
    /// Get next real-time thread to run
    pub fn dequeue(&mut self) -> Option<ThreadId> {
        // Always run earliest deadline first
        self.queue.pop_front().map(|task| task.thread)
    }
}
}

Interactive Scheduling (100-139)

#![allow(unused)]
fn main() {
impl InteractiveQueue {
    /// Add interactive thread with boost
    pub fn enqueue(&mut self, thread: ThreadId, boost: u8) -> Result<()> {
        let effective_priority = self.base_priority + boost;
        self.priority_queues[effective_priority as usize].push_back(thread);
        Ok(())
    }
    
    /// Boost priority for I/O bound tasks
    pub fn io_boost(&mut self, thread: ThreadId) {
        if let Some(task) = self.find_task(thread) {
            task.boost = (task.boost + 5).min(20);
        }
    }
}
}

#![allow(unused)]
fn main() {
impl NormalQueue {
    /// Standard round-robin with aging
    pub fn enqueue(&mut self, thread: ThreadId) -> Result<()> {
        let priority = self.calculate_priority(thread);
        self.priority_queues[priority].push_back(thread);
        Ok(())
    }
    
    /// Age threads to prevent starvation
    pub fn age_threads(&mut self) {
        for (priority, queue) in self.priority_queues.iter_mut().enumerate() {
            if priority > 0 {
                // Move long-waiting threads to higher priority
                while let Some(thread) = queue.pop_front() {
                    if self.should_age(thread) {
                        self.priority_queues[priority - 1].push_back(thread);
                    } else {
                        queue.push_back(thread);
                        break;
                    }
                }
            }
        }
    }
}
}

CPU Affinity and Load Balancing

#![allow(unused)]
fn main() {
pub struct LoadBalancer {
    /// Per-CPU run queue lengths
    cpu_loads: [AtomicU32; MAX_CPUS],
    
    /// Last balance timestamp
    last_balance: Instant,
    
    /// Balancing interval
    balance_interval: Duration,
}

impl LoadBalancer {
    /// Balance load across CPUs
    pub fn balance(&mut self) -> Result<()> {
        let now = Instant::now();
        if now.duration_since(self.last_balance) < self.balance_interval {
            return Ok(());
        }
        
        // Find most and least loaded CPUs
        let (max_cpu, max_load) = self.find_max_load();
        let (min_cpu, min_load) = self.find_min_load();
        
        // Migrate threads if imbalance is significant
        if max_load > min_load + IMBALANCE_THRESHOLD {
            self.migrate_threads(max_cpu, min_cpu, (max_load - min_load) / 2)?;
        }
        
        self.last_balance = now;
        Ok(())
    }
    
    /// Migrate threads between CPUs
    fn migrate_threads(&self, from_cpu: CpuId, to_cpu: CpuId, count: u32) -> Result<()> {
        let from_queue = &self.cpu_queues[from_cpu];
        let to_queue = &self.cpu_queues[to_cpu];
        
        for _ in 0..count {
            if let Some(thread) = from_queue.pop_migrable() {
                // Check CPU affinity
                if thread.cpu_affinity.contains(to_cpu) {
                    to_queue.push(thread);
                    
                    // Send IPI to wake up target CPU
                    send_ipi(to_cpu, IPI_RESCHEDULE);
                } else {
                    // Put back if can't migrate
                    from_queue.push(thread);
                    break;
                }
            }
        }
        
        Ok(())
    }
}
}

Process Creation and Lifecycle

Process Creation

#![allow(unused)]
fn main() {
/// Create new process with capabilities
pub fn create_process(
    binary: &[u8],
    args: &[&str],
    env: &[(&str, &str)],
    capabilities: &[Capability],
) -> Result<ProcessId> {
    // 1. Allocate process ID
    let pid = allocate_pid()?;
    
    // 2. Create address space
    let address_space = AddressSpace::new()?;
    
    // 3. Load binary into memory
    let entry_point = load_binary(&address_space, binary)?;
    
    // 4. Set up initial stack
    let stack_base = setup_user_stack(&address_space, args, env)?;
    
    // 5. Create main thread
    let main_thread = ThreadControlBlock::new(
        pid,
        entry_point,
        stack_base,
        capabilities.to_vec(),
    )?;
    
    // 6. Add to scheduler
    SCHEDULER.lock().add_thread(main_thread)?;
    
    Ok(pid)
}
}

Process Termination

#![allow(unused)]
fn main() {
/// Terminate process and clean up resources
pub fn terminate_process(pid: ProcessId, exit_code: i32) -> Result<()> {
    let process = PROCESS_TABLE.lock().get(pid)?;
    
    // 1. Terminate all threads
    for thread_id in &process.threads {
        terminate_thread(*thread_id)?;
    }
    
    // 2. Notify parent process
    if let Some(parent) = process.parent {
        send_child_exit_notification(parent, pid, exit_code)?;
    }
    
    // 3. Close IPC endpoints
    for endpoint in &process.ipc_endpoints {
        close_endpoint(*endpoint)?;
    }
    
    // 4. Revoke all capabilities
    for capability in &process.capabilities {
        revoke_capability(capability)?;
    }
    
    // 5. Free address space
    free_address_space(process.address_space)?;
    
    // 6. Remove from process table
    PROCESS_TABLE.lock().remove(pid);
    
    Ok(())
}
}

Performance Characteristics

Benchmark Results

Operation	Target	Achieved	Notes
Context Switch	<10μs	~8.5μs	Including TLB flush
Process Creation	<50μs	~42μs	Basic process with minimal capabilities
Thread Creation	<5μs	~3.2μs	Within existing process
Schedule Decision	<1μs	~0.7μs	O(1) in most cases
Load Balance	<100μs	~75μs	Across 8 CPU cores
Wake-up Latency	<5μs	~4.1μs	From blocked to running

Memory Usage

#![allow(unused)]
fn main() {
/// Process table entry
pub struct ProcessTableEntry {
    pid: ProcessId,
    parent: Option<ProcessId>,
    children: Vec<ProcessId>,
    
    // Memory footprint: ~256 bytes per process
    address_space: AddressSpace,      // 32 bytes
    capabilities: Vec<Capability>,    // Variable
    ipc_endpoints: Vec<EndpointId>,   // Variable
    threads: Vec<ThreadId>,           // Variable
    
    // Resource usage tracking
    memory_usage: AtomicUsize,
    cpu_time: AtomicU64,
    io_counters: IoCounters,
}

// Total overhead: ~384 bytes per thread + variable capability storage
}

Multi-Architecture Support

x86_64 Specific Features

#![allow(unused)]
fn main() {
#[cfg(target_arch = "x86_64")]
impl ArchSpecific for ProcessManager {
    fn setup_syscall_entry(&self, thread: &mut ThreadControlBlock) -> Result<()> {
        // Set up SYSCALL/SYSRET mechanism
        thread.saved_context.cs = KERNEL_CS;
        thread.saved_context.ss = USER_DS;
        
        // Configure LSTAR MSR for syscall entry
        unsafe {
            wrmsr(MSR_LSTAR, syscall_entry as u64);
            wrmsr(MSR_STAR, ((KERNEL_CS as u64) << 32) | ((USER_CS as u64) << 48));
            wrmsr(MSR_SFMASK, RFLAGS_IF); // Disable interrupts in syscalls
        }
        
        Ok(())
    }
}
}

AArch64 Specific Features

#![allow(unused)]
fn main() {
#[cfg(target_arch = "aarch64")]
impl ArchSpecific for ProcessManager {
    fn setup_exception_entry(&self, thread: &mut ThreadControlBlock) -> Result<()> {
        // Set up exception vector table
        thread.saved_context.pstate = PSTATE_EL0;
        
        // Configure EL1 for kernel mode
        unsafe {
            write_sysreg!(vbar_el1, exception_vectors as u64);
            write_sysreg!(spsel, 1); // Use SP_EL1 in kernel mode
        }
        
        Ok(())
    }
}
}

RISC-V Specific Features

#![allow(unused)]
fn main() {
#[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))]
impl ArchSpecific for ProcessManager {
    fn setup_trap_entry(&self, thread: &mut ThreadControlBlock) -> Result<()> {
        // Set up trap vector
        unsafe {
            csrw!(stvec, trap_entry as usize);
            csrw!(sstatus, SSTATUS_SIE); // Enable supervisor interrupts
        }
        
        Ok(())
    }
}
}

Integration with Other Subsystems

IPC Integration

#![allow(unused)]
fn main() {
impl IpcIntegration for ProcessManager {
    /// Block thread waiting for IPC message
    fn block_for_ipc(&self, thread_id: ThreadId, endpoint: EndpointId) -> Result<()> {
        let mut thread = self.get_thread_mut(thread_id)?;
        thread.state = ThreadState::Blocked(BlockReason::IpcReceive(endpoint));
        
        // Remove from run queue
        SCHEDULER.lock().unschedule(thread_id)?;
        
        // Trigger reschedule
        reschedule();
        
        Ok(())
    }
    
    /// Wake thread when IPC message arrives
    fn wake_from_ipc(&self, thread_id: ThreadId) -> Result<()> {
        let mut thread = self.get_thread_mut(thread_id)?;
        thread.state = ThreadState::Ready;
        
        // Add back to run queue with priority boost
        SCHEDULER.lock().schedule_with_boost(thread_id, PRIORITY_BOOST_IPC)?;
        
        Ok(())
    }
}
}

Memory Management Integration

#![allow(unused)]
fn main() {
impl MemoryIntegration for ProcessManager {
    /// Handle page fault for process
    fn handle_page_fault(&self, thread_id: ThreadId, fault_addr: VirtAddr) -> Result<()> {
        let thread = self.get_thread(thread_id)?;
        let process = self.get_process(thread.pid)?;
        
        // Check if address is in valid VMA
        if let Some(vma) = process.address_space.find_vma(fault_addr) {
            match vma.fault_type {
                FaultType::DemandPage => {
                    // Allocate and map new page
                    let frame = allocate_frame()?;
                    map_page(&process.address_space, fault_addr, frame, vma.flags)?;
                }
                FaultType::CopyOnWrite => {
                    // Copy page and remap with write permission
                    handle_cow_fault(&process.address_space, fault_addr)?;
                }
                _ => return Err(Error::SegmentationFault),
            }
        } else {
            // Invalid memory access
            terminate_thread(thread_id)?;
        }
        
        Ok(())
    }
}
}

Future Enhancements

Planned Features

Gang Scheduling: Schedule related threads together
NUMA Awareness: Consider memory locality in scheduling decisions
Energy Efficiency: CPU frequency scaling based on workload
Real-Time Enhancements: Rate monotonic and deadline scheduling
Security Enhancements: Process isolation through hardware features

Research Areas

Machine Learning: AI-driven scheduling optimization
Heterogeneous Computing: GPU/accelerator integration
Distributed Scheduling: Multi-node process migration
Quantum Computing: Quantum process scheduling models

This process management system provides the foundation for secure, efficient, and scalable computing on VeridianOS while maintaining the microkernel's principles of isolation and capability-based security.

VeridianOS Developer Guide