freenet 0.2.38

Freenet core software
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! BBRv3 statistics for telemetry and debugging.
//!
//! This module provides a snapshot of the BBR controller state for
//! logging, metrics, and debugging purposes.

use std::time::Duration;

use super::state::{BbrState, ProbeBwPhase};

/// Snapshot of BBR controller state for telemetry.
#[derive(Debug, Clone)]
pub struct BbrStats {
    /// Current BBR state (Startup, Drain, ProbeBW, ProbeRTT).
    pub state: BbrState,

    /// Current ProbeBW sub-phase (only meaningful in ProbeBW state).
    pub probe_bw_phase: ProbeBwPhase,

    /// Current congestion window (bytes).
    pub cwnd: usize,

    /// Current bytes in flight.
    pub flightsize: usize,

    /// Current pacing rate (bytes/sec).
    pub pacing_rate: u64,

    /// Maximum bandwidth estimate (bytes/sec).
    pub max_bw: u64,

    /// Minimum RTT estimate.
    pub min_rtt: Option<Duration>,

    /// Bandwidth-Delay Product estimate (bytes).
    pub bdp: usize,

    /// Total bytes delivered.
    pub delivered: u64,

    /// Total bytes lost.
    pub lost: u64,

    /// Current round count.
    pub round_count: u64,

    /// Number of rounds without bandwidth growth (for Startup exit).
    pub full_bw_count: u32,

    /// Peak bandwidth seen during Startup.
    pub full_bw: u64,

    /// Number of times we've entered ProbeRTT.
    pub probe_rtt_rounds: u64,

    /// Number of timeouts experienced.
    pub timeouts: u64,

    /// Maximum BDP ever seen (for adaptive timeout floor).
    pub max_bdp_seen: usize,

    /// Whether currently application-limited.
    pub is_app_limited: bool,

    /// Current pacing gain.
    pub pacing_gain: f64,

    /// Current cwnd gain.
    pub cwnd_gain: f64,
}

impl Default for BbrStats {
    fn default() -> Self {
        Self {
            state: BbrState::Startup,
            probe_bw_phase: ProbeBwPhase::Cruise,
            cwnd: 0,
            flightsize: 0,
            pacing_rate: 0,
            max_bw: 0,
            min_rtt: None,
            bdp: 0,
            delivered: 0,
            lost: 0,
            round_count: 0,
            full_bw_count: 0,
            full_bw: 0,
            probe_rtt_rounds: 0,
            timeouts: 0,
            max_bdp_seen: 0,
            is_app_limited: false,
            pacing_gain: 1.0,
            cwnd_gain: 1.0,
        }
    }
}

impl std::fmt::Display for BbrStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "BBR[{:?}] cwnd={} flight={} rate={}/s bw={}/s rtt={:?} bdp={}",
            self.state,
            format_bytes(self.cwnd),
            format_bytes(self.flightsize),
            format_bytes(self.pacing_rate as usize),
            format_bytes(self.max_bw as usize),
            self.min_rtt,
            format_bytes(self.bdp),
        )
    }
}

/// Format bytes in human-readable form.
fn format_bytes(bytes: usize) -> String {
    if bytes >= 1_000_000 {
        format!("{:.1}MB", bytes as f64 / 1_000_000.0)
    } else if bytes >= 1_000 {
        format!("{:.1}KB", bytes as f64 / 1_000.0)
    } else {
        format!("{}B", bytes)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_stats_display() {
        let stats = BbrStats {
            state: BbrState::ProbeBW,
            cwnd: 150_000,
            flightsize: 100_000,
            pacing_rate: 10_000_000,
            max_bw: 10_000_000,
            min_rtt: Some(Duration::from_millis(50)),
            bdp: 500_000,
            ..Default::default()
        };

        let display = format!("{}", stats);
        assert!(display.contains("ProbeBW"));
        assert!(display.contains("150.0KB"));
    }

    #[test]
    fn test_format_bytes() {
        assert_eq!(format_bytes(500), "500B");
        assert_eq!(format_bytes(1500), "1.5KB");
        assert_eq!(format_bytes(1_500_000), "1.5MB");
    }
}