qualia_core_db/specialized_libs/statistical_computing/

scheduler.rs

use super::*;

/// Statistical scheduler
pub struct StatisticalScheduler {
    scheduling_policy: SchedulingPolicy,
    queue_manager: QueueManager,
    load_balancer: LoadBalancer,
}

/// Scheduling policies
#[derive(Debug, Clone, PartialEq)]
pub enum SchedulingPolicy {
    FIFO,
    Priority,
    ShortestJobFirst,
    Deadline,
    Adaptive,
}

/// Queue manager
pub struct QueueManager {
    pending_queue: Vec<QueuedOperation>,
    running_operations: HashMap<String, RunningOperation>,
    completed_operations: Vec<CompletedOperation>,
}

/// Queued operation
#[derive(Debug, Clone)]
pub struct QueuedOperation {
    pub operation_id: String,
    pub operation: StatisticalOperation,
    pub priority: OperationPriority,
    pub submitted_at: u64,
    pub deadline: Option<u64>,
}

/// Running operation
#[derive(Debug, Clone)]
pub struct RunningOperation {
    pub operation_id: String,
    pub unit_id: String,
    pub started_at: u64,
    pub progress: f64,
}

/// Completed operation
#[derive(Debug, Clone)]
pub struct CompletedOperation {
    pub operation_id: String,
    pub started_at: u64,
    pub completed_at: u64,
    pub result: StatisticalResult,
    pub success: bool,
}

/// Operation priorities
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum OperationPriority {
    Low,
    Normal,
    High,
    Critical,
}

/// Load balancer
pub struct LoadBalancer {
    balancing_strategy: BalancingStrategy,
    unit_metrics: HashMap<String, UnitMetrics>,
}

/// Unit metrics
#[derive(Debug, Clone)]
pub struct UnitMetrics {
    pub unit_id: String,
    pub current_load: f64,
    pub average_response_time: f64,
    pub success_rate: f64,
    pub energy_efficiency: f64,
}

impl StatisticalScheduler {
    pub fn new() -> Self {
        Self {
            scheduling_policy: SchedulingPolicy::Priority,
            queue_manager: QueueManager::new(),
            load_balancer: LoadBalancer::new(),
        }
    }

    pub fn initialize(&mut self) -> Result<(), StatisticalError> {
        Ok(())
    }

    /// Returns the current scheduling policy.
    pub fn scheduling_policy(&self) -> &SchedulingPolicy {
        &self.scheduling_policy
    }

    /// Set the scheduling policy.
    pub fn set_scheduling_policy(&mut self, policy: SchedulingPolicy) {
        self.scheduling_policy = policy;
    }

    /// Returns a reference to the queue manager.
    pub fn queue_manager(&self) -> &QueueManager {
        &self.queue_manager
    }

    /// Returns a mutable reference to the queue manager.
    pub fn queue_manager_mut(&mut self) -> &mut QueueManager {
        &mut self.queue_manager
    }

    /// Returns a reference to the load balancer.
    pub fn load_balancer(&self) -> &LoadBalancer {
        &self.load_balancer
    }

    /// Returns a mutable reference to the load balancer.
    pub fn load_balancer_mut(&mut self) -> &mut LoadBalancer {
        &mut self.load_balancer
    }
}

impl QueueManager {
    pub fn new() -> Self {
        Self {
            pending_queue: Vec::new(),
            running_operations: HashMap::new(),
            completed_operations: Vec::new(),
        }
    }

    /// Enqueue a pending operation.
    pub fn enqueue(&mut self, operation: QueuedOperation) {
        self.pending_queue.push(operation);
    }

    /// Dequeue the next pending operation (FIFO order). Returns `None` when
    /// the queue is empty.
    pub fn dequeue(&mut self) -> Option<QueuedOperation> {
        if self.pending_queue.is_empty() {
            None
        } else {
            Some(self.pending_queue.remove(0))
        }
    }

    /// Returns the pending operations currently in the queue.
    pub fn pending_queue(&self) -> &[QueuedOperation] {
        &self.pending_queue
    }

    /// Returns the number of pending operations.
    pub fn pending_count(&self) -> usize {
        self.pending_queue.len()
    }

    /// Mark an operation as running, recording it under `operation_id`.
    pub fn start_operation(&mut self, operation: RunningOperation) {
        self.running_operations
            .insert(operation.operation_id.clone(), operation);
    }

    /// Look up a running operation by id.
    pub fn get_running_operation(&self, operation_id: &str) -> Option<&RunningOperation> {
        self.running_operations.get(operation_id)
    }

    /// Remove a running operation (e.g. when it finishes), returning it so
    /// the caller can record completion.
    pub fn remove_running_operation(&mut self, operation_id: &str) -> Option<RunningOperation> {
        self.running_operations.remove(operation_id)
    }

    /// Returns the number of currently running operations.
    pub fn running_count(&self) -> usize {
        self.running_operations.len()
    }

    /// Record a completed operation.
    pub fn record_completed(&mut self, operation: CompletedOperation) {
        self.completed_operations.push(operation);
    }

    /// Returns the completed operations.
    pub fn completed_operations(&self) -> &[CompletedOperation] {
        &self.completed_operations
    }

    /// Returns the number of completed operations.
    pub fn completed_count(&self) -> usize {
        self.completed_operations.len()
    }
}

impl LoadBalancer {
    pub fn new() -> Self {
        Self {
            balancing_strategy: BalancingStrategy::LoadBased,
            unit_metrics: HashMap::new(),
        }
    }

    /// Returns the current balancing strategy.
    pub fn balancing_strategy(&self) -> &BalancingStrategy {
        &self.balancing_strategy
    }

    /// Set the balancing strategy.
    pub fn set_balancing_strategy(&mut self, strategy: BalancingStrategy) {
        self.balancing_strategy = strategy;
    }

    /// Record or update metrics for a computation unit.
    pub fn set_unit_metrics(&mut self, unit_id: &str, metrics: UnitMetrics) {
        self.unit_metrics.insert(unit_id.to_string(), metrics);
    }

    /// Look up metrics for a computation unit.
    pub fn get_unit_metrics(&self, unit_id: &str) -> Option<&UnitMetrics> {
        self.unit_metrics.get(unit_id)
    }

    /// Remove metrics for a computation unit.
    pub fn remove_unit_metrics(&mut self, unit_id: &str) -> Option<UnitMetrics> {
        self.unit_metrics.remove(unit_id)
    }

    /// Returns the number of units with recorded metrics.
    pub fn tracked_unit_count(&self) -> usize {
        self.unit_metrics.len()
    }
}