1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * H-TCP congestion control. The algorithm is detailed in: |
4 | * R.N.Shorten, D.J.Leith: |
5 | * "H-TCP: TCP for high-speed and long-distance networks" |
6 | * Proc. PFLDnet, Argonne, 2004. |
7 | * https://www.hamilton.ie/net/htcp3.pdf |
8 | */ |
9 | |
10 | #include <linux/mm.h> |
11 | #include <linux/module.h> |
12 | #include <net/tcp.h> |
13 | |
14 | #define ALPHA_BASE (1<<7) /* 1.0 with shift << 7 */ |
15 | #define BETA_MIN (1<<6) /* 0.5 with shift << 7 */ |
16 | #define BETA_MAX 102 /* 0.8 with shift << 7 */ |
17 | |
18 | static int use_rtt_scaling __read_mostly = 1; |
19 | module_param(use_rtt_scaling, int, 0644); |
20 | MODULE_PARM_DESC(use_rtt_scaling, "turn on/off RTT scaling" ); |
21 | |
22 | static int use_bandwidth_switch __read_mostly = 1; |
23 | module_param(use_bandwidth_switch, int, 0644); |
24 | MODULE_PARM_DESC(use_bandwidth_switch, "turn on/off bandwidth switcher" ); |
25 | |
26 | struct htcp { |
27 | u32 alpha; /* Fixed point arith, << 7 */ |
28 | u8 beta; /* Fixed point arith, << 7 */ |
29 | u8 modeswitch; /* Delay modeswitch |
30 | until we had at least one congestion event */ |
31 | u16 pkts_acked; |
32 | u32 packetcount; |
33 | u32 minRTT; |
34 | u32 maxRTT; |
35 | u32 last_cong; /* Time since last congestion event end */ |
36 | u32 undo_last_cong; |
37 | |
38 | u32 undo_maxRTT; |
39 | u32 undo_old_maxB; |
40 | |
41 | /* Bandwidth estimation */ |
42 | u32 minB; |
43 | u32 maxB; |
44 | u32 old_maxB; |
45 | u32 Bi; |
46 | u32 lasttime; |
47 | }; |
48 | |
49 | static inline u32 htcp_cong_time(const struct htcp *ca) |
50 | { |
51 | return jiffies - ca->last_cong; |
52 | } |
53 | |
54 | static inline u32 htcp_ccount(const struct htcp *ca) |
55 | { |
56 | return htcp_cong_time(ca) / ca->minRTT; |
57 | } |
58 | |
59 | static inline void htcp_reset(struct htcp *ca) |
60 | { |
61 | ca->undo_last_cong = ca->last_cong; |
62 | ca->undo_maxRTT = ca->maxRTT; |
63 | ca->undo_old_maxB = ca->old_maxB; |
64 | |
65 | ca->last_cong = jiffies; |
66 | } |
67 | |
68 | static u32 htcp_cwnd_undo(struct sock *sk) |
69 | { |
70 | struct htcp *ca = inet_csk_ca(sk); |
71 | |
72 | if (ca->undo_last_cong) { |
73 | ca->last_cong = ca->undo_last_cong; |
74 | ca->maxRTT = ca->undo_maxRTT; |
75 | ca->old_maxB = ca->undo_old_maxB; |
76 | ca->undo_last_cong = 0; |
77 | } |
78 | |
79 | return tcp_reno_undo_cwnd(sk); |
80 | } |
81 | |
82 | static inline void measure_rtt(struct sock *sk, u32 srtt) |
83 | { |
84 | const struct inet_connection_sock *icsk = inet_csk(sk); |
85 | struct htcp *ca = inet_csk_ca(sk); |
86 | |
87 | /* keep track of minimum RTT seen so far, minRTT is zero at first */ |
88 | if (ca->minRTT > srtt || !ca->minRTT) |
89 | ca->minRTT = srtt; |
90 | |
91 | /* max RTT */ |
92 | if (icsk->icsk_ca_state == TCP_CA_Open) { |
93 | if (ca->maxRTT < ca->minRTT) |
94 | ca->maxRTT = ca->minRTT; |
95 | if (ca->maxRTT < srtt && |
96 | srtt <= ca->maxRTT + msecs_to_jiffies(m: 20)) |
97 | ca->maxRTT = srtt; |
98 | } |
99 | } |
100 | |
101 | static void measure_achieved_throughput(struct sock *sk, |
102 | const struct ack_sample *sample) |
103 | { |
104 | const struct inet_connection_sock *icsk = inet_csk(sk); |
105 | const struct tcp_sock *tp = tcp_sk(sk); |
106 | struct htcp *ca = inet_csk_ca(sk); |
107 | u32 now = tcp_jiffies32; |
108 | |
109 | if (icsk->icsk_ca_state == TCP_CA_Open) |
110 | ca->pkts_acked = sample->pkts_acked; |
111 | |
112 | if (sample->rtt_us > 0) |
113 | measure_rtt(sk, srtt: usecs_to_jiffies(u: sample->rtt_us)); |
114 | |
115 | if (!use_bandwidth_switch) |
116 | return; |
117 | |
118 | /* achieved throughput calculations */ |
119 | if (!((1 << icsk->icsk_ca_state) & (TCPF_CA_Open | TCPF_CA_Disorder))) { |
120 | ca->packetcount = 0; |
121 | ca->lasttime = now; |
122 | return; |
123 | } |
124 | |
125 | ca->packetcount += sample->pkts_acked; |
126 | |
127 | if (ca->packetcount >= tcp_snd_cwnd(tp) - (ca->alpha >> 7 ? : 1) && |
128 | now - ca->lasttime >= ca->minRTT && |
129 | ca->minRTT > 0) { |
130 | __u32 cur_Bi = ca->packetcount * HZ / (now - ca->lasttime); |
131 | |
132 | if (htcp_ccount(ca) <= 3) { |
133 | /* just after backoff */ |
134 | ca->minB = ca->maxB = ca->Bi = cur_Bi; |
135 | } else { |
136 | ca->Bi = (3 * ca->Bi + cur_Bi) / 4; |
137 | if (ca->Bi > ca->maxB) |
138 | ca->maxB = ca->Bi; |
139 | if (ca->minB > ca->maxB) |
140 | ca->minB = ca->maxB; |
141 | } |
142 | ca->packetcount = 0; |
143 | ca->lasttime = now; |
144 | } |
145 | } |
146 | |
147 | static inline void htcp_beta_update(struct htcp *ca, u32 minRTT, u32 maxRTT) |
148 | { |
149 | if (use_bandwidth_switch) { |
150 | u32 maxB = ca->maxB; |
151 | u32 old_maxB = ca->old_maxB; |
152 | |
153 | ca->old_maxB = ca->maxB; |
154 | if (!between(seq1: 5 * maxB, seq2: 4 * old_maxB, seq3: 6 * old_maxB)) { |
155 | ca->beta = BETA_MIN; |
156 | ca->modeswitch = 0; |
157 | return; |
158 | } |
159 | } |
160 | |
161 | if (ca->modeswitch && minRTT > msecs_to_jiffies(m: 10) && maxRTT) { |
162 | ca->beta = (minRTT << 7) / maxRTT; |
163 | if (ca->beta < BETA_MIN) |
164 | ca->beta = BETA_MIN; |
165 | else if (ca->beta > BETA_MAX) |
166 | ca->beta = BETA_MAX; |
167 | } else { |
168 | ca->beta = BETA_MIN; |
169 | ca->modeswitch = 1; |
170 | } |
171 | } |
172 | |
173 | static inline void htcp_alpha_update(struct htcp *ca) |
174 | { |
175 | u32 minRTT = ca->minRTT; |
176 | u32 factor = 1; |
177 | u32 diff = htcp_cong_time(ca); |
178 | |
179 | if (diff > HZ) { |
180 | diff -= HZ; |
181 | factor = 1 + (10 * diff + ((diff / 2) * (diff / 2) / HZ)) / HZ; |
182 | } |
183 | |
184 | if (use_rtt_scaling && minRTT) { |
185 | u32 scale = (HZ << 3) / (10 * minRTT); |
186 | |
187 | /* clamping ratio to interval [0.5,10]<<3 */ |
188 | scale = min(max(scale, 1U << 2), 10U << 3); |
189 | factor = (factor << 3) / scale; |
190 | if (!factor) |
191 | factor = 1; |
192 | } |
193 | |
194 | ca->alpha = 2 * factor * ((1 << 7) - ca->beta); |
195 | if (!ca->alpha) |
196 | ca->alpha = ALPHA_BASE; |
197 | } |
198 | |
199 | /* |
200 | * After we have the rtt data to calculate beta, we'd still prefer to wait one |
201 | * rtt before we adjust our beta to ensure we are working from a consistent |
202 | * data. |
203 | * |
204 | * This function should be called when we hit a congestion event since only at |
205 | * that point do we really have a real sense of maxRTT (the queues en route |
206 | * were getting just too full now). |
207 | */ |
208 | static void htcp_param_update(struct sock *sk) |
209 | { |
210 | struct htcp *ca = inet_csk_ca(sk); |
211 | u32 minRTT = ca->minRTT; |
212 | u32 maxRTT = ca->maxRTT; |
213 | |
214 | htcp_beta_update(ca, minRTT, maxRTT); |
215 | htcp_alpha_update(ca); |
216 | |
217 | /* add slowly fading memory for maxRTT to accommodate routing changes */ |
218 | if (minRTT > 0 && maxRTT > minRTT) |
219 | ca->maxRTT = minRTT + ((maxRTT - minRTT) * 95) / 100; |
220 | } |
221 | |
222 | static u32 htcp_recalc_ssthresh(struct sock *sk) |
223 | { |
224 | const struct tcp_sock *tp = tcp_sk(sk); |
225 | const struct htcp *ca = inet_csk_ca(sk); |
226 | |
227 | htcp_param_update(sk); |
228 | return max((tcp_snd_cwnd(tp) * ca->beta) >> 7, 2U); |
229 | } |
230 | |
231 | static void htcp_cong_avoid(struct sock *sk, u32 ack, u32 acked) |
232 | { |
233 | struct tcp_sock *tp = tcp_sk(sk); |
234 | struct htcp *ca = inet_csk_ca(sk); |
235 | |
236 | if (!tcp_is_cwnd_limited(sk)) |
237 | return; |
238 | |
239 | if (tcp_in_slow_start(tp)) |
240 | tcp_slow_start(tp, acked); |
241 | else { |
242 | /* In dangerous area, increase slowly. |
243 | * In theory this is tp->snd_cwnd += alpha / tp->snd_cwnd |
244 | */ |
245 | if ((tp->snd_cwnd_cnt * ca->alpha)>>7 >= tcp_snd_cwnd(tp)) { |
246 | if (tcp_snd_cwnd(tp) < tp->snd_cwnd_clamp) |
247 | tcp_snd_cwnd_set(tp, val: tcp_snd_cwnd(tp) + 1); |
248 | tp->snd_cwnd_cnt = 0; |
249 | htcp_alpha_update(ca); |
250 | } else |
251 | tp->snd_cwnd_cnt += ca->pkts_acked; |
252 | |
253 | ca->pkts_acked = 1; |
254 | } |
255 | } |
256 | |
257 | static void htcp_init(struct sock *sk) |
258 | { |
259 | struct htcp *ca = inet_csk_ca(sk); |
260 | |
261 | memset(ca, 0, sizeof(struct htcp)); |
262 | ca->alpha = ALPHA_BASE; |
263 | ca->beta = BETA_MIN; |
264 | ca->pkts_acked = 1; |
265 | ca->last_cong = jiffies; |
266 | } |
267 | |
268 | static void htcp_state(struct sock *sk, u8 new_state) |
269 | { |
270 | switch (new_state) { |
271 | case TCP_CA_Open: |
272 | { |
273 | struct htcp *ca = inet_csk_ca(sk); |
274 | |
275 | if (ca->undo_last_cong) { |
276 | ca->last_cong = jiffies; |
277 | ca->undo_last_cong = 0; |
278 | } |
279 | } |
280 | break; |
281 | case TCP_CA_CWR: |
282 | case TCP_CA_Recovery: |
283 | case TCP_CA_Loss: |
284 | htcp_reset(ca: inet_csk_ca(sk)); |
285 | break; |
286 | } |
287 | } |
288 | |
289 | static struct tcp_congestion_ops htcp __read_mostly = { |
290 | .init = htcp_init, |
291 | .ssthresh = htcp_recalc_ssthresh, |
292 | .cong_avoid = htcp_cong_avoid, |
293 | .set_state = htcp_state, |
294 | .undo_cwnd = htcp_cwnd_undo, |
295 | .pkts_acked = measure_achieved_throughput, |
296 | .owner = THIS_MODULE, |
297 | .name = "htcp" , |
298 | }; |
299 | |
300 | static int __init htcp_register(void) |
301 | { |
302 | BUILD_BUG_ON(sizeof(struct htcp) > ICSK_CA_PRIV_SIZE); |
303 | BUILD_BUG_ON(BETA_MIN >= BETA_MAX); |
304 | return tcp_register_congestion_control(type: &htcp); |
305 | } |
306 | |
307 | static void __exit htcp_unregister(void) |
308 | { |
309 | tcp_unregister_congestion_control(type: &htcp); |
310 | } |
311 | |
312 | module_init(htcp_register); |
313 | module_exit(htcp_unregister); |
314 | |
315 | MODULE_AUTHOR("Baruch Even" ); |
316 | MODULE_LICENSE("GPL" ); |
317 | MODULE_DESCRIPTION("H-TCP" ); |
318 | |