1df3271f3SStephen Hemminger /* 2e1c3e7abSStephen Hemminger * TCP CUBIC: Binary Increase Congestion control for TCP v2.1 3df3271f3SStephen Hemminger * 4df3271f3SStephen Hemminger * This is from the implementation of CUBIC TCP in 5df3271f3SStephen Hemminger * Injong Rhee, Lisong Xu. 6df3271f3SStephen Hemminger * "CUBIC: A New TCP-Friendly High-Speed TCP Variant 7df3271f3SStephen Hemminger * in PFLDnet 2005 8df3271f3SStephen Hemminger * Available from: 9df3271f3SStephen Hemminger * http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/cubic-paper.pdf 10df3271f3SStephen Hemminger * 11df3271f3SStephen Hemminger * Unless CUBIC is enabled and congestion window is large 12df3271f3SStephen Hemminger * this behaves the same as the original Reno. 13df3271f3SStephen Hemminger */ 14df3271f3SStephen Hemminger 15df3271f3SStephen Hemminger #include <linux/mm.h> 16df3271f3SStephen Hemminger #include <linux/module.h> 17df3271f3SStephen Hemminger #include <net/tcp.h> 1889b3d9aaSStephen Hemminger #include <asm/div64.h> 19df3271f3SStephen Hemminger 20df3271f3SStephen Hemminger #define BICTCP_BETA_SCALE 1024 /* Scale factor beta calculation 21df3271f3SStephen Hemminger * max_cwnd = snd_cwnd * beta 22df3271f3SStephen Hemminger */ 23df3271f3SStephen Hemminger #define BICTCP_B 4 /* 24df3271f3SStephen Hemminger * In binary search, 25df3271f3SStephen Hemminger * go to point (max+min)/N 26df3271f3SStephen Hemminger */ 27df3271f3SStephen Hemminger #define BICTCP_HZ 10 /* BIC HZ 2^10 = 1024 */ 28df3271f3SStephen Hemminger 2959758f44SStephen Hemminger static int fast_convergence __read_mostly = 1; 3059758f44SStephen Hemminger static int max_increment __read_mostly = 16; 3159758f44SStephen Hemminger static int beta __read_mostly = 819; /* = 819/1024 (BICTCP_BETA_SCALE) */ 3266e1e3b2SDavid S. Miller static int initial_ssthresh __read_mostly; 3359758f44SStephen Hemminger static int bic_scale __read_mostly = 41; 3459758f44SStephen Hemminger static int tcp_friendliness __read_mostly = 1; 35df3271f3SStephen Hemminger 3659758f44SStephen Hemminger static u32 cube_rtt_scale __read_mostly; 3759758f44SStephen Hemminger static u32 beta_scale __read_mostly; 3859758f44SStephen Hemminger static u64 cube_factor __read_mostly; 3989b3d9aaSStephen Hemminger 4089b3d9aaSStephen Hemminger /* Note parameters that are used for precomputing scale factors are read-only */ 41df3271f3SStephen Hemminger module_param(fast_convergence, int, 0644); 42df3271f3SStephen Hemminger MODULE_PARM_DESC(fast_convergence, "turn on/off fast convergence"); 43df3271f3SStephen Hemminger module_param(max_increment, int, 0644); 44df3271f3SStephen Hemminger MODULE_PARM_DESC(max_increment, "Limit on increment allowed during binary search"); 4589b3d9aaSStephen Hemminger module_param(beta, int, 0444); 46df3271f3SStephen Hemminger MODULE_PARM_DESC(beta, "beta for multiplicative increase"); 47df3271f3SStephen Hemminger module_param(initial_ssthresh, int, 0644); 48df3271f3SStephen Hemminger MODULE_PARM_DESC(initial_ssthresh, "initial value of slow start threshold"); 4989b3d9aaSStephen Hemminger module_param(bic_scale, int, 0444); 50df3271f3SStephen Hemminger MODULE_PARM_DESC(bic_scale, "scale (scaled by 1024) value for bic function (bic_scale/1024)"); 51df3271f3SStephen Hemminger module_param(tcp_friendliness, int, 0644); 52df3271f3SStephen Hemminger MODULE_PARM_DESC(tcp_friendliness, "turn on/off tcp friendliness"); 53df3271f3SStephen Hemminger 54df3271f3SStephen Hemminger /* BIC TCP Parameters */ 55df3271f3SStephen Hemminger struct bictcp { 56df3271f3SStephen Hemminger u32 cnt; /* increase cwnd by 1 after ACKs */ 57df3271f3SStephen Hemminger u32 last_max_cwnd; /* last maximum snd_cwnd */ 58df3271f3SStephen Hemminger u32 loss_cwnd; /* congestion window at last loss */ 59df3271f3SStephen Hemminger u32 last_cwnd; /* the last snd_cwnd */ 60df3271f3SStephen Hemminger u32 last_time; /* time when updated last_cwnd */ 61df3271f3SStephen Hemminger u32 bic_origin_point;/* origin point of bic function */ 62df3271f3SStephen Hemminger u32 bic_K; /* time to origin point from the beginning of the current epoch */ 63df3271f3SStephen Hemminger u32 delay_min; /* min delay */ 64df3271f3SStephen Hemminger u32 epoch_start; /* beginning of an epoch */ 65df3271f3SStephen Hemminger u32 ack_cnt; /* number of acks */ 66df3271f3SStephen Hemminger u32 tcp_cwnd; /* estimated tcp cwnd */ 67df3271f3SStephen Hemminger #define ACK_RATIO_SHIFT 4 68df3271f3SStephen Hemminger u32 delayed_ack; /* estimate the ratio of Packets/ACKs << 4 */ 69df3271f3SStephen Hemminger }; 70df3271f3SStephen Hemminger 71df3271f3SStephen Hemminger static inline void bictcp_reset(struct bictcp *ca) 72df3271f3SStephen Hemminger { 73df3271f3SStephen Hemminger ca->cnt = 0; 74df3271f3SStephen Hemminger ca->last_max_cwnd = 0; 75df3271f3SStephen Hemminger ca->loss_cwnd = 0; 76df3271f3SStephen Hemminger ca->last_cwnd = 0; 77df3271f3SStephen Hemminger ca->last_time = 0; 78df3271f3SStephen Hemminger ca->bic_origin_point = 0; 79df3271f3SStephen Hemminger ca->bic_K = 0; 80df3271f3SStephen Hemminger ca->delay_min = 0; 81df3271f3SStephen Hemminger ca->epoch_start = 0; 82df3271f3SStephen Hemminger ca->delayed_ack = 2 << ACK_RATIO_SHIFT; 83df3271f3SStephen Hemminger ca->ack_cnt = 0; 84df3271f3SStephen Hemminger ca->tcp_cwnd = 0; 85df3271f3SStephen Hemminger } 86df3271f3SStephen Hemminger 87df3271f3SStephen Hemminger static void bictcp_init(struct sock *sk) 88df3271f3SStephen Hemminger { 89df3271f3SStephen Hemminger bictcp_reset(inet_csk_ca(sk)); 90df3271f3SStephen Hemminger if (initial_ssthresh) 91df3271f3SStephen Hemminger tcp_sk(sk)->snd_ssthresh = initial_ssthresh; 92df3271f3SStephen Hemminger } 93df3271f3SStephen Hemminger 947e58886bSStephen Hemminger /* calculate the cubic root of x using a table lookup followed by one 957e58886bSStephen Hemminger * Newton-Raphson iteration. 967e58886bSStephen Hemminger * Avg err ~= 0.195% 97df3271f3SStephen Hemminger */ 989eb2d627SStephen Hemminger static u32 cubic_root(u64 a) 99df3271f3SStephen Hemminger { 1007e58886bSStephen Hemminger u32 x, b, shift; 1017e58886bSStephen Hemminger /* 1027e58886bSStephen Hemminger * cbrt(x) MSB values for x MSB values in [0..63]. 1037e58886bSStephen Hemminger * Precomputed then refined by hand - Willy Tarreau 1047e58886bSStephen Hemminger * 1057e58886bSStephen Hemminger * For x in [0..63], 1067e58886bSStephen Hemminger * v = cbrt(x << 18) - 1 1077e58886bSStephen Hemminger * cbrt(x) = (v[x] + 10) >> 6 1089eb2d627SStephen Hemminger */ 1097e58886bSStephen Hemminger static const u8 v[] = { 1107e58886bSStephen Hemminger /* 0x00 */ 0, 54, 54, 54, 118, 118, 118, 118, 1117e58886bSStephen Hemminger /* 0x08 */ 123, 129, 134, 138, 143, 147, 151, 156, 1127e58886bSStephen Hemminger /* 0x10 */ 157, 161, 164, 168, 170, 173, 176, 179, 1137e58886bSStephen Hemminger /* 0x18 */ 181, 185, 187, 190, 192, 194, 197, 199, 1147e58886bSStephen Hemminger /* 0x20 */ 200, 202, 204, 206, 209, 211, 213, 215, 1157e58886bSStephen Hemminger /* 0x28 */ 217, 219, 221, 222, 224, 225, 227, 229, 1167e58886bSStephen Hemminger /* 0x30 */ 231, 232, 234, 236, 237, 239, 240, 242, 1177e58886bSStephen Hemminger /* 0x38 */ 244, 245, 246, 248, 250, 251, 252, 254, 1187e58886bSStephen Hemminger }; 119df3271f3SStephen Hemminger 1207e58886bSStephen Hemminger b = fls64(a); 1217e58886bSStephen Hemminger if (b < 7) { 1227e58886bSStephen Hemminger /* a in [0..63] */ 1237e58886bSStephen Hemminger return ((u32)v[(u32)a] + 35) >> 6; 1247e58886bSStephen Hemminger } 125df3271f3SStephen Hemminger 1267e58886bSStephen Hemminger b = ((b * 84) >> 8) - 1; 1277e58886bSStephen Hemminger shift = (a >> (b * 3)); 1287e58886bSStephen Hemminger 1297e58886bSStephen Hemminger x = ((u32)(((u32)v[shift] + 10) << b)) >> 6; 1307e58886bSStephen Hemminger 1317e58886bSStephen Hemminger /* 1327e58886bSStephen Hemminger * Newton-Raphson iteration 1337e58886bSStephen Hemminger * 2 1347e58886bSStephen Hemminger * x = ( 2 * x + a / x ) / 3 1357e58886bSStephen Hemminger * k+1 k k 1367e58886bSStephen Hemminger */ 1377e58886bSStephen Hemminger x = (2 * x + (u32)div64_64(a, (u64)x * (u64)(x - 1))); 1387e58886bSStephen Hemminger x = ((x * 341) >> 10); 1399eb2d627SStephen Hemminger return x; 140df3271f3SStephen Hemminger } 141df3271f3SStephen Hemminger 142df3271f3SStephen Hemminger /* 143df3271f3SStephen Hemminger * Compute congestion window to use. 144df3271f3SStephen Hemminger */ 145df3271f3SStephen Hemminger static inline void bictcp_update(struct bictcp *ca, u32 cwnd) 146df3271f3SStephen Hemminger { 14789b3d9aaSStephen Hemminger u64 offs; 14889b3d9aaSStephen Hemminger u32 delta, t, bic_target, min_cnt, max_cnt; 149df3271f3SStephen Hemminger 150df3271f3SStephen Hemminger ca->ack_cnt++; /* count the number of ACKs */ 151df3271f3SStephen Hemminger 152df3271f3SStephen Hemminger if (ca->last_cwnd == cwnd && 153df3271f3SStephen Hemminger (s32)(tcp_time_stamp - ca->last_time) <= HZ / 32) 154df3271f3SStephen Hemminger return; 155df3271f3SStephen Hemminger 156df3271f3SStephen Hemminger ca->last_cwnd = cwnd; 157df3271f3SStephen Hemminger ca->last_time = tcp_time_stamp; 158df3271f3SStephen Hemminger 159df3271f3SStephen Hemminger if (ca->epoch_start == 0) { 160df3271f3SStephen Hemminger ca->epoch_start = tcp_time_stamp; /* record the beginning of an epoch */ 161df3271f3SStephen Hemminger ca->ack_cnt = 1; /* start counting */ 162df3271f3SStephen Hemminger ca->tcp_cwnd = cwnd; /* syn with cubic */ 163df3271f3SStephen Hemminger 164df3271f3SStephen Hemminger if (ca->last_max_cwnd <= cwnd) { 165df3271f3SStephen Hemminger ca->bic_K = 0; 166df3271f3SStephen Hemminger ca->bic_origin_point = cwnd; 167df3271f3SStephen Hemminger } else { 16889b3d9aaSStephen Hemminger /* Compute new K based on 16989b3d9aaSStephen Hemminger * (wmax-cwnd) * (srtt>>3 / HZ) / c * 2^(3*bictcp_HZ) 17089b3d9aaSStephen Hemminger */ 17189b3d9aaSStephen Hemminger ca->bic_K = cubic_root(cube_factor 17289b3d9aaSStephen Hemminger * (ca->last_max_cwnd - cwnd)); 173df3271f3SStephen Hemminger ca->bic_origin_point = ca->last_max_cwnd; 174df3271f3SStephen Hemminger } 175df3271f3SStephen Hemminger } 176df3271f3SStephen Hemminger 177df3271f3SStephen Hemminger /* cubic function - calc*/ 178df3271f3SStephen Hemminger /* calculate c * time^3 / rtt, 179df3271f3SStephen Hemminger * while considering overflow in calculation of time^3 18089b3d9aaSStephen Hemminger * (so time^3 is done by using 64 bit) 181df3271f3SStephen Hemminger * and without the support of division of 64bit numbers 18289b3d9aaSStephen Hemminger * (so all divisions are done by using 32 bit) 183df3271f3SStephen Hemminger * also NOTE the unit of those veriables 184df3271f3SStephen Hemminger * time = (t - K) / 2^bictcp_HZ 185df3271f3SStephen Hemminger * c = bic_scale >> 10 186df3271f3SStephen Hemminger * rtt = (srtt >> 3) / HZ 187df3271f3SStephen Hemminger * !!! The following code does not have overflow problems, 188df3271f3SStephen Hemminger * if the cwnd < 1 million packets !!! 189df3271f3SStephen Hemminger */ 190df3271f3SStephen Hemminger 191df3271f3SStephen Hemminger /* change the unit from HZ to bictcp_HZ */ 19222119240SStephen Hemminger t = ((tcp_time_stamp + (ca->delay_min>>3) - ca->epoch_start) 193df3271f3SStephen Hemminger << BICTCP_HZ) / HZ; 194df3271f3SStephen Hemminger 195df3271f3SStephen Hemminger if (t < ca->bic_K) /* t - K */ 19689b3d9aaSStephen Hemminger offs = ca->bic_K - t; 197df3271f3SStephen Hemminger else 19889b3d9aaSStephen Hemminger offs = t - ca->bic_K; 199df3271f3SStephen Hemminger 20089b3d9aaSStephen Hemminger /* c/rtt * (t-K)^3 */ 20189b3d9aaSStephen Hemminger delta = (cube_rtt_scale * offs * offs * offs) >> (10+3*BICTCP_HZ); 202df3271f3SStephen Hemminger if (t < ca->bic_K) /* below origin*/ 20389b3d9aaSStephen Hemminger bic_target = ca->bic_origin_point - delta; 204df3271f3SStephen Hemminger else /* above origin*/ 20589b3d9aaSStephen Hemminger bic_target = ca->bic_origin_point + delta; 206df3271f3SStephen Hemminger 207df3271f3SStephen Hemminger /* cubic function - calc bictcp_cnt*/ 208df3271f3SStephen Hemminger if (bic_target > cwnd) { 209df3271f3SStephen Hemminger ca->cnt = cwnd / (bic_target - cwnd); 210df3271f3SStephen Hemminger } else { 211df3271f3SStephen Hemminger ca->cnt = 100 * cwnd; /* very small increment*/ 212df3271f3SStephen Hemminger } 213df3271f3SStephen Hemminger 214df3271f3SStephen Hemminger if (ca->delay_min > 0) { 215df3271f3SStephen Hemminger /* max increment = Smax * rtt / 0.1 */ 216df3271f3SStephen Hemminger min_cnt = (cwnd * HZ * 8)/(10 * max_increment * ca->delay_min); 217e1c3e7abSStephen Hemminger 218e1c3e7abSStephen Hemminger /* use concave growth when the target is above the origin */ 219e1c3e7abSStephen Hemminger if (ca->cnt < min_cnt && t >= ca->bic_K) 220df3271f3SStephen Hemminger ca->cnt = min_cnt; 221df3271f3SStephen Hemminger } 222df3271f3SStephen Hemminger 223df3271f3SStephen Hemminger /* slow start and low utilization */ 224df3271f3SStephen Hemminger if (ca->loss_cwnd == 0) /* could be aggressive in slow start */ 225df3271f3SStephen Hemminger ca->cnt = 50; 226df3271f3SStephen Hemminger 227df3271f3SStephen Hemminger /* TCP Friendly */ 228df3271f3SStephen Hemminger if (tcp_friendliness) { 22989b3d9aaSStephen Hemminger u32 scale = beta_scale; 23089b3d9aaSStephen Hemminger delta = (cwnd * scale) >> 3; 23189b3d9aaSStephen Hemminger while (ca->ack_cnt > delta) { /* update tcp cwnd */ 23289b3d9aaSStephen Hemminger ca->ack_cnt -= delta; 233df3271f3SStephen Hemminger ca->tcp_cwnd++; 234df3271f3SStephen Hemminger } 235df3271f3SStephen Hemminger 236df3271f3SStephen Hemminger if (ca->tcp_cwnd > cwnd){ /* if bic is slower than tcp */ 23789b3d9aaSStephen Hemminger delta = ca->tcp_cwnd - cwnd; 23889b3d9aaSStephen Hemminger max_cnt = cwnd / delta; 239df3271f3SStephen Hemminger if (ca->cnt > max_cnt) 240df3271f3SStephen Hemminger ca->cnt = max_cnt; 241df3271f3SStephen Hemminger } 242df3271f3SStephen Hemminger } 243df3271f3SStephen Hemminger 244df3271f3SStephen Hemminger ca->cnt = (ca->cnt << ACK_RATIO_SHIFT) / ca->delayed_ack; 245df3271f3SStephen Hemminger if (ca->cnt == 0) /* cannot be zero */ 246df3271f3SStephen Hemminger ca->cnt = 1; 247df3271f3SStephen Hemminger } 248df3271f3SStephen Hemminger 249df3271f3SStephen Hemminger static void bictcp_cong_avoid(struct sock *sk, u32 ack, 25016751347SStephen Hemminger u32 in_flight, int data_acked) 251df3271f3SStephen Hemminger { 252df3271f3SStephen Hemminger struct tcp_sock *tp = tcp_sk(sk); 253df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 254df3271f3SStephen Hemminger 255df3271f3SStephen Hemminger if (!tcp_is_cwnd_limited(sk, in_flight)) 256df3271f3SStephen Hemminger return; 257df3271f3SStephen Hemminger 258df3271f3SStephen Hemminger if (tp->snd_cwnd <= tp->snd_ssthresh) 259df3271f3SStephen Hemminger tcp_slow_start(tp); 260df3271f3SStephen Hemminger else { 261df3271f3SStephen Hemminger bictcp_update(ca, tp->snd_cwnd); 262df3271f3SStephen Hemminger 263df3271f3SStephen Hemminger /* In dangerous area, increase slowly. 264df3271f3SStephen Hemminger * In theory this is tp->snd_cwnd += 1 / tp->snd_cwnd 265df3271f3SStephen Hemminger */ 266df3271f3SStephen Hemminger if (tp->snd_cwnd_cnt >= ca->cnt) { 267df3271f3SStephen Hemminger if (tp->snd_cwnd < tp->snd_cwnd_clamp) 268df3271f3SStephen Hemminger tp->snd_cwnd++; 269df3271f3SStephen Hemminger tp->snd_cwnd_cnt = 0; 270df3271f3SStephen Hemminger } else 271df3271f3SStephen Hemminger tp->snd_cwnd_cnt++; 272df3271f3SStephen Hemminger } 273df3271f3SStephen Hemminger 274df3271f3SStephen Hemminger } 275df3271f3SStephen Hemminger 276df3271f3SStephen Hemminger static u32 bictcp_recalc_ssthresh(struct sock *sk) 277df3271f3SStephen Hemminger { 278df3271f3SStephen Hemminger const struct tcp_sock *tp = tcp_sk(sk); 279df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 280df3271f3SStephen Hemminger 281df3271f3SStephen Hemminger ca->epoch_start = 0; /* end of epoch */ 282df3271f3SStephen Hemminger 283df3271f3SStephen Hemminger /* Wmax and fast convergence */ 284df3271f3SStephen Hemminger if (tp->snd_cwnd < ca->last_max_cwnd && fast_convergence) 285df3271f3SStephen Hemminger ca->last_max_cwnd = (tp->snd_cwnd * (BICTCP_BETA_SCALE + beta)) 286df3271f3SStephen Hemminger / (2 * BICTCP_BETA_SCALE); 287df3271f3SStephen Hemminger else 288df3271f3SStephen Hemminger ca->last_max_cwnd = tp->snd_cwnd; 289df3271f3SStephen Hemminger 290df3271f3SStephen Hemminger ca->loss_cwnd = tp->snd_cwnd; 291df3271f3SStephen Hemminger 292df3271f3SStephen Hemminger return max((tp->snd_cwnd * beta) / BICTCP_BETA_SCALE, 2U); 293df3271f3SStephen Hemminger } 294df3271f3SStephen Hemminger 295df3271f3SStephen Hemminger static u32 bictcp_undo_cwnd(struct sock *sk) 296df3271f3SStephen Hemminger { 297df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 298df3271f3SStephen Hemminger 299df3271f3SStephen Hemminger return max(tcp_sk(sk)->snd_cwnd, ca->last_max_cwnd); 300df3271f3SStephen Hemminger } 301df3271f3SStephen Hemminger 302df3271f3SStephen Hemminger static void bictcp_state(struct sock *sk, u8 new_state) 303df3271f3SStephen Hemminger { 304df3271f3SStephen Hemminger if (new_state == TCP_CA_Loss) 305df3271f3SStephen Hemminger bictcp_reset(inet_csk_ca(sk)); 306df3271f3SStephen Hemminger } 307df3271f3SStephen Hemminger 308df3271f3SStephen Hemminger /* Track delayed acknowledgment ratio using sliding window 309df3271f3SStephen Hemminger * ratio = (15*ratio + sample) / 16 310df3271f3SStephen Hemminger */ 31130cfd0baSStephen Hemminger static void bictcp_acked(struct sock *sk, u32 cnt, s32 rtt_us) 312df3271f3SStephen Hemminger { 313df3271f3SStephen Hemminger const struct inet_connection_sock *icsk = inet_csk(sk); 314e7d0c885SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 315e7d0c885SStephen Hemminger u32 delay; 316df3271f3SStephen Hemminger 317*35e86941SIlpo Järvinen if (icsk->icsk_ca_state == TCP_CA_Open) { 318df3271f3SStephen Hemminger cnt -= ca->delayed_ack >> ACK_RATIO_SHIFT; 319df3271f3SStephen Hemminger ca->delayed_ack += cnt; 320df3271f3SStephen Hemminger } 321df3271f3SStephen Hemminger 322e7d0c885SStephen Hemminger /* Some calls are for duplicates without timetamps */ 323e7d0c885SStephen Hemminger if (rtt_us < 0) 324e7d0c885SStephen Hemminger return; 325e7d0c885SStephen Hemminger 326e7d0c885SStephen Hemminger /* Discard delay samples right after fast recovery */ 327e7d0c885SStephen Hemminger if ((s32)(tcp_time_stamp - ca->epoch_start) < HZ) 328e7d0c885SStephen Hemminger return; 329e7d0c885SStephen Hemminger 330e7d0c885SStephen Hemminger delay = usecs_to_jiffies(rtt_us) << 3; 331e7d0c885SStephen Hemminger if (delay == 0) 332e7d0c885SStephen Hemminger delay = 1; 333e7d0c885SStephen Hemminger 334e7d0c885SStephen Hemminger /* first time call or link delay decreases */ 335e7d0c885SStephen Hemminger if (ca->delay_min == 0 || ca->delay_min > delay) 336e7d0c885SStephen Hemminger ca->delay_min = delay; 337e7d0c885SStephen Hemminger } 338df3271f3SStephen Hemminger 339df3271f3SStephen Hemminger static struct tcp_congestion_ops cubictcp = { 340df3271f3SStephen Hemminger .init = bictcp_init, 341df3271f3SStephen Hemminger .ssthresh = bictcp_recalc_ssthresh, 342df3271f3SStephen Hemminger .cong_avoid = bictcp_cong_avoid, 343df3271f3SStephen Hemminger .set_state = bictcp_state, 344df3271f3SStephen Hemminger .undo_cwnd = bictcp_undo_cwnd, 345df3271f3SStephen Hemminger .pkts_acked = bictcp_acked, 346df3271f3SStephen Hemminger .owner = THIS_MODULE, 347df3271f3SStephen Hemminger .name = "cubic", 348df3271f3SStephen Hemminger }; 349df3271f3SStephen Hemminger 350df3271f3SStephen Hemminger static int __init cubictcp_register(void) 351df3271f3SStephen Hemminger { 35274975d40SAlexey Dobriyan BUILD_BUG_ON(sizeof(struct bictcp) > ICSK_CA_PRIV_SIZE); 35389b3d9aaSStephen Hemminger 35489b3d9aaSStephen Hemminger /* Precompute a bunch of the scaling factors that are used per-packet 35589b3d9aaSStephen Hemminger * based on SRTT of 100ms 35689b3d9aaSStephen Hemminger */ 35789b3d9aaSStephen Hemminger 35889b3d9aaSStephen Hemminger beta_scale = 8*(BICTCP_BETA_SCALE+beta)/ 3 / (BICTCP_BETA_SCALE - beta); 35989b3d9aaSStephen Hemminger 36022119240SStephen Hemminger cube_rtt_scale = (bic_scale * 10); /* 1024*c/rtt */ 36189b3d9aaSStephen Hemminger 36289b3d9aaSStephen Hemminger /* calculate the "K" for (wmax-cwnd) = c/rtt * K^3 36389b3d9aaSStephen Hemminger * so K = cubic_root( (wmax-cwnd)*rtt/c ) 36489b3d9aaSStephen Hemminger * the unit of K is bictcp_HZ=2^10, not HZ 36589b3d9aaSStephen Hemminger * 36689b3d9aaSStephen Hemminger * c = bic_scale >> 10 36789b3d9aaSStephen Hemminger * rtt = 100ms 36889b3d9aaSStephen Hemminger * 36989b3d9aaSStephen Hemminger * the following code has been designed and tested for 37089b3d9aaSStephen Hemminger * cwnd < 1 million packets 37189b3d9aaSStephen Hemminger * RTT < 100 seconds 37289b3d9aaSStephen Hemminger * HZ < 1,000,00 (corresponding to 10 nano-second) 37389b3d9aaSStephen Hemminger */ 37489b3d9aaSStephen Hemminger 37589b3d9aaSStephen Hemminger /* 1/c * 2^2*bictcp_HZ * srtt */ 37689b3d9aaSStephen Hemminger cube_factor = 1ull << (10+3*BICTCP_HZ); /* 2^40 */ 37789b3d9aaSStephen Hemminger 37889b3d9aaSStephen Hemminger /* divide by bic_scale and by constant Srtt (100ms) */ 37989b3d9aaSStephen Hemminger do_div(cube_factor, bic_scale * 10); 38089b3d9aaSStephen Hemminger 381df3271f3SStephen Hemminger return tcp_register_congestion_control(&cubictcp); 382df3271f3SStephen Hemminger } 383df3271f3SStephen Hemminger 384df3271f3SStephen Hemminger static void __exit cubictcp_unregister(void) 385df3271f3SStephen Hemminger { 386df3271f3SStephen Hemminger tcp_unregister_congestion_control(&cubictcp); 387df3271f3SStephen Hemminger } 388df3271f3SStephen Hemminger 389df3271f3SStephen Hemminger module_init(cubictcp_register); 390df3271f3SStephen Hemminger module_exit(cubictcp_unregister); 391df3271f3SStephen Hemminger 392df3271f3SStephen Hemminger MODULE_AUTHOR("Sangtae Ha, Stephen Hemminger"); 393df3271f3SStephen Hemminger MODULE_LICENSE("GPL"); 394df3271f3SStephen Hemminger MODULE_DESCRIPTION("CUBIC TCP"); 395e1c3e7abSStephen Hemminger MODULE_VERSION("2.1"); 396