quiche/
flowcontrol.rs

1// Copyright (C) 2021, 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;
28use std::time::Instant;
29
30// When autotuning the receiver window, decide how much
31// we increase the window.
32const WINDOW_INCREASE_FACTOR: u64 = 2;
33
34// When autotuning the receiver window, check if the last
35// update is within RTT * this constant.
36const WINDOW_TRIGGER_FACTOR: u32 = 2;
37
38#[derive(Default, Debug)]
39pub struct FlowControl {
40    /// Total consumed bytes by the receiver.
41    consumed: u64,
42
43    /// Flow control limit.
44    max_data: u64,
45
46    /// The receive window. This value is used for updating
47    /// flow control limit.
48    window: u64,
49
50    /// The maximum receive window.
51    max_window: u64,
52
53    /// Last update time of max_data for autotuning the window.
54    last_update: Option<Instant>,
55}
56
57impl FlowControl {
58    pub fn new(max_data: u64, window: u64, max_window: u64) -> Self {
59        Self {
60            max_data,
61
62            window: std::cmp::min(window, max_window),
63
64            max_window,
65
66            ..Default::default()
67        }
68    }
69
70    /// Returns the current window size.
71    pub fn window(&self) -> u64 {
72        self.window
73    }
74
75    /// Returns the current flow limit.
76    pub fn max_data(&self) -> u64 {
77        self.max_data
78    }
79
80    /// Returns the consumed bytes by the receiver.
81    #[cfg(test)]
82    pub fn consumed(&self) -> u64 {
83        self.consumed
84    }
85
86    /// Update consumed bytes.
87    pub fn add_consumed(&mut self, consumed: u64) {
88        self.consumed += consumed;
89    }
90
91    /// Returns true if the flow control needs to update max_data.
92    ///
93    /// This happens when the available window is smaller than the half
94    /// of the current window.
95    pub fn should_update_max_data(&self) -> bool {
96        let available_window = self.max_data - self.consumed;
97
98        available_window < (self.window / 2)
99    }
100
101    /// Returns the new max_data limit.
102    pub fn max_data_next(&self) -> u64 {
103        self.consumed + self.window
104    }
105
106    /// Commits the new max_data limit.
107    pub fn update_max_data(&mut self, now: Instant) {
108        self.max_data = self.max_data_next();
109        self.last_update = Some(now);
110    }
111
112    /// Autotune the window size. When there is an another update
113    /// within RTT x 2, bump the window x 2, capped by
114    /// max_window.
115    pub fn autotune_window(&mut self, now: Instant, rtt: Duration) {
116        if let Some(last_update) = self.last_update {
117            if now - last_update < rtt * WINDOW_TRIGGER_FACTOR {
118                self.set_window(self.window * WINDOW_INCREASE_FACTOR);
119            }
120        }
121    }
122
123    fn set_window(&mut self, window: u64) {
124        self.window = std::cmp::min(window, self.max_window);
125    }
126
127    /// Make sure the lower bound of the window is same to
128    /// the current window.
129    pub fn ensure_window_lower_bound(&mut self, min_window: u64) {
130        if min_window > self.window {
131            // ... we still need to clamp to `max_window`
132            self.set_window(min_window);
133        }
134    }
135}
136
137#[cfg(test)]
138mod tests {
139    use super::*;
140
141    #[test]
142    fn max_window_in_new() {
143        let fc = FlowControl::new(100, 100, 50);
144        assert_eq!(fc.max_data(), 100);
145        assert_eq!(fc.window, 50);
146    }
147
148    #[test]
149    fn max_data() {
150        let fc = FlowControl::new(100, 20, 100);
151
152        assert_eq!(fc.max_data(), 100);
153    }
154
155    #[test]
156    fn should_update_max_data() {
157        let mut fc = FlowControl::new(100, 20, 100);
158
159        fc.add_consumed(85);
160        assert!(!fc.should_update_max_data());
161
162        fc.add_consumed(10);
163        assert!(fc.should_update_max_data());
164    }
165
166    #[test]
167    fn max_data_next() {
168        let mut fc = FlowControl::new(100, 20, 100);
169
170        let consumed = 95;
171
172        fc.add_consumed(consumed);
173        assert!(fc.should_update_max_data());
174        assert_eq!(fc.max_data_next(), consumed + 20);
175    }
176
177    #[test]
178    fn update_max_data() {
179        let mut fc = FlowControl::new(100, 20, 100);
180
181        let consumed = 95;
182
183        fc.add_consumed(consumed);
184        assert!(fc.should_update_max_data());
185
186        let max_data_next = fc.max_data_next();
187        assert_eq!(fc.max_data_next(), consumed + 20);
188
189        fc.update_max_data(Instant::now());
190        assert_eq!(fc.max_data(), max_data_next);
191    }
192
193    #[test]
194    fn autotune_window() {
195        let w = 20;
196        let mut fc = FlowControl::new(100, w, 100);
197
198        let consumed = 95;
199
200        fc.add_consumed(consumed);
201        assert!(fc.should_update_max_data());
202
203        let max_data_next = fc.max_data_next();
204        assert_eq!(max_data_next, consumed + w);
205
206        fc.update_max_data(Instant::now());
207        assert_eq!(fc.max_data(), max_data_next);
208
209        // Window size should be doubled.
210        fc.autotune_window(Instant::now(), Duration::from_millis(100));
211
212        let w = w * 2;
213        let consumed_inc = 15;
214
215        fc.add_consumed(consumed_inc);
216        assert!(fc.should_update_max_data());
217
218        let max_data_next = fc.max_data_next();
219        assert_eq!(max_data_next, consumed + consumed_inc + w);
220    }
221
222    #[test]
223    fn ensure_window_lower_bound() {
224        let w = 20;
225        let mut fc = FlowControl::new(100, w, 100);
226
227        // Window doesn't change.
228        fc.ensure_window_lower_bound(w);
229        assert_eq!(fc.window(), 20);
230
231        // Window changed to the new value.
232        fc.ensure_window_lower_bound(w * 2);
233        assert_eq!(fc.window(), 40);
234
235        // Window clamped to max_window
236        fc.ensure_window_lower_bound(101);
237        assert_eq!(fc.window(), 100);
238    }
239}
quiche/flowcontrol.rs

quiche/
flowcontrol.rs
