hippox-drivers 0.3.5

//! CPU cache information driver module
//!
//! This module provides functionality to get CPU cache information including
//! size, line size, and associativity for each cache level.
use crate::{
    DriverCallback, DriverCategory, DriverContext, DriverError, DriverResult,
    drivers::operating_system_cpu::common::CpuCacheInfo,
    types::{Driver, DriverParameter},
};
use serde_json::{Value, json};
use std::collections::HashMap;
use tracing::{debug, info};
/// Driver for getting CPU cache information
#[derive(Debug)]
pub struct CpuCacheDriver;
#[async_trait::async_trait]
impl Driver for CpuCacheDriver {
    /// Returns the unique name of this driver
    fn name(&self) -> &str {
        return "cpu_cache";
    }
    /// Returns a brief description of the driver's functionality
    fn description(&self) -> &str {
        return "Get CPU cache information including size, line size, and associativity";
    }
    /// Returns detailed usage guidance for LLMs
    fn usage_hint(&self) -> &str {
        return "Use this skill to understand CPU cache hierarchy and performance characteristics";
    }
    /// Returns the parameter definitions for this driver
    fn parameters(&self) -> Vec<DriverParameter> {
        return vec![];
    }
    /// Returns an example call for this driver
    fn example_call(&self) -> DriverResult<Value> {
        return Ok(json!({
            "action": "cpu_cache",
            "parameters": {}
        }));
    }
    /// Returns an example output from this driver
    fn example_output(&self) -> String {
        return r#"CPU Cache Information:
L1 Cache (Data): 32 KB, 64-byte lines, 8-way associative
L1 Cache (Instruction): 32 KB, 64-byte lines, 8-way associative
L2 Cache: 256 KB, 64-byte lines, 4-way associative
L3 Cache: 12 MB, 64-byte lines, 16-way associative"#
            .to_string();
    }
    /// Returns the category of this driver
    fn category(&self) -> DriverCategory {
        return DriverCategory::OperatingSystemCpu;
    }
    /// Executes the driver with the given parameters
    async fn execute(
        &self,
        _parameters: &HashMap<String, Value>,
        _callback: Option<&dyn DriverCallback>,
        _context: Option<&DriverContext>,
    ) -> DriverResult<String> {
        debug!("Executing cpu_cache driver");
        let caches = get_cache_info()?;
        let mut output = String::from("CPU Cache Information:\n");
        for cache in caches {
            let associativity = cache.associativity.map(|a| format!("{}-way", a)).unwrap_or_else(|| "Unknown".to_string());
            output.push_str(&format!(
                "L{} Cache ({}): {} KB, {}-byte lines, {}\n",
                cache.level, cache.cache_type, cache.size_kb, cache.line_size_bytes, associativity
            ));
        }
        info!("CPU cache information retrieved");
        return Ok(output);
    }
    /// Validates the parameters before execution
    fn validate(&self, _parameters: &HashMap<String, Value>) -> DriverResult<()> {
        return Ok(());
    }
}
fn get_cache_info() -> DriverResult<Vec<CpuCacheInfo>> {
    let mut caches = Vec::new();
    #[cfg(target_os = "linux")]
    {
        let base_path = "/sys/devices/system/cpu/cpu0/cache";
        for entry in std::fs::read_dir(base_path).map_err(|e| DriverError::execution(format!("Failed to read cache directory: {}", e)))? {
            let entry = entry.map_err(|e| DriverError::execution(format!("Failed to read directory entry: {}", e)))?;
            let path = entry.path();
            let index = entry.file_name().to_string_lossy().to_string();
            if !index.starts_with("index") {
                continue;
            }
            let size_path = path.join("size");
            let type_path = path.join("type");
            let line_size_path = path.join("coherency_line_size");
            let ways_path = path.join("ways_of_associativity");
            let level_path = path.join("level");
            if let (Ok(size_str), Ok(type_str), Ok(line_size_str)) =
                (std::fs::read_to_string(&size_path), std::fs::read_to_string(&type_path), std::fs::read_to_string(&line_size_path))
            {
                let size_kb = parse_size(&size_str.trim());
                let cache_type = type_str.trim().to_string();
                let line_size = line_size_str.trim().parse::<u64>().unwrap_or(64);
                let level = std::fs::read_to_string(&level_path).map(|s| s.trim().parse::<u8>().unwrap_or(1)).unwrap_or(1);
                let associativity = std::fs::read_to_string(&ways_path).map(|s| s.trim().parse::<u64>().ok()).unwrap_or(None);
                caches.push(CpuCacheInfo { level, size_kb, line_size_bytes: line_size, associativity, cache_type });
            }
        }
    }
    #[cfg(not(target_os = "linux"))]
    {
        let mut system = sysinfo::System::new_all();
        system.refresh_cpu_all();
        if let Some(cpu) = system.cpus().first() {
            let brand = cpu.brand().to_lowercase();
            let (l1_size, l2_size, l3_size) = if brand.contains("intel") {
                (48, 256, 12288)
            } else if brand.contains("amd") {
                (32, 512, 16384)
            } else {
                (32, 256, 8192)
            };
            caches.push(CpuCacheInfo {
                level: 1,
                size_kb: l1_size,
                line_size_bytes: 64,
                associativity: Some(8),
                cache_type: "Data + Instruction".to_string(),
            });
            caches.push(CpuCacheInfo { level: 2, size_kb: l2_size, line_size_bytes: 64, associativity: Some(4), cache_type: "Unified".to_string() });
            if l3_size > 0 {
                caches.push(CpuCacheInfo {
                    level: 3,
                    size_kb: l3_size,
                    line_size_bytes: 64,
                    associativity: Some(16),
                    cache_type: "Unified".to_string(),
                });
            }
        } else {
            caches.push(CpuCacheInfo {
                level: 1,
                size_kb: 32,
                line_size_bytes: 64,
                associativity: Some(8),
                cache_type: "Data + Instruction".to_string(),
            });
            caches.push(CpuCacheInfo { level: 2, size_kb: 256, line_size_bytes: 64, associativity: Some(4), cache_type: "Unified".to_string() });
        }
    }
    caches.sort_by_key(|c| c.level);
    return Ok(caches);
}
fn parse_size(size_str: &str) -> u64 {
    let size_str = size_str.trim();
    if size_str.ends_with('K') {
        size_str[..size_str.len() - 1].parse::<u64>().unwrap_or(0)
    } else if size_str.ends_with('M') {
        size_str[..size_str.len() - 1].parse::<u64>().unwrap_or(0) * 1024
    } else if size_str.ends_with('G') {
        size_str[..size_str.len() - 1].parse::<u64>().unwrap_or(0) * 1024 * 1024
    } else {
        size_str.parse::<u64>().unwrap_or(0) / 1024
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_cpu_cache_metadata() {
        let driver = CpuCacheDriver;
        assert_eq!(driver.name(), "cpu_cache");
        assert_eq!(driver.category(), DriverCategory::OperatingSystemCpu);
    }
}