grafos_profile/

sensitivity.rs

//! Sensitivity inference — generate a [`WorkloadProfile`] from observed behavior.
//!
//! For each resource dimension, computes an activity score based on:
//! - `cost_fraction`: this resource type's lease-cost / total lease-cost
//! - `acquire_wait_fraction`: this resource type's acquire wait / total acquire wait
//!
//! Maps scores to sensitivity levels:
//! - cost_fraction > 0.5 OR acquire_wait_fraction > 0.3 -> Critical
//! - cost_fraction > 0.2 -> Moderate
//! - cost_fraction > 0.05 -> Low
//! - cost_fraction > 0 -> Indifferent
//! - cost_fraction == 0 -> Unused

use alloc::string::String;
use alloc::vec::Vec;

use grafos_observe::event::ResourceType;

use crate::recording::ProfileRecording;
use crate::summary::ProfileSummary;

/// Sensitivity level for a resource dimension.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum SensitivityLevel {
    /// Not used at all.
    Unused,
    /// Used but not sensitive to quality.
    Indifferent,
    /// Low sensitivity.
    Low,
    /// Moderate sensitivity.
    Moderate,
    /// Critical — dominant resource dimension.
    Critical,
}

impl core::fmt::Display for SensitivityLevel {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            SensitivityLevel::Unused => write!(f, "unused"),
            SensitivityLevel::Indifferent => write!(f, "indifferent"),
            SensitivityLevel::Low => write!(f, "low"),
            SensitivityLevel::Moderate => write!(f, "moderate"),
            SensitivityLevel::Critical => write!(f, "critical"),
        }
    }
}

/// Sensitivity score for a single resource dimension.
#[derive(Debug, Clone)]
pub struct DimensionScore {
    /// Resource type (Mem, Block, Gpu, Cpu).
    pub resource_type: ResourceType,
    /// Fraction of total lease cost attributable to this type.
    pub cost_fraction: f64,
    /// Fraction of total acquire wait attributable to this type.
    pub acquire_wait_fraction: f64,
    /// Operations per second for this resource type.
    pub ops_per_sec: f64,
    /// Bytes per second for this resource type.
    pub bytes_per_sec: f64,
    /// Inferred sensitivity level.
    pub level: SensitivityLevel,
}

/// Workload sensitivity profile inferred from observed behavior.
#[derive(Debug, Clone)]
pub struct WorkloadProfile {
    /// Per-dimension scores.
    pub dimensions: Vec<DimensionScore>,
    /// Total recording duration in microseconds.
    pub total_duration_us: u64,
    /// Total lease cost (byte-seconds).
    pub total_lease_cost: u64,
}

impl WorkloadProfile {
    /// Get the sensitivity level for a specific resource type.
    pub fn level_for(&self, rt: ResourceType) -> SensitivityLevel {
        self.dimensions
            .iter()
            .find(|d| d.resource_type == rt)
            .map(|d| d.level)
            .unwrap_or(SensitivityLevel::Unused)
    }

    /// Render a text summary of the profile.
    pub fn render_text(&self) -> String {
        let mut out = String::new();
        out.push_str("Workload Sensitivity Profile\n\n");

        for dim in &self.dimensions {
            out.push_str(&alloc::format!(
                "  {}: {} (cost: {:.1}%, wait: {:.1}%, ops/s: {:.1}, bytes/s: {:.1})\n",
                dim.resource_type,
                dim.level,
                dim.cost_fraction * 100.0,
                dim.acquire_wait_fraction * 100.0,
                dim.ops_per_sec,
                dim.bytes_per_sec,
            ));
        }

        // Generate summary sentence
        let critical: Vec<_> = self
            .dimensions
            .iter()
            .filter(|d| d.level == SensitivityLevel::Critical)
            .collect();
        let indifferent: Vec<_> = self
            .dimensions
            .iter()
            .filter(|d| d.level == SensitivityLevel::Indifferent)
            .collect();

        if !critical.is_empty() {
            out.push_str(&alloc::format!(
                "\nThis workload is {}-critical ({:.0}% of lease-cost)",
                critical[0].resource_type,
                critical[0].cost_fraction * 100.0,
            ));
            for d in &indifferent {
                out.push_str(&alloc::format!(
                    ", {}-indifferent ({:.0}%)",
                    d.resource_type,
                    d.cost_fraction * 100.0,
                ));
            }
            out.push_str(".\n");
        }

        out
    }
}

