tcp_htcp.c 7.4 KB

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