PageRenderTime 57ms CodeModel.GetById 17ms app.highlight 33ms RepoModel.GetById 2ms app.codeStats 0ms

/net/ipv4/tcp_yeah.c

http://github.com/mirrors/linux
C | 239 lines | 134 code | 44 blank | 61 comment | 13 complexity | adbe7bf63fb9c205d084f8a7bfee3a37 MD5 | raw file
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 *
  4 *   YeAH TCP
  5 *
  6 * For further details look at:
  7 *   https://web.archive.org/web/20080316215752/http://wil.cs.caltech.edu/pfldnet2007/paper/YeAH_TCP.pdf
  8 *
  9 */
 10#include <linux/mm.h>
 11#include <linux/module.h>
 12#include <linux/skbuff.h>
 13#include <linux/inet_diag.h>
 14
 15#include <net/tcp.h>
 16
 17#include "tcp_vegas.h"
 18
 19#define TCP_YEAH_ALPHA       80 /* number of packets queued at the bottleneck */
 20#define TCP_YEAH_GAMMA        1 /* fraction of queue to be removed per rtt */
 21#define TCP_YEAH_DELTA        3 /* log minimum fraction of cwnd to be removed on loss */
 22#define TCP_YEAH_EPSILON      1 /* log maximum fraction to be removed on early decongestion */
 23#define TCP_YEAH_PHY          8 /* maximum delta from base */
 24#define TCP_YEAH_RHO         16 /* minimum number of consecutive rtt to consider competition on loss */
 25#define TCP_YEAH_ZETA        50 /* minimum number of state switches to reset reno_count */
 26
 27#define TCP_SCALABLE_AI_CNT	 100U
 28
 29/* YeAH variables */
 30struct yeah {
 31	struct vegas vegas;	/* must be first */
 32
 33	/* YeAH */
 34	u32 lastQ;
 35	u32 doing_reno_now;
 36
 37	u32 reno_count;
 38	u32 fast_count;
 39};
 40
 41static void tcp_yeah_init(struct sock *sk)
 42{
 43	struct tcp_sock *tp = tcp_sk(sk);
 44	struct yeah *yeah = inet_csk_ca(sk);
 45
 46	tcp_vegas_init(sk);
 47
 48	yeah->doing_reno_now = 0;
 49	yeah->lastQ = 0;
 50
 51	yeah->reno_count = 2;
 52
 53	/* Ensure the MD arithmetic works.  This is somewhat pedantic,
 54	 * since I don't think we will see a cwnd this large. :) */
 55	tp->snd_cwnd_clamp = min_t(u32, tp->snd_cwnd_clamp, 0xffffffff/128);
 56}
 57
 58static void tcp_yeah_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 59{
 60	struct tcp_sock *tp = tcp_sk(sk);
 61	struct yeah *yeah = inet_csk_ca(sk);
 62
 63	if (!tcp_is_cwnd_limited(sk))
 64		return;
 65
 66	if (tcp_in_slow_start(tp)) {
 67		acked = tcp_slow_start(tp, acked);
 68		if (!acked)
 69			goto do_vegas;
 70	}
 71
 72	if (!yeah->doing_reno_now) {
 73		/* Scalable */
 74		tcp_cong_avoid_ai(tp, min(tp->snd_cwnd, TCP_SCALABLE_AI_CNT),
 75				  acked);
 76	} else {
 77		/* Reno */
 78		tcp_cong_avoid_ai(tp, tp->snd_cwnd, acked);
 79	}
 80
 81	/* The key players are v_vegas.beg_snd_una and v_beg_snd_nxt.
 82	 *
 83	 * These are so named because they represent the approximate values
 84	 * of snd_una and snd_nxt at the beginning of the current RTT. More
 85	 * precisely, they represent the amount of data sent during the RTT.
 86	 * At the end of the RTT, when we receive an ACK for v_beg_snd_nxt,
 87	 * we will calculate that (v_beg_snd_nxt - v_vegas.beg_snd_una) outstanding
 88	 * bytes of data have been ACKed during the course of the RTT, giving
 89	 * an "actual" rate of:
 90	 *
 91	 *     (v_beg_snd_nxt - v_vegas.beg_snd_una) / (rtt duration)
 92	 *
 93	 * Unfortunately, v_vegas.beg_snd_una is not exactly equal to snd_una,
 94	 * because delayed ACKs can cover more than one segment, so they
 95	 * don't line up yeahly with the boundaries of RTTs.
 96	 *
 97	 * Another unfortunate fact of life is that delayed ACKs delay the
 98	 * advance of the left edge of our send window, so that the number
 99	 * of bytes we send in an RTT is often less than our cwnd will allow.
100	 * So we keep track of our cwnd separately, in v_beg_snd_cwnd.
101	 */
102do_vegas:
103	if (after(ack, yeah->vegas.beg_snd_nxt)) {
104		/* We do the Vegas calculations only if we got enough RTT
105		 * samples that we can be reasonably sure that we got
106		 * at least one RTT sample that wasn't from a delayed ACK.
107		 * If we only had 2 samples total,
108		 * then that means we're getting only 1 ACK per RTT, which
109		 * means they're almost certainly delayed ACKs.
110		 * If  we have 3 samples, we should be OK.
111		 */
112
113		if (yeah->vegas.cntRTT > 2) {
114			u32 rtt, queue;
115			u64 bw;
116
117			/* We have enough RTT samples, so, using the Vegas
118			 * algorithm, we determine if we should increase or
119			 * decrease cwnd, and by how much.
120			 */
121
122			/* Pluck out the RTT we are using for the Vegas
123			 * calculations. This is the min RTT seen during the
124			 * last RTT. Taking the min filters out the effects
125			 * of delayed ACKs, at the cost of noticing congestion
126			 * a bit later.
127			 */
128			rtt = yeah->vegas.minRTT;
129
130			/* Compute excess number of packets above bandwidth
131			 * Avoid doing full 64 bit divide.
132			 */
133			bw = tp->snd_cwnd;
134			bw *= rtt - yeah->vegas.baseRTT;
135			do_div(bw, rtt);
136			queue = bw;
137
138			if (queue > TCP_YEAH_ALPHA ||
139			    rtt - yeah->vegas.baseRTT > (yeah->vegas.baseRTT / TCP_YEAH_PHY)) {
140				if (queue > TCP_YEAH_ALPHA &&
141				    tp->snd_cwnd > yeah->reno_count) {
142					u32 reduction = min(queue / TCP_YEAH_GAMMA ,
143							    tp->snd_cwnd >> TCP_YEAH_EPSILON);
144
145					tp->snd_cwnd -= reduction;
146
147					tp->snd_cwnd = max(tp->snd_cwnd,
148							   yeah->reno_count);
149
150					tp->snd_ssthresh = tp->snd_cwnd;
151				}
152
153				if (yeah->reno_count <= 2)
154					yeah->reno_count = max(tp->snd_cwnd>>1, 2U);
155				else
156					yeah->reno_count++;
157
158				yeah->doing_reno_now = min(yeah->doing_reno_now + 1,
159							   0xffffffU);
160			} else {
161				yeah->fast_count++;
162
163				if (yeah->fast_count > TCP_YEAH_ZETA) {
164					yeah->reno_count = 2;
165					yeah->fast_count = 0;
166				}
167
168				yeah->doing_reno_now = 0;
169			}
170
171			yeah->lastQ = queue;
172		}
173
174		/* Save the extent of the current window so we can use this
175		 * at the end of the next RTT.
176		 */
177		yeah->vegas.beg_snd_una  = yeah->vegas.beg_snd_nxt;
178		yeah->vegas.beg_snd_nxt  = tp->snd_nxt;
179		yeah->vegas.beg_snd_cwnd = tp->snd_cwnd;
180
181		/* Wipe the slate clean for the next RTT. */
182		yeah->vegas.cntRTT = 0;
183		yeah->vegas.minRTT = 0x7fffffff;
184	}
185}
186
187static u32 tcp_yeah_ssthresh(struct sock *sk)
188{
189	const struct tcp_sock *tp = tcp_sk(sk);
190	struct yeah *yeah = inet_csk_ca(sk);
191	u32 reduction;
192
193	if (yeah->doing_reno_now < TCP_YEAH_RHO) {
194		reduction = yeah->lastQ;
195
196		reduction = min(reduction, max(tp->snd_cwnd>>1, 2U));
197
198		reduction = max(reduction, tp->snd_cwnd >> TCP_YEAH_DELTA);
199	} else
200		reduction = max(tp->snd_cwnd>>1, 2U);
201
202	yeah->fast_count = 0;
203	yeah->reno_count = max(yeah->reno_count>>1, 2U);
204
205	return max_t(int, tp->snd_cwnd - reduction, 2);
206}
207
208static struct tcp_congestion_ops tcp_yeah __read_mostly = {
209	.init		= tcp_yeah_init,
210	.ssthresh	= tcp_yeah_ssthresh,
211	.undo_cwnd      = tcp_reno_undo_cwnd,
212	.cong_avoid	= tcp_yeah_cong_avoid,
213	.set_state	= tcp_vegas_state,
214	.cwnd_event	= tcp_vegas_cwnd_event,
215	.get_info	= tcp_vegas_get_info,
216	.pkts_acked	= tcp_vegas_pkts_acked,
217
218	.owner		= THIS_MODULE,
219	.name		= "yeah",
220};
221
222static int __init tcp_yeah_register(void)
223{
224	BUG_ON(sizeof(struct yeah) > ICSK_CA_PRIV_SIZE);
225	tcp_register_congestion_control(&tcp_yeah);
226	return 0;
227}
228
229static void __exit tcp_yeah_unregister(void)
230{
231	tcp_unregister_congestion_control(&tcp_yeah);
232}
233
234module_init(tcp_yeah_register);
235module_exit(tcp_yeah_unregister);
236
237MODULE_AUTHOR("Angelo P. Castellani");
238MODULE_LICENSE("GPL");
239MODULE_DESCRIPTION("YeAH TCP");