/// Infer a sensitivity profile from a recording.
pub fn infer_sensitivity(rec: &ProfileRecording) -> WorkloadProfile {
    if rec.spans.is_empty() {
        return WorkloadProfile {
            dimensions: Vec::new(),
            total_duration_us: 0,
            total_lease_cost: 0,
        };
    }

    let summary = ProfileSummary::from_recording(rec);
    let total_cost = summary.total_lease_cost_byte_secs;
    let total_duration_us = summary.total_duration_us;
    let duration_secs = total_duration_us as f64 / 1_000_000.0;

    let total_acquire_wait: u64 = rec.spans.iter().map(|s| s.lease_acquire_wait_us).sum();

    let resource_types = [
        ResourceType::Mem,
        ResourceType::Block,
        ResourceType::Gpu,
        ResourceType::Cpu,
        ResourceType::Net,
    ];

    let mut dimensions = Vec::new();

    for &rt in &resource_types {
        let key = alloc::format!("{}", rt);
        let type_summary = summary.by_resource_type.get(&key);

        let type_cost = type_summary
            .map(|s| s.total_lease_cost_byte_secs)
            .unwrap_or(0);
        let type_ops = type_summary.map(|s| s.total_ops).unwrap_or(0);
        let type_bytes_read = type_summary.map(|s| s.total_bytes_read).unwrap_or(0);
        let type_bytes_written = type_summary.map(|s| s.total_bytes_written).unwrap_or(0);
        let type_wait = type_summary.map(|s| s.total_acquire_wait_us).unwrap_or(0);

        let cost_fraction = if total_cost > 0 {
            type_cost as f64 / total_cost as f64
        } else {
            0.0
        };

        let acquire_wait_fraction = if total_acquire_wait > 0 {
            type_wait as f64 / total_acquire_wait as f64
        } else {
            0.0
        };

        let ops_per_sec = if duration_secs > 0.0 {
            type_ops as f64 / duration_secs
        } else {
            0.0
        };

        let bytes_per_sec = if duration_secs > 0.0 {
            (type_bytes_read + type_bytes_written) as f64 / duration_secs
        } else {
            0.0
        };

        let level = if cost_fraction > 0.5 || acquire_wait_fraction > 0.3 {
            SensitivityLevel::Critical
        } else if cost_fraction > 0.2 {
            SensitivityLevel::Moderate
        } else if cost_fraction > 0.05 {
            SensitivityLevel::Low
        } else if cost_fraction > 0.0 {
            SensitivityLevel::Indifferent
        } else {
            SensitivityLevel::Unused
        };

        dimensions.push(DimensionScore {
            resource_type: rt,
            cost_fraction,
            acquire_wait_fraction,
            ops_per_sec,
            bytes_per_sec,
            level,
        });
    }

    WorkloadProfile {
        dimensions,
        total_duration_us,
        total_lease_cost: total_cost,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use grafos_observe::event::OpType;
    use grafos_observe::span::ResourceSpan;
    use grafos_observe::trace::TraceContext;

    fn test_ctx() -> TraceContext {
        let mut bytes = [0u8; 24];
        for (i, b) in bytes.iter_mut().enumerate() {
            *b = (i as u8).wrapping_add(0x42);
        }
        TraceContext::new_root(&bytes)
    }

    #[test]
    fn empty_recording() {
        let rec = ProfileRecording::from_spans(Vec::new());
        let profile = infer_sensitivity(&rec);
        assert!(profile.dimensions.is_empty());
        assert_eq!(profile.total_lease_cost, 0);
    }

    #[test]
    fn memory_critical_block_indifferent() {
        let ctx = test_ctx();
        let c1 = ctx.child(&[0xAA; 8]);

        // Memory-heavy span: 80% of cost
        let mut mem_span = ResourceSpan::new("mem_heavy", ctx);
        mem_span.start_time_unix_us = 0;
        mem_span.end_time_unix_us = 1_000_000;
        mem_span.lease_cost_byte_secs = 800;
        mem_span.bytes_read = 100_000;
        mem_span.record_op(ResourceType::Mem, OpType::Read, 1000);

        // Block-light span: 2% of cost
        let mut block_span = ResourceSpan::new("block_light", c1);
        block_span.start_time_unix_us = 0;
        block_span.end_time_unix_us = 1_000_000;
        block_span.lease_cost_byte_secs = 20;
        block_span.bytes_read = 100;
        block_span.record_op(ResourceType::Block, OpType::ReadBlock, 2);

        let rec = ProfileRecording::from_spans(vec![mem_span, block_span]);
        let profile = infer_sensitivity(&rec);

        assert_eq!(
            profile.level_for(ResourceType::Mem),
            SensitivityLevel::Critical
        );
        assert_eq!(
            profile.level_for(ResourceType::Block),
            SensitivityLevel::Indifferent
        );
        assert_eq!(
            profile.level_for(ResourceType::Gpu),
            SensitivityLevel::Unused
        );
    }

    #[test]
    fn moderate_sensitivity() {
        let ctx = test_ctx();
        let c1 = ctx.child(&[0xAA; 8]);

        // Mem: 40% of cost -> moderate
        let mut mem_span = ResourceSpan::new("mem_op", ctx);
        mem_span.start_time_unix_us = 0;
        mem_span.end_time_unix_us = 1_000_000;
        mem_span.lease_cost_byte_secs = 400;
        mem_span.record_op(ResourceType::Mem, OpType::Read, 100);

        // Block: 60% of cost -> critical
        let mut block_span = ResourceSpan::new("block_op", c1);
        block_span.start_time_unix_us = 0;
        block_span.end_time_unix_us = 1_000_000;
        block_span.lease_cost_byte_secs = 600;
        block_span.record_op(ResourceType::Block, OpType::ReadBlock, 100);

        let rec = ProfileRecording::from_spans(vec![mem_span, block_span]);
        let profile = infer_sensitivity(&rec);

        assert_eq!(
            profile.level_for(ResourceType::Mem),
            SensitivityLevel::Moderate
        );
        assert_eq!(
            profile.level_for(ResourceType::Block),
            SensitivityLevel::Critical
        );
    }

    #[test]
    fn text_summary() {
        let ctx = test_ctx();
        let mut span = ResourceSpan::new("mem_op", ctx);
        span.start_time_unix_us = 0;
        span.end_time_unix_us = 1_000_000;
        span.lease_cost_byte_secs = 1000;
        span.record_op(ResourceType::Mem, OpType::Read, 100);

        let rec = ProfileRecording::from_spans(vec![span]);
        let profile = infer_sensitivity(&rec);
        let text = profile.render_text();

        assert!(text.contains("Workload Sensitivity Profile"));
        assert!(text.contains("mem: critical"));
    }
}