1df3271f3SStephen Hemminger /* 2df3271f3SStephen Hemminger * TCP CUBIC: Binary Increase Congestion control for TCP v2.0 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 29df3271f3SStephen Hemminger static int fast_convergence = 1; 30df3271f3SStephen Hemminger static int max_increment = 16; 31df3271f3SStephen Hemminger static int beta = 819; /* = 819/1024 (BICTCP_BETA_SCALE) */ 32df3271f3SStephen Hemminger static int initial_ssthresh = 100; 33df3271f3SStephen Hemminger static int bic_scale = 41; 34df3271f3SStephen Hemminger static int tcp_friendliness = 1; 35df3271f3SStephen Hemminger 3689b3d9aaSStephen Hemminger static u32 cube_rtt_scale; 3789b3d9aaSStephen Hemminger static u32 beta_scale; 3889b3d9aaSStephen Hemminger static u64 cube_factor; 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 549eb2d627SStephen Hemminger #include <asm/div64.h> 55df3271f3SStephen Hemminger 56df3271f3SStephen Hemminger /* BIC TCP Parameters */ 57df3271f3SStephen Hemminger struct bictcp { 58df3271f3SStephen Hemminger u32 cnt; /* increase cwnd by 1 after ACKs */ 59df3271f3SStephen Hemminger u32 last_max_cwnd; /* last maximum snd_cwnd */ 60df3271f3SStephen Hemminger u32 loss_cwnd; /* congestion window at last loss */ 61df3271f3SStephen Hemminger u32 last_cwnd; /* the last snd_cwnd */ 62df3271f3SStephen Hemminger u32 last_time; /* time when updated last_cwnd */ 63df3271f3SStephen Hemminger u32 bic_origin_point;/* origin point of bic function */ 64df3271f3SStephen Hemminger u32 bic_K; /* time to origin point from the beginning of the current epoch */ 65df3271f3SStephen Hemminger u32 delay_min; /* min delay */ 66df3271f3SStephen Hemminger u32 epoch_start; /* beginning of an epoch */ 67df3271f3SStephen Hemminger u32 ack_cnt; /* number of acks */ 68df3271f3SStephen Hemminger u32 tcp_cwnd; /* estimated tcp cwnd */ 69df3271f3SStephen Hemminger #define ACK_RATIO_SHIFT 4 70df3271f3SStephen Hemminger u32 delayed_ack; /* estimate the ratio of Packets/ACKs << 4 */ 71df3271f3SStephen Hemminger }; 72df3271f3SStephen Hemminger 73df3271f3SStephen Hemminger static inline void bictcp_reset(struct bictcp *ca) 74df3271f3SStephen Hemminger { 75df3271f3SStephen Hemminger ca->cnt = 0; 76df3271f3SStephen Hemminger ca->last_max_cwnd = 0; 77df3271f3SStephen Hemminger ca->loss_cwnd = 0; 78df3271f3SStephen Hemminger ca->last_cwnd = 0; 79df3271f3SStephen Hemminger ca->last_time = 0; 80df3271f3SStephen Hemminger ca->bic_origin_point = 0; 81df3271f3SStephen Hemminger ca->bic_K = 0; 82df3271f3SStephen Hemminger ca->delay_min = 0; 83df3271f3SStephen Hemminger ca->epoch_start = 0; 84df3271f3SStephen Hemminger ca->delayed_ack = 2 << ACK_RATIO_SHIFT; 85df3271f3SStephen Hemminger ca->ack_cnt = 0; 86df3271f3SStephen Hemminger ca->tcp_cwnd = 0; 87df3271f3SStephen Hemminger } 88df3271f3SStephen Hemminger 89df3271f3SStephen Hemminger static void bictcp_init(struct sock *sk) 90df3271f3SStephen Hemminger { 91df3271f3SStephen Hemminger bictcp_reset(inet_csk_ca(sk)); 92df3271f3SStephen Hemminger if (initial_ssthresh) 93df3271f3SStephen Hemminger tcp_sk(sk)->snd_ssthresh = initial_ssthresh; 94df3271f3SStephen Hemminger } 95df3271f3SStephen Hemminger 969eb2d627SStephen Hemminger /* 64bit divisor, dividend and result. dynamic precision */ 979eb2d627SStephen Hemminger static inline u_int64_t div64_64(u_int64_t dividend, u_int64_t divisor) 989eb2d627SStephen Hemminger { 999eb2d627SStephen Hemminger u_int32_t d = divisor; 1009eb2d627SStephen Hemminger 1019eb2d627SStephen Hemminger if (divisor > 0xffffffffULL) { 1029eb2d627SStephen Hemminger unsigned int shift = fls(divisor >> 32); 1039eb2d627SStephen Hemminger 1049eb2d627SStephen Hemminger d = divisor >> shift; 1059eb2d627SStephen Hemminger dividend >>= shift; 1069eb2d627SStephen Hemminger } 1079eb2d627SStephen Hemminger 1089eb2d627SStephen Hemminger /* avoid 64 bit division if possible */ 1099eb2d627SStephen Hemminger if (dividend >> 32) 1109eb2d627SStephen Hemminger do_div(dividend, d); 1119eb2d627SStephen Hemminger else 1129eb2d627SStephen Hemminger dividend = (uint32_t) dividend / d; 1139eb2d627SStephen Hemminger 1149eb2d627SStephen Hemminger return dividend; 1159eb2d627SStephen Hemminger } 116df3271f3SStephen Hemminger 117df3271f3SStephen Hemminger /* 1189eb2d627SStephen Hemminger * calculate the cubic root of x using Newton-Raphson 119df3271f3SStephen Hemminger */ 1209eb2d627SStephen Hemminger static u32 cubic_root(u64 a) 121df3271f3SStephen Hemminger { 1229eb2d627SStephen Hemminger u32 x, x1; 123df3271f3SStephen Hemminger 1249eb2d627SStephen Hemminger /* Initial estimate is based on: 1259eb2d627SStephen Hemminger * cbrt(x) = exp(log(x) / 3) 1269eb2d627SStephen Hemminger */ 1279eb2d627SStephen Hemminger x = 1u << (fls64(a)/3); 128df3271f3SStephen Hemminger 1299eb2d627SStephen Hemminger /* 1309eb2d627SStephen Hemminger * Iteration based on: 1319eb2d627SStephen Hemminger * 2 1329eb2d627SStephen Hemminger * x = ( 2 * x + a / x ) / 3 1339eb2d627SStephen Hemminger * k+1 k k 1349eb2d627SStephen Hemminger */ 1359eb2d627SStephen Hemminger do { 1369eb2d627SStephen Hemminger x1 = x; 1379eb2d627SStephen Hemminger x = (2 * x + (uint32_t) div64_64(a, x*x)) / 3; 1389eb2d627SStephen Hemminger } while (abs(x1 - x) > 1); 139df3271f3SStephen Hemminger 1409eb2d627SStephen Hemminger return x; 141df3271f3SStephen Hemminger } 142df3271f3SStephen Hemminger 143df3271f3SStephen Hemminger /* 144df3271f3SStephen Hemminger * Compute congestion window to use. 145df3271f3SStephen Hemminger */ 146df3271f3SStephen Hemminger static inline void bictcp_update(struct bictcp *ca, u32 cwnd) 147df3271f3SStephen Hemminger { 14889b3d9aaSStephen Hemminger u64 offs; 14989b3d9aaSStephen Hemminger u32 delta, t, bic_target, min_cnt, max_cnt; 150df3271f3SStephen Hemminger 151df3271f3SStephen Hemminger ca->ack_cnt++; /* count the number of ACKs */ 152df3271f3SStephen Hemminger 153df3271f3SStephen Hemminger if (ca->last_cwnd == cwnd && 154df3271f3SStephen Hemminger (s32)(tcp_time_stamp - ca->last_time) <= HZ / 32) 155df3271f3SStephen Hemminger return; 156df3271f3SStephen Hemminger 157df3271f3SStephen Hemminger ca->last_cwnd = cwnd; 158df3271f3SStephen Hemminger ca->last_time = tcp_time_stamp; 159df3271f3SStephen Hemminger 160df3271f3SStephen Hemminger if (ca->epoch_start == 0) { 161df3271f3SStephen Hemminger ca->epoch_start = tcp_time_stamp; /* record the beginning of an epoch */ 162df3271f3SStephen Hemminger ca->ack_cnt = 1; /* start counting */ 163df3271f3SStephen Hemminger ca->tcp_cwnd = cwnd; /* syn with cubic */ 164df3271f3SStephen Hemminger 165df3271f3SStephen Hemminger if (ca->last_max_cwnd <= cwnd) { 166df3271f3SStephen Hemminger ca->bic_K = 0; 167df3271f3SStephen Hemminger ca->bic_origin_point = cwnd; 168df3271f3SStephen Hemminger } else { 16989b3d9aaSStephen Hemminger /* Compute new K based on 17089b3d9aaSStephen Hemminger * (wmax-cwnd) * (srtt>>3 / HZ) / c * 2^(3*bictcp_HZ) 17189b3d9aaSStephen Hemminger */ 17289b3d9aaSStephen Hemminger ca->bic_K = cubic_root(cube_factor 17389b3d9aaSStephen Hemminger * (ca->last_max_cwnd - cwnd)); 174df3271f3SStephen Hemminger ca->bic_origin_point = ca->last_max_cwnd; 175df3271f3SStephen Hemminger } 176df3271f3SStephen Hemminger } 177df3271f3SStephen Hemminger 178df3271f3SStephen Hemminger /* cubic function - calc*/ 179df3271f3SStephen Hemminger /* calculate c * time^3 / rtt, 180df3271f3SStephen Hemminger * while considering overflow in calculation of time^3 18189b3d9aaSStephen Hemminger * (so time^3 is done by using 64 bit) 182df3271f3SStephen Hemminger * and without the support of division of 64bit numbers 18389b3d9aaSStephen Hemminger * (so all divisions are done by using 32 bit) 184df3271f3SStephen Hemminger * also NOTE the unit of those veriables 185df3271f3SStephen Hemminger * time = (t - K) / 2^bictcp_HZ 186df3271f3SStephen Hemminger * c = bic_scale >> 10 187df3271f3SStephen Hemminger * rtt = (srtt >> 3) / HZ 188df3271f3SStephen Hemminger * !!! The following code does not have overflow problems, 189df3271f3SStephen Hemminger * if the cwnd < 1 million packets !!! 190df3271f3SStephen Hemminger */ 191df3271f3SStephen Hemminger 192df3271f3SStephen Hemminger /* change the unit from HZ to bictcp_HZ */ 193df3271f3SStephen Hemminger t = ((tcp_time_stamp + ca->delay_min - ca->epoch_start) 194df3271f3SStephen Hemminger << BICTCP_HZ) / HZ; 195df3271f3SStephen Hemminger 196df3271f3SStephen Hemminger if (t < ca->bic_K) /* t - K */ 19789b3d9aaSStephen Hemminger offs = ca->bic_K - t; 198df3271f3SStephen Hemminger else 19989b3d9aaSStephen Hemminger offs = t - ca->bic_K; 200df3271f3SStephen Hemminger 20189b3d9aaSStephen Hemminger /* c/rtt * (t-K)^3 */ 20289b3d9aaSStephen Hemminger delta = (cube_rtt_scale * offs * offs * offs) >> (10+3*BICTCP_HZ); 203df3271f3SStephen Hemminger if (t < ca->bic_K) /* below origin*/ 20489b3d9aaSStephen Hemminger bic_target = ca->bic_origin_point - delta; 205df3271f3SStephen Hemminger else /* above origin*/ 20689b3d9aaSStephen Hemminger bic_target = ca->bic_origin_point + delta; 207df3271f3SStephen Hemminger 208df3271f3SStephen Hemminger /* cubic function - calc bictcp_cnt*/ 209df3271f3SStephen Hemminger if (bic_target > cwnd) { 210df3271f3SStephen Hemminger ca->cnt = cwnd / (bic_target - cwnd); 211df3271f3SStephen Hemminger } else { 212df3271f3SStephen Hemminger ca->cnt = 100 * cwnd; /* very small increment*/ 213df3271f3SStephen Hemminger } 214df3271f3SStephen Hemminger 215df3271f3SStephen Hemminger if (ca->delay_min > 0) { 216df3271f3SStephen Hemminger /* max increment = Smax * rtt / 0.1 */ 217df3271f3SStephen Hemminger min_cnt = (cwnd * HZ * 8)/(10 * max_increment * ca->delay_min); 218df3271f3SStephen Hemminger if (ca->cnt < min_cnt) 219df3271f3SStephen Hemminger ca->cnt = min_cnt; 220df3271f3SStephen Hemminger } 221df3271f3SStephen Hemminger 222df3271f3SStephen Hemminger /* slow start and low utilization */ 223df3271f3SStephen Hemminger if (ca->loss_cwnd == 0) /* could be aggressive in slow start */ 224df3271f3SStephen Hemminger ca->cnt = 50; 225df3271f3SStephen Hemminger 226df3271f3SStephen Hemminger /* TCP Friendly */ 227df3271f3SStephen Hemminger if (tcp_friendliness) { 22889b3d9aaSStephen Hemminger u32 scale = beta_scale; 22989b3d9aaSStephen Hemminger delta = (cwnd * scale) >> 3; 23089b3d9aaSStephen Hemminger while (ca->ack_cnt > delta) { /* update tcp cwnd */ 23189b3d9aaSStephen Hemminger ca->ack_cnt -= delta; 232df3271f3SStephen Hemminger ca->tcp_cwnd++; 233df3271f3SStephen Hemminger } 234df3271f3SStephen Hemminger 235df3271f3SStephen Hemminger if (ca->tcp_cwnd > cwnd){ /* if bic is slower than tcp */ 23689b3d9aaSStephen Hemminger delta = ca->tcp_cwnd - cwnd; 23789b3d9aaSStephen Hemminger max_cnt = cwnd / delta; 238df3271f3SStephen Hemminger if (ca->cnt > max_cnt) 239df3271f3SStephen Hemminger ca->cnt = max_cnt; 240df3271f3SStephen Hemminger } 241df3271f3SStephen Hemminger } 242df3271f3SStephen Hemminger 243df3271f3SStephen Hemminger ca->cnt = (ca->cnt << ACK_RATIO_SHIFT) / ca->delayed_ack; 244df3271f3SStephen Hemminger if (ca->cnt == 0) /* cannot be zero */ 245df3271f3SStephen Hemminger ca->cnt = 1; 246df3271f3SStephen Hemminger } 247df3271f3SStephen Hemminger 248df3271f3SStephen Hemminger 249df3271f3SStephen Hemminger /* Keep track of minimum rtt */ 250df3271f3SStephen Hemminger static inline void measure_delay(struct sock *sk) 251df3271f3SStephen Hemminger { 252df3271f3SStephen Hemminger const struct tcp_sock *tp = tcp_sk(sk); 253df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 254df3271f3SStephen Hemminger u32 delay; 255df3271f3SStephen Hemminger 256df3271f3SStephen Hemminger /* No time stamp */ 257df3271f3SStephen Hemminger if (!(tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr) || 258df3271f3SStephen Hemminger /* Discard delay samples right after fast recovery */ 259df3271f3SStephen Hemminger (s32)(tcp_time_stamp - ca->epoch_start) < HZ) 260df3271f3SStephen Hemminger return; 261df3271f3SStephen Hemminger 262df3271f3SStephen Hemminger delay = tcp_time_stamp - tp->rx_opt.rcv_tsecr; 263df3271f3SStephen Hemminger if (delay == 0) 264df3271f3SStephen Hemminger delay = 1; 265df3271f3SStephen Hemminger 266df3271f3SStephen Hemminger /* first time call or link delay decreases */ 267df3271f3SStephen Hemminger if (ca->delay_min == 0 || ca->delay_min > delay) 268df3271f3SStephen Hemminger ca->delay_min = delay; 269df3271f3SStephen Hemminger } 270df3271f3SStephen Hemminger 271df3271f3SStephen Hemminger static void bictcp_cong_avoid(struct sock *sk, u32 ack, 272df3271f3SStephen Hemminger u32 seq_rtt, u32 in_flight, int data_acked) 273df3271f3SStephen Hemminger { 274df3271f3SStephen Hemminger struct tcp_sock *tp = tcp_sk(sk); 275df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 276df3271f3SStephen Hemminger 277df3271f3SStephen Hemminger if (data_acked) 278df3271f3SStephen Hemminger measure_delay(sk); 279df3271f3SStephen Hemminger 280df3271f3SStephen Hemminger if (!tcp_is_cwnd_limited(sk, in_flight)) 281df3271f3SStephen Hemminger return; 282df3271f3SStephen Hemminger 283df3271f3SStephen Hemminger if (tp->snd_cwnd <= tp->snd_ssthresh) 284df3271f3SStephen Hemminger tcp_slow_start(tp); 285df3271f3SStephen Hemminger else { 286df3271f3SStephen Hemminger bictcp_update(ca, tp->snd_cwnd); 287df3271f3SStephen Hemminger 288df3271f3SStephen Hemminger /* In dangerous area, increase slowly. 289df3271f3SStephen Hemminger * In theory this is tp->snd_cwnd += 1 / tp->snd_cwnd 290df3271f3SStephen Hemminger */ 291df3271f3SStephen Hemminger if (tp->snd_cwnd_cnt >= ca->cnt) { 292df3271f3SStephen Hemminger if (tp->snd_cwnd < tp->snd_cwnd_clamp) 293df3271f3SStephen Hemminger tp->snd_cwnd++; 294df3271f3SStephen Hemminger tp->snd_cwnd_cnt = 0; 295df3271f3SStephen Hemminger } else 296df3271f3SStephen Hemminger tp->snd_cwnd_cnt++; 297df3271f3SStephen Hemminger } 298df3271f3SStephen Hemminger 299df3271f3SStephen Hemminger } 300df3271f3SStephen Hemminger 301df3271f3SStephen Hemminger static u32 bictcp_recalc_ssthresh(struct sock *sk) 302df3271f3SStephen Hemminger { 303df3271f3SStephen Hemminger const struct tcp_sock *tp = tcp_sk(sk); 304df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 305df3271f3SStephen Hemminger 306df3271f3SStephen Hemminger ca->epoch_start = 0; /* end of epoch */ 307df3271f3SStephen Hemminger 308df3271f3SStephen Hemminger /* Wmax and fast convergence */ 309df3271f3SStephen Hemminger if (tp->snd_cwnd < ca->last_max_cwnd && fast_convergence) 310df3271f3SStephen Hemminger ca->last_max_cwnd = (tp->snd_cwnd * (BICTCP_BETA_SCALE + beta)) 311df3271f3SStephen Hemminger / (2 * BICTCP_BETA_SCALE); 312df3271f3SStephen Hemminger else 313df3271f3SStephen Hemminger ca->last_max_cwnd = tp->snd_cwnd; 314df3271f3SStephen Hemminger 315df3271f3SStephen Hemminger ca->loss_cwnd = tp->snd_cwnd; 316df3271f3SStephen Hemminger 317df3271f3SStephen Hemminger return max((tp->snd_cwnd * beta) / BICTCP_BETA_SCALE, 2U); 318df3271f3SStephen Hemminger } 319df3271f3SStephen Hemminger 320df3271f3SStephen Hemminger static u32 bictcp_undo_cwnd(struct sock *sk) 321df3271f3SStephen Hemminger { 322df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 323df3271f3SStephen Hemminger 324df3271f3SStephen Hemminger return max(tcp_sk(sk)->snd_cwnd, ca->last_max_cwnd); 325df3271f3SStephen Hemminger } 326df3271f3SStephen Hemminger 327df3271f3SStephen Hemminger static void bictcp_state(struct sock *sk, u8 new_state) 328df3271f3SStephen Hemminger { 329df3271f3SStephen Hemminger if (new_state == TCP_CA_Loss) 330df3271f3SStephen Hemminger bictcp_reset(inet_csk_ca(sk)); 331df3271f3SStephen Hemminger } 332df3271f3SStephen Hemminger 333df3271f3SStephen Hemminger /* Track delayed acknowledgment ratio using sliding window 334df3271f3SStephen Hemminger * ratio = (15*ratio + sample) / 16 335df3271f3SStephen Hemminger */ 336df3271f3SStephen Hemminger static void bictcp_acked(struct sock *sk, u32 cnt) 337df3271f3SStephen Hemminger { 338df3271f3SStephen Hemminger const struct inet_connection_sock *icsk = inet_csk(sk); 339df3271f3SStephen Hemminger 340df3271f3SStephen Hemminger if (cnt > 0 && icsk->icsk_ca_state == TCP_CA_Open) { 341df3271f3SStephen Hemminger struct bictcp *ca = inet_csk_ca(sk); 342df3271f3SStephen Hemminger cnt -= ca->delayed_ack >> ACK_RATIO_SHIFT; 343df3271f3SStephen Hemminger ca->delayed_ack += cnt; 344df3271f3SStephen Hemminger } 345df3271f3SStephen Hemminger } 346df3271f3SStephen Hemminger 347df3271f3SStephen Hemminger 348df3271f3SStephen Hemminger static struct tcp_congestion_ops cubictcp = { 349df3271f3SStephen Hemminger .init = bictcp_init, 350df3271f3SStephen Hemminger .ssthresh = bictcp_recalc_ssthresh, 351df3271f3SStephen Hemminger .cong_avoid = bictcp_cong_avoid, 352df3271f3SStephen Hemminger .set_state = bictcp_state, 353df3271f3SStephen Hemminger .undo_cwnd = bictcp_undo_cwnd, 354df3271f3SStephen Hemminger .pkts_acked = bictcp_acked, 355df3271f3SStephen Hemminger .owner = THIS_MODULE, 356df3271f3SStephen Hemminger .name = "cubic", 357df3271f3SStephen Hemminger }; 358df3271f3SStephen Hemminger 359df3271f3SStephen Hemminger static int __init cubictcp_register(void) 360df3271f3SStephen Hemminger { 361*74975d40SAlexey Dobriyan BUILD_BUG_ON(sizeof(struct bictcp) > ICSK_CA_PRIV_SIZE); 36289b3d9aaSStephen Hemminger 36389b3d9aaSStephen Hemminger /* Precompute a bunch of the scaling factors that are used per-packet 36489b3d9aaSStephen Hemminger * based on SRTT of 100ms 36589b3d9aaSStephen Hemminger */ 36689b3d9aaSStephen Hemminger 36789b3d9aaSStephen Hemminger beta_scale = 8*(BICTCP_BETA_SCALE+beta)/ 3 / (BICTCP_BETA_SCALE - beta); 36889b3d9aaSStephen Hemminger 36989b3d9aaSStephen Hemminger cube_rtt_scale = (bic_scale << 3) / 10; /* 1024*c/rtt */ 37089b3d9aaSStephen Hemminger 37189b3d9aaSStephen Hemminger /* calculate the "K" for (wmax-cwnd) = c/rtt * K^3 37289b3d9aaSStephen Hemminger * so K = cubic_root( (wmax-cwnd)*rtt/c ) 37389b3d9aaSStephen Hemminger * the unit of K is bictcp_HZ=2^10, not HZ 37489b3d9aaSStephen Hemminger * 37589b3d9aaSStephen Hemminger * c = bic_scale >> 10 37689b3d9aaSStephen Hemminger * rtt = 100ms 37789b3d9aaSStephen Hemminger * 37889b3d9aaSStephen Hemminger * the following code has been designed and tested for 37989b3d9aaSStephen Hemminger * cwnd < 1 million packets 38089b3d9aaSStephen Hemminger * RTT < 100 seconds 38189b3d9aaSStephen Hemminger * HZ < 1,000,00 (corresponding to 10 nano-second) 38289b3d9aaSStephen Hemminger */ 38389b3d9aaSStephen Hemminger 38489b3d9aaSStephen Hemminger /* 1/c * 2^2*bictcp_HZ * srtt */ 38589b3d9aaSStephen Hemminger cube_factor = 1ull << (10+3*BICTCP_HZ); /* 2^40 */ 38689b3d9aaSStephen Hemminger 38789b3d9aaSStephen Hemminger /* divide by bic_scale and by constant Srtt (100ms) */ 38889b3d9aaSStephen Hemminger do_div(cube_factor, bic_scale * 10); 38989b3d9aaSStephen Hemminger 390df3271f3SStephen Hemminger return tcp_register_congestion_control(&cubictcp); 391df3271f3SStephen Hemminger } 392df3271f3SStephen Hemminger 393df3271f3SStephen Hemminger static void __exit cubictcp_unregister(void) 394df3271f3SStephen Hemminger { 395df3271f3SStephen Hemminger tcp_unregister_congestion_control(&cubictcp); 396df3271f3SStephen Hemminger } 397df3271f3SStephen Hemminger 398df3271f3SStephen Hemminger module_init(cubictcp_register); 399df3271f3SStephen Hemminger module_exit(cubictcp_unregister); 400df3271f3SStephen Hemminger 401df3271f3SStephen Hemminger MODULE_AUTHOR("Sangtae Ha, Stephen Hemminger"); 402df3271f3SStephen Hemminger MODULE_LICENSE("GPL"); 403df3271f3SStephen Hemminger MODULE_DESCRIPTION("CUBIC TCP"); 404df3271f3SStephen Hemminger MODULE_VERSION("2.0"); 405