1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * TCP HYBLA |
4 | * |
5 | * TCP-HYBLA Congestion control algorithm, based on: |
6 | * C.Caini, R.Firrincieli, "TCP-Hybla: A TCP Enhancement |
7 | * for Heterogeneous Networks", |
8 | * International Journal on satellite Communications, |
9 | * September 2004 |
10 | * Daniele Lacamera |
11 | * root at danielinux.net |
12 | */ |
13 | |
14 | #include <linux/module.h> |
15 | #include <net/tcp.h> |
16 | |
17 | /* Tcp Hybla structure. */ |
18 | struct hybla { |
19 | bool hybla_en; |
20 | u32 snd_cwnd_cents; /* Keeps increment values when it is <1, <<7 */ |
21 | u32 rho; /* Rho parameter, integer part */ |
22 | u32 rho2; /* Rho * Rho, integer part */ |
23 | u32 rho_3ls; /* Rho parameter, <<3 */ |
24 | u32 rho2_7ls; /* Rho^2, <<7 */ |
25 | u32 minrtt_us; /* Minimum smoothed round trip time value seen */ |
26 | }; |
27 | |
28 | /* Hybla reference round trip time (default= 1/40 sec = 25 ms), in ms */ |
29 | static int rtt0 = 25; |
30 | module_param(rtt0, int, 0644); |
31 | MODULE_PARM_DESC(rtt0, "reference rout trip time (ms)" ); |
32 | |
33 | /* This is called to refresh values for hybla parameters */ |
34 | static inline void hybla_recalc_param (struct sock *sk) |
35 | { |
36 | struct hybla *ca = inet_csk_ca(sk); |
37 | |
38 | ca->rho_3ls = max_t(u32, |
39 | tcp_sk(sk)->srtt_us / (rtt0 * USEC_PER_MSEC), |
40 | 8U); |
41 | ca->rho = ca->rho_3ls >> 3; |
42 | ca->rho2_7ls = (ca->rho_3ls * ca->rho_3ls) << 1; |
43 | ca->rho2 = ca->rho2_7ls >> 7; |
44 | } |
45 | |
46 | static void hybla_init(struct sock *sk) |
47 | { |
48 | struct tcp_sock *tp = tcp_sk(sk); |
49 | struct hybla *ca = inet_csk_ca(sk); |
50 | |
51 | ca->rho = 0; |
52 | ca->rho2 = 0; |
53 | ca->rho_3ls = 0; |
54 | ca->rho2_7ls = 0; |
55 | ca->snd_cwnd_cents = 0; |
56 | ca->hybla_en = true; |
57 | tcp_snd_cwnd_set(tp, val: 2); |
58 | tp->snd_cwnd_clamp = 65535; |
59 | |
60 | /* 1st Rho measurement based on initial srtt */ |
61 | hybla_recalc_param(sk); |
62 | |
63 | /* set minimum rtt as this is the 1st ever seen */ |
64 | ca->minrtt_us = tp->srtt_us; |
65 | tcp_snd_cwnd_set(tp, val: ca->rho); |
66 | } |
67 | |
68 | static void hybla_state(struct sock *sk, u8 ca_state) |
69 | { |
70 | struct hybla *ca = inet_csk_ca(sk); |
71 | |
72 | ca->hybla_en = (ca_state == TCP_CA_Open); |
73 | } |
74 | |
75 | static inline u32 hybla_fraction(u32 odds) |
76 | { |
77 | static const u32 fractions[] = { |
78 | 128, 139, 152, 165, 181, 197, 215, 234, |
79 | }; |
80 | |
81 | return (odds < ARRAY_SIZE(fractions)) ? fractions[odds] : 128; |
82 | } |
83 | |
84 | /* TCP Hybla main routine. |
85 | * This is the algorithm behavior: |
86 | * o Recalc Hybla parameters if min_rtt has changed |
87 | * o Give cwnd a new value based on the model proposed |
88 | * o remember increments <1 |
89 | */ |
90 | static void hybla_cong_avoid(struct sock *sk, u32 ack, u32 acked) |
91 | { |
92 | struct tcp_sock *tp = tcp_sk(sk); |
93 | struct hybla *ca = inet_csk_ca(sk); |
94 | u32 increment, odd, rho_fractions; |
95 | int is_slowstart = 0; |
96 | |
97 | /* Recalculate rho only if this srtt is the lowest */ |
98 | if (tp->srtt_us < ca->minrtt_us) { |
99 | hybla_recalc_param(sk); |
100 | ca->minrtt_us = tp->srtt_us; |
101 | } |
102 | |
103 | if (!tcp_is_cwnd_limited(sk)) |
104 | return; |
105 | |
106 | if (!ca->hybla_en) { |
107 | tcp_reno_cong_avoid(sk, ack, acked); |
108 | return; |
109 | } |
110 | |
111 | if (ca->rho == 0) |
112 | hybla_recalc_param(sk); |
113 | |
114 | rho_fractions = ca->rho_3ls - (ca->rho << 3); |
115 | |
116 | if (tcp_in_slow_start(tp)) { |
117 | /* |
118 | * slow start |
119 | * INC = 2^RHO - 1 |
120 | * This is done by splitting the rho parameter |
121 | * into 2 parts: an integer part and a fraction part. |
122 | * Inrement<<7 is estimated by doing: |
123 | * [2^(int+fract)]<<7 |
124 | * that is equal to: |
125 | * (2^int) * [(2^fract) <<7] |
126 | * 2^int is straightly computed as 1<<int, |
127 | * while we will use hybla_slowstart_fraction_increment() to |
128 | * calculate 2^fract in a <<7 value. |
129 | */ |
130 | is_slowstart = 1; |
131 | increment = ((1 << min(ca->rho, 16U)) * |
132 | hybla_fraction(odds: rho_fractions)) - 128; |
133 | } else { |
134 | /* |
135 | * congestion avoidance |
136 | * INC = RHO^2 / W |
137 | * as long as increment is estimated as (rho<<7)/window |
138 | * it already is <<7 and we can easily count its fractions. |
139 | */ |
140 | increment = ca->rho2_7ls / tcp_snd_cwnd(tp); |
141 | if (increment < 128) |
142 | tp->snd_cwnd_cnt++; |
143 | } |
144 | |
145 | odd = increment % 128; |
146 | tcp_snd_cwnd_set(tp, val: tcp_snd_cwnd(tp) + (increment >> 7)); |
147 | ca->snd_cwnd_cents += odd; |
148 | |
149 | /* check when fractions goes >=128 and increase cwnd by 1. */ |
150 | while (ca->snd_cwnd_cents >= 128) { |
151 | tcp_snd_cwnd_set(tp, val: tcp_snd_cwnd(tp) + 1); |
152 | ca->snd_cwnd_cents -= 128; |
153 | tp->snd_cwnd_cnt = 0; |
154 | } |
155 | /* check when cwnd has not been incremented for a while */ |
156 | if (increment == 0 && odd == 0 && tp->snd_cwnd_cnt >= tcp_snd_cwnd(tp)) { |
157 | tcp_snd_cwnd_set(tp, val: tcp_snd_cwnd(tp) + 1); |
158 | tp->snd_cwnd_cnt = 0; |
159 | } |
160 | /* clamp down slowstart cwnd to ssthresh value. */ |
161 | if (is_slowstart) |
162 | tcp_snd_cwnd_set(tp, min(tcp_snd_cwnd(tp), tp->snd_ssthresh)); |
163 | |
164 | tcp_snd_cwnd_set(tp, min(tcp_snd_cwnd(tp), tp->snd_cwnd_clamp)); |
165 | } |
166 | |
167 | static struct tcp_congestion_ops tcp_hybla __read_mostly = { |
168 | .init = hybla_init, |
169 | .ssthresh = tcp_reno_ssthresh, |
170 | .undo_cwnd = tcp_reno_undo_cwnd, |
171 | .cong_avoid = hybla_cong_avoid, |
172 | .set_state = hybla_state, |
173 | |
174 | .owner = THIS_MODULE, |
175 | .name = "hybla" |
176 | }; |
177 | |
178 | static int __init hybla_register(void) |
179 | { |
180 | BUILD_BUG_ON(sizeof(struct hybla) > ICSK_CA_PRIV_SIZE); |
181 | return tcp_register_congestion_control(type: &tcp_hybla); |
182 | } |
183 | |
184 | static void __exit hybla_unregister(void) |
185 | { |
186 | tcp_unregister_congestion_control(type: &tcp_hybla); |
187 | } |
188 | |
189 | module_init(hybla_register); |
190 | module_exit(hybla_unregister); |
191 | |
192 | MODULE_AUTHOR("Daniele Lacamera" ); |
193 | MODULE_LICENSE("GPL" ); |
194 | MODULE_DESCRIPTION("TCP Hybla" ); |
195 | |