tcp_htcp.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * H-TCP congestion control. The algorithm is detailed in:
  4. * R.N.Shorten, D.J.Leith:
  5. * "H-TCP: TCP for high-speed and long-distance networks"
  6. * Proc. PFLDnet, Argonne, 2004.
  7. * https://www.hamilton.ie/net/htcp3.pdf
  8. */
  9. #include <linux/mm.h>
  10. #include <linux/module.h>
  11. #include <net/tcp.h>
  12. #define ALPHA_BASE (1<<7) /* 1.0 with shift << 7 */
  13. #define BETA_MIN (1<<6) /* 0.5 with shift << 7 */
  14. #define BETA_MAX 102 /* 0.8 with shift << 7 */
  15. static int use_rtt_scaling __read_mostly = 1;
  16. module_param(use_rtt_scaling, int, 0644);
  17. MODULE_PARM_DESC(use_rtt_scaling, "turn on/off RTT scaling");
  18. static int use_bandwidth_switch __read_mostly = 1;
  19. module_param(use_bandwidth_switch, int, 0644);
  20. MODULE_PARM_DESC(use_bandwidth_switch, "turn on/off bandwidth switcher");
  21. struct htcp {
  22. u32 alpha; /* Fixed point arith, << 7 */
  23. u8 beta; /* Fixed point arith, << 7 */
  24. u8 modeswitch; /* Delay modeswitch
  25. until we had at least one congestion event */
  26. u16 pkts_acked;
  27. u32 packetcount;
  28. u32 minRTT;
  29. u32 maxRTT;
  30. u32 last_cong; /* Time since last congestion event end */
  31. u32 undo_last_cong;
  32. u32 undo_maxRTT;
  33. u32 undo_old_maxB;
  34. /* Bandwidth estimation */
  35. u32 minB;
  36. u32 maxB;
  37. u32 old_maxB;
  38. u32 Bi;
  39. u32 lasttime;
  40. };
  41. static inline u32 htcp_cong_time(const struct htcp *ca)
  42. {
  43. return jiffies - ca->last_cong;
  44. }
  45. static inline u32 htcp_ccount(const struct htcp *ca)
  46. {
  47. return htcp_cong_time(ca) / ca->minRTT;
  48. }
  49. static inline void htcp_reset(struct htcp *ca)
  50. {
  51. ca->undo_last_cong = ca->last_cong;
  52. ca->undo_maxRTT = ca->maxRTT;
  53. ca->undo_old_maxB = ca->old_maxB;
  54. ca->last_cong = jiffies;
  55. }
  56. static u32 htcp_cwnd_undo(struct sock *sk)
  57. {
  58. struct htcp *ca = inet_csk_ca(sk);
  59. if (ca->undo_last_cong) {
  60. ca->last_cong = ca->undo_last_cong;
  61. ca->maxRTT = ca->undo_maxRTT;
  62. ca->old_maxB = ca->undo_old_maxB;
  63. ca->undo_last_cong = 0;
  64. }
  65. return tcp_reno_undo_cwnd(sk);
  66. }
  67. static inline void measure_rtt(struct sock *sk, u32 srtt)
  68. {
  69. const struct inet_connection_sock *icsk = inet_csk(sk);
  70. struct htcp *ca = inet_csk_ca(sk);
  71. /* keep track of minimum RTT seen so far, minRTT is zero at first */
  72. if (ca->minRTT > srtt || !ca->minRTT)
  73. ca->minRTT = srtt;
  74. /* max RTT */
  75. if (icsk->icsk_ca_state == TCP_CA_Open) {
  76. if (ca->maxRTT < ca->minRTT)
  77. ca->maxRTT = ca->minRTT;
  78. if (ca->maxRTT < srtt &&
  79. srtt <= ca->maxRTT + msecs_to_jiffies(20))
  80. ca->maxRTT = srtt;
  81. }
  82. }
  83. static void measure_achieved_throughput(struct sock *sk,
  84. const struct ack_sample *sample)
  85. {
  86. const struct inet_connection_sock *icsk = inet_csk(sk);
  87. const struct tcp_sock *tp = tcp_sk(sk);
  88. struct htcp *ca = inet_csk_ca(sk);
  89. u32 now = tcp_jiffies32;
  90. if (icsk->icsk_ca_state == TCP_CA_Open)
  91. ca->pkts_acked = sample->pkts_acked;
  92. if (sample->rtt_us > 0)
  93. measure_rtt(sk, usecs_to_jiffies(sample->rtt_us));
  94. if (!use_bandwidth_switch)
  95. return;
  96. /* achieved throughput calculations */
  97. if (!((1 << icsk->icsk_ca_state) & (TCPF_CA_Open | TCPF_CA_Disorder))) {
  98. ca->packetcount = 0;
  99. ca->lasttime = now;
  100. return;
  101. }
  102. ca->packetcount += sample->pkts_acked;
  103. if (ca->packetcount >= tp->snd_cwnd - (ca->alpha >> 7 ? : 1) &&
  104. now - ca->lasttime >= ca->minRTT &&
  105. ca->minRTT > 0) {
  106. __u32 cur_Bi = ca->packetcount * HZ / (now - ca->lasttime);
  107. if (htcp_ccount(ca) <= 3) {
  108. /* just after backoff */
  109. ca->minB = ca->maxB = ca->Bi = cur_Bi;
  110. } else {
  111. ca->Bi = (3 * ca->Bi + cur_Bi) / 4;
  112. if (ca->Bi > ca->maxB)
  113. ca->maxB = ca->Bi;
  114. if (ca->minB > ca->maxB)
  115. ca->minB = ca->maxB;
  116. }
  117. ca->packetcount = 0;
  118. ca->lasttime = now;
  119. }
  120. }
  121. static inline void htcp_beta_update(struct htcp *ca, u32 minRTT, u32 maxRTT)
  122. {
  123. if (use_bandwidth_switch) {
  124. u32 maxB = ca->maxB;
  125. u32 old_maxB = ca->old_maxB;
  126. ca->old_maxB = ca->maxB;
  127. if (!between(5 * maxB, 4 * old_maxB, 6 * old_maxB)) {
  128. ca->beta = BETA_MIN;
  129. ca->modeswitch = 0;
  130. return;
  131. }
  132. }
  133. if (ca->modeswitch && minRTT > msecs_to_jiffies(10) && maxRTT) {
  134. ca->beta = (minRTT << 7) / maxRTT;
  135. if (ca->beta < BETA_MIN)
  136. ca->beta = BETA_MIN;
  137. else if (ca->beta > BETA_MAX)
  138. ca->beta = BETA_MAX;
  139. } else {
  140. ca->beta = BETA_MIN;
  141. ca->modeswitch = 1;
  142. }
  143. }
  144. static inline void htcp_alpha_update(struct htcp *ca)
  145. {
  146. u32 minRTT = ca->minRTT;
  147. u32 factor = 1;
  148. u32 diff = htcp_cong_time(ca);
  149. if (diff > HZ) {
  150. diff -= HZ;
  151. factor = 1 + (10 * diff + ((diff / 2) * (diff / 2) / HZ)) / HZ;
  152. }
  153. if (use_rtt_scaling && minRTT) {
  154. u32 scale = (HZ << 3) / (10 * minRTT);
  155. /* clamping ratio to interval [0.5,10]<<3 */
  156. scale = min(max(scale, 1U << 2), 10U << 3);
  157. factor = (factor << 3) / scale;
  158. if (!factor)
  159. factor = 1;
  160. }
  161. ca->alpha = 2 * factor * ((1 << 7) - ca->beta);
  162. if (!ca->alpha)
  163. ca->alpha = ALPHA_BASE;
  164. }
  165. /*
  166. * After we have the rtt data to calculate beta, we'd still prefer to wait one
  167. * rtt before we adjust our beta to ensure we are working from a consistent
  168. * data.
  169. *
  170. * This function should be called when we hit a congestion event since only at
  171. * that point do we really have a real sense of maxRTT (the queues en route
  172. * were getting just too full now).
  173. */
  174. static void htcp_param_update(struct sock *sk)
  175. {
  176. struct htcp *ca = inet_csk_ca(sk);
  177. u32 minRTT = ca->minRTT;
  178. u32 maxRTT = ca->maxRTT;
  179. htcp_beta_update(ca, minRTT, maxRTT);
  180. htcp_alpha_update(ca);
  181. /* add slowly fading memory for maxRTT to accommodate routing changes */
  182. if (minRTT > 0 && maxRTT > minRTT)
  183. ca->maxRTT = minRTT + ((maxRTT - minRTT) * 95) / 100;
  184. }
  185. static u32 htcp_recalc_ssthresh(struct sock *sk)
  186. {
  187. const struct tcp_sock *tp = tcp_sk(sk);
  188. const struct htcp *ca = inet_csk_ca(sk);
  189. htcp_param_update(sk);
  190. return max((tp->snd_cwnd * ca->beta) >> 7, 2U);
  191. }
  192. static void htcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
  193. {
  194. struct tcp_sock *tp = tcp_sk(sk);
  195. struct htcp *ca = inet_csk_ca(sk);
  196. if (!tcp_is_cwnd_limited(sk))
  197. return;
  198. if (tcp_in_slow_start(tp))
  199. tcp_slow_start(tp, acked);
  200. else {
  201. /* In dangerous area, increase slowly.
  202. * In theory this is tp->snd_cwnd += alpha / tp->snd_cwnd
  203. */
  204. if ((tp->snd_cwnd_cnt * ca->alpha)>>7 >= tp->snd_cwnd) {
  205. if (tp->snd_cwnd < tp->snd_cwnd_clamp)
  206. tp->snd_cwnd++;
  207. tp->snd_cwnd_cnt = 0;
  208. htcp_alpha_update(ca);
  209. } else
  210. tp->snd_cwnd_cnt += ca->pkts_acked;
  211. ca->pkts_acked = 1;
  212. }
  213. }
  214. static void htcp_init(struct sock *sk)
  215. {
  216. struct htcp *ca = inet_csk_ca(sk);
  217. memset(ca, 0, sizeof(struct htcp));
  218. ca->alpha = ALPHA_BASE;
  219. ca->beta = BETA_MIN;
  220. ca->pkts_acked = 1;
  221. ca->last_cong = jiffies;
  222. }
  223. static void htcp_state(struct sock *sk, u8 new_state)
  224. {
  225. switch (new_state) {
  226. case TCP_CA_Open:
  227. {
  228. struct htcp *ca = inet_csk_ca(sk);
  229. if (ca->undo_last_cong) {
  230. ca->last_cong = jiffies;
  231. ca->undo_last_cong = 0;
  232. }
  233. }
  234. break;
  235. case TCP_CA_CWR:
  236. case TCP_CA_Recovery:
  237. case TCP_CA_Loss:
  238. htcp_reset(inet_csk_ca(sk));
  239. break;
  240. }
  241. }
  242. static struct tcp_congestion_ops htcp __read_mostly = {
  243. .init = htcp_init,
  244. .ssthresh = htcp_recalc_ssthresh,
  245. .cong_avoid = htcp_cong_avoid,
  246. .set_state = htcp_state,
  247. .undo_cwnd = htcp_cwnd_undo,
  248. .pkts_acked = measure_achieved_throughput,
  249. .owner = THIS_MODULE,
  250. .name = "htcp",
  251. };
  252. static int __init htcp_register(void)
  253. {
  254. BUILD_BUG_ON(sizeof(struct htcp) > ICSK_CA_PRIV_SIZE);
  255. BUILD_BUG_ON(BETA_MIN >= BETA_MAX);
  256. return tcp_register_congestion_control(&htcp);
  257. }
  258. static void __exit htcp_unregister(void)
  259. {
  260. tcp_unregister_congestion_control(&htcp);
  261. }
  262. module_init(htcp_register);
  263. module_exit(htcp_unregister);
  264. MODULE_AUTHOR("Baruch Even");
  265. MODULE_LICENSE("GPL");
  266. MODULE_DESCRIPTION("H-TCP");