aprender-cbtop 0.31.1

Compute Block Top - Real-time load testing and hardware monitoring TUI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Execution policy (Theme equivalent in Grammar of Graphics).

use std::time::Duration;

use super::resources::ByteSize;

/// Quality of Service level
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QosLevel {
    /// Best effort (no guarantees)
    BestEffort,
    /// Background (lowest priority)
    Background,
    /// Interactive (balanced)
    Interactive,
    /// Realtime (highest priority)
    Realtime,
}

/// Retry policy
#[derive(Debug, Clone, PartialEq)]
pub struct RetryPolicy {
    /// Maximum retry attempts
    pub max_retries: usize,
    /// Initial backoff duration
    pub initial_backoff: Duration,
    /// Backoff multiplier
    pub backoff_multiplier: f64,
}

impl Default for RetryPolicy {
    fn default() -> Self {
        Self {
            max_retries: 3,
            initial_backoff: Duration::from_millis(100),
            backoff_multiplier: 2.0,
        }
    }
}

/// Resource limits
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ResourceLimits {
    /// Maximum memory usage
    pub max_memory: Option<ByteSize>,
    /// Maximum CPU cores
    pub max_cores: Option<usize>,
    /// Maximum GPU memory
    pub max_gpu_memory: Option<ByteSize>,
}

/// Observability configuration
#[derive(Debug, Clone, PartialEq, Default)]
pub struct ObservabilityConfig {
    /// Enable tracing
    pub tracing: bool,
    /// Enable metrics
    pub metrics: bool,
    /// Sampling rate (0.0-1.0)
    pub sampling_rate: f64,
}

/// Execution policy (analogous to Theme)
#[derive(Debug, Clone, PartialEq)]
pub struct ExecutionPolicy {
    /// Quality of Service level
    pub qos: QosLevel,
    /// Preemption allowed
    pub preemptible: bool,
    /// Timeout constraint
    pub timeout: Option<Duration>,
    /// Retry policy
    pub retry: RetryPolicy,
    /// Resource limits
    pub limits: ResourceLimits,
    /// Observability config
    pub observability: ObservabilityConfig,
}

impl Default for ExecutionPolicy {
    fn default() -> Self {
        Self {
            qos: QosLevel::Interactive,
            preemptible: true,
            timeout: None,
            retry: RetryPolicy::default(),
            limits: ResourceLimits::default(),
            observability: ObservabilityConfig::default(),
        }
    }
}

impl ExecutionPolicy {
    /// Create realtime policy (low latency, non-preemptible)
    pub fn realtime() -> Self {
        Self {
            qos: QosLevel::Realtime,
            preemptible: false,
            timeout: Some(Duration::from_millis(100)),
            ..Default::default()
        }
    }

    /// Create batch policy (high throughput, preemptible)
    pub fn batch() -> Self {
        Self {
            qos: QosLevel::BestEffort,
            preemptible: true,
            timeout: None,
            ..Default::default()
        }
    }

    /// Create interactive policy (balanced)
    pub fn interactive() -> Self {
        Self::default()
    }

    /// Create debug policy (full tracing, relaxed limits)
    pub fn debug() -> Self {
        Self {
            qos: QosLevel::BestEffort,
            preemptible: true,
            timeout: None,
            observability: ObservabilityConfig {
                tracing: true,
                metrics: true,
                sampling_rate: 1.0,
            },
            ..Default::default()
        }
    }
}