quiche/recovery/gcongestion/
bandwidth.rs

1// Copyright (C) 2023, Cloudflare, Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8//     * Redistributions of source code must retain the above copyright notice,
9//       this list of conditions and the following disclaimer.
10//
11//     * Redistributions in binary form must reproduce the above copyright
12//       notice, this list of conditions and the following disclaimer in the
13//       documentation and/or other materials provided with the distribution.
14//
15// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
16// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
19// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27use std::time::Duration;
28
29const NUM_MILLIS_PER_SECOND: u64 = 1000;
30const NUM_MICROS_PER_MILLI: u64 = 1000;
31const NUM_MICROS_PER_SECOND: u64 = NUM_MICROS_PER_MILLI * NUM_MILLIS_PER_SECOND;
32const NUM_NANOS_PER_SECOND: u64 = 1000 * NUM_MICROS_PER_SECOND;
33
34#[derive(PartialEq, PartialOrd, Eq, Ord, Clone, Copy)]
35pub struct Bandwidth {
36    bits_per_second: u64,
37}
38
39impl std::ops::Mul<f64> for Bandwidth {
40    type Output = Bandwidth;
41
42    fn mul(self, rhs: f64) -> Self::Output {
43        Bandwidth {
44            bits_per_second: (self.bits_per_second as f64 * rhs).round() as u64,
45        }
46    }
47}
48
49impl std::ops::Mul<f32> for Bandwidth {
50    type Output = Bandwidth;
51
52    fn mul(self, rhs: f32) -> Self::Output {
53        self * rhs as f64
54    }
55}
56
57impl std::ops::Sub<Bandwidth> for Bandwidth {
58    type Output = Option<Bandwidth>;
59
60    fn sub(self, rhs: Bandwidth) -> Self::Output {
61        self.bits_per_second
62            .checked_sub(rhs.bits_per_second)
63            .map(|bps| Bandwidth {
64                bits_per_second: bps,
65            })
66    }
67}
68
69impl std::ops::Add<Bandwidth> for Bandwidth {
70    type Output = Bandwidth;
71
72    fn add(self, rhs: Bandwidth) -> Self::Output {
73        Bandwidth {
74            bits_per_second: self.bits_per_second.add(rhs.bits_per_second),
75        }
76    }
77}
78
79impl std::ops::Mul<Duration> for Bandwidth {
80    type Output = u64;
81
82    fn mul(self, rhs: Duration) -> Self::Output {
83        self.to_bytes_per_period(rhs)
84    }
85}
86
87impl Bandwidth {
88    pub const fn from_bytes_and_time_delta(
89        bytes: usize, time_delta: Duration,
90    ) -> Self {
91        if bytes == 0 {
92            return Bandwidth { bits_per_second: 0 };
93        }
94
95        let mut nanos = time_delta.as_nanos() as u64;
96        if nanos == 0 {
97            nanos = 1;
98        }
99
100        let num_nano_bits = 8 * bytes as u64 * NUM_NANOS_PER_SECOND;
101        if num_nano_bits < nanos {
102            return Bandwidth { bits_per_second: 1 };
103        }
104
105        Bandwidth {
106            bits_per_second: num_nano_bits / nanos,
107        }
108    }
109
110    #[allow(dead_code)]
111    pub const fn from_bytes_per_second(bytes_per_second: u64) -> Self {
112        Bandwidth {
113            bits_per_second: bytes_per_second * 8,
114        }
115    }
116
117    #[allow(dead_code)]
118    pub const fn to_bits_per_second(self) -> u64 {
119        self.bits_per_second
120    }
121
122    pub const fn from_kbits_per_second(k_bits_per_second: u64) -> Self {
123        Bandwidth {
124            bits_per_second: k_bits_per_second * 1_000,
125        }
126    }
127
128    #[allow(dead_code)]
129    pub const fn from_mbits_per_second(m_bits_per_second: u64) -> Self {
130        Bandwidth::from_kbits_per_second(m_bits_per_second * 1_000)
131    }
132
133    pub const fn infinite() -> Self {
134        Bandwidth {
135            bits_per_second: u64::MAX,
136        }
137    }
138
139    pub const fn zero() -> Self {
140        Bandwidth { bits_per_second: 0 }
141    }
142
143    pub fn transfer_time(&self, bytes: usize) -> Duration {
144        if self.bits_per_second == 0 {
145            Duration::ZERO
146        } else {
147            Duration::from_nanos(
148                (bytes as u64 * 8 * NUM_NANOS_PER_SECOND) / self.bits_per_second,
149            )
150        }
151    }
152
153    pub fn to_bytes_per_period(self, time_period: Duration) -> u64 {
154        self.bits_per_second * time_period.as_nanos() as u64 /
155            8 /
156            NUM_NANOS_PER_SECOND
157    }
158}
159
160impl std::fmt::Debug for Bandwidth {
161    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
162        match self.bits_per_second {
163            x if x < 1_000_000 => write!(f, "{:.2} Kbps", x as f64 / 1_000.),
164            x if x < 1_000_000_000 => {
165                write!(f, "{:.2} Mbps", x as f64 / 1_000_000.)
166            },
167            x => write!(f, "{:.2} Gbps", x as f64 / 1_000_000_000.),
168        }
169    }
170}
quiche/recovery/gcongestion/bandwidth.rs

quiche/recovery/gcongestion/
bandwidth.rs
