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