tcp: add cubic hystart++ support RFC 9406

Use HyStart++ in cubic's initial slow start to leave it before the queue
overflows. An increase of the per-round minimum rtt moves the connection
to Conservative Slow Start (CSS), which resumes slow start if the
increase proves spurious and otherwise ends it after five rounds.

RTT samples come from ac->rtt_time, and a round needs N_RTT_SAMPLE of
them before a delay increase is checked. HyStart++ is enabled by default
and configured in the cubic stanza with [no-]hystart and
[no-]hystart-css. Without css, a delay increase ends slow start.

To avoid growing cc TCP_CC_DATA_SZ, K is now stored as 2^-20s ticks.

Type: feature

Change-Id: Ief0251cd6de0e39ae02967495f3f93bd8773bb5a
Signed-off-by: Florin Coras <fcoras@cisco.com>

Author: florincoras

src/plugins/unittest/tcp_test.c

@@ -2385,6 +2385,318 @@ tcp_test_cwnd_limited_growth (void)
   return 0;
 }
 
+static void
+tcp_test_cubic_hystart_init (tcp_connection_t *tc, clib_thread_index_t thread_index, u32 snd_mss)
+{
+  clib_memset (tc, 0, sizeof (*tc));
+  tc->c_thread_index = thread_index;
+  tc->snd_mss = snd_mss;
+  tc->snd_una = snd_mss;
+  tc->snd_nxt = 11 * snd_mss;
+  tc->tx_fifo_size = 1 << 30;
+  tc->mrtt_us = 0.01;
+  tc->srtt = 0.01 / TCP_TICK;
+  tc->cc_algo = tcp_cc_algo_get (TCP_CC_CUBIC);
+  tc->cc_algo->init (tc);
+}
+
+static void
+tcp_test_cubic_hystart_ack (tcp_connection_t *tc, u32 ack, u32 snd_nxt, u32 bytes_acked,
+			    f64 rtt_time)
+{
+  tcp_ack_ctx_t ac = {
+    .bytes_acked = bytes_acked,
+    .acked_and_sacked = bytes_acked,
+    .rtt_time = rtt_time,
+  };
+
+  tc->snd_una = ack;
+  tc->snd_nxt = snd_nxt;
+  tc->cwnd_limited_seq = ack;
+  tc->cc_algo->rcv_ack (tc, &ac);
+}
+
+/* 10 ms baseline round, then eight 20 ms samples */
+static u32
+tcp_test_cubic_hystart_enter_css (tcp_connection_t *tc, u32 snd_mss)
+{
+  u32 ack = tc->snd_una;
+  u32 first_round_end = tc->snd_nxt;
+  u32 next_round_end = first_round_end + 29 * snd_mss;
+  u32 i;
+
+  /* Baseline samples before the round boundary */
+  for (i = 0; i < 9; i++)
+    {
+      ack += snd_mss;
+      tcp_test_cubic_hystart_ack (tc, ack, first_round_end, snd_mss, 0.010);
+    }
+
+  /* Boundary ack is the new round's first sample */
+  ack += snd_mss;
+  tcp_test_cubic_hystart_ack (tc, ack, next_round_end, snd_mss, 0.020);
+  for (i = 1; i < 8; i++)
+    {
+      ack += snd_mss;
+      tcp_test_cubic_hystart_ack (tc, ack, next_round_end, snd_mss, 0.020);
+    }
+
+  return ack;
+}
+
+/* Drain and refill counts as one CSS round */
+static int
+tcp_test_cubic_hystart_drained_rounds (void)
+{
+  const clib_thread_index_t thread_index = 0;
+  const u32 snd_mss = 1000;
+  const struct
+  {
+    u32 seq_offset;
+    u8 ack_each_segment;
+    const char *name;
+  } cases[] = {
+    { 0, 1, "per-segment ACKs" },
+    { 0, 0, "one cumulative ACK" },
+    { ~0U - 29999, 1, "sequence wrap" },
+  };
+  tcp_connection_t _tc, *tc = &_tc;
+  u32 ack, round_end, bytes_acked, i, round;
+
+  tcp_test_set_time (thread_index, 1);
+  for (i = 0; i < ARRAY_LEN (cases); i++)
+    {
+      tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+      if (cases[i].seq_offset)
+	{
+	  tc->snd_una += cases[i].seq_offset;
+	  tc->snd_nxt += cases[i].seq_offset;
+	  tc->cc_algo->init (tc);
+	}
+      tc->connection.flags |= TRANSPORT_CONNECTION_F_IS_TX_PACED;
+      ack = tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+      round_end = tc->snd_nxt;
+
+      for (round = 1; round <= 5; round++)
+	{
+	  while (seq_lt (ack, round_end))
+	    {
+	      bytes_acked = cases[i].ack_each_segment ? snd_mss : round_end - ack;
+	      ack += bytes_acked;
+	      tcp_test_cubic_hystart_ack (tc, ack, round_end, bytes_acked, 0.020);
+	    }
+	  if (round < 5)
+	    {
+	      TCP_TEST ((tcp_in_slowstart (tc)), "CSS remains after drained round %u (%s)", round,
+			cases[i].name);
+	      round_end += (tc->cwnd / snd_mss) * snd_mss;
+	    }
+	  else
+	    TCP_TEST ((tc->ssthresh == tc->cwnd), "CSS exits after five drained rounds (%s)",
+		      cases[i].name);
+	}
+    }
+
+  return 0;
+}
+
+static void
+tcp_test_cubic_config (char *cfg)
+{
+  unformat_input_t input;
+
+  unformat_init_string (&input, cfg, strlen (cfg));
+  tcp_cc_algo_get (TCP_CC_CUBIC)->unformat_cfg (&input);
+  unformat_free (&input);
+}
+
+static int
+tcp_test_cubic_hystart (void)
+{
+  const clib_thread_index_t thread_index = 0;
+  const u32 snd_mss = 1000;
+  tcp_connection_t _tc, *tc = &_tc;
+  u32 ack, before, initial_cwnd, initial_ssthresh, i;
+  u64 pacing_rate;
+
+  tcp_test_set_time (thread_index, 1);
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  TCP_TEST ((tcp_cc_get_pacing_rate (tc) == (u64) (2.0 * tc->cwnd / 0.010)),
+	    "HyStart++ standard slow start paces at 2x");
+  ack = tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+  TCP_TEST ((tcp_cc_get_pacing_rate (tc) == (u64) (1.25 * tc->cwnd / 0.010)),
+	    "CSS paces at 1.25x despite the high ssthresh");
+  initial_ssthresh = tc->ssthresh;
+  tc->ssthresh = tc->cwnd;
+  pacing_rate = tcp_cc_get_pacing_rate (tc);
+  tc->ssthresh = initial_ssthresh;
+  TCP_TEST ((pacing_rate == (u64) ((f64) tc->cwnd / 0.010)),
+	    "CSS uses 1x pacing once cwnd reaches ssthresh");
+
+  /* CSS grows at a quarter of the slow start rate */
+  before = tc->cwnd;
+  ack += snd_mss;
+  tcp_test_cubic_hystart_ack (tc, ack, 40 * snd_mss, snd_mss, 0.020);
+  TCP_TEST ((tc->cwnd == before + snd_mss / 4), "HyStart++ enters conservative slow start");
+
+  /* Lower rtt in the next round resumes slow start */
+  ack = 40 * snd_mss;
+  tcp_test_cubic_hystart_ack (tc, ack, 80 * snd_mss, snd_mss, 0.010);
+  for (i = 1; i < 8; i++)
+    {
+      ack += snd_mss;
+      tcp_test_cubic_hystart_ack (tc, ack, 80 * snd_mss, snd_mss, 0.010);
+    }
+  before = tc->cwnd;
+  ack += snd_mss;
+  tcp_test_cubic_hystart_ack (tc, ack, 80 * snd_mss, snd_mss, 0.010);
+  TCP_TEST ((tc->cwnd == before + snd_mss), "HyStart++ resumes standard slow start");
+  TCP_TEST ((tcp_cc_get_pacing_rate (tc) == (u64) (2.0 * tc->cwnd / 0.010)),
+	    "HyStart++ restores 2x pacing after a transient delay increase");
+
+  /* Five inflated CSS rounds exit to avoidance, cwnd is rounded */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  ack = tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+  tcp_test_cubic_hystart_ack (tc, ack + snd_mss, 40 * snd_mss, snd_mss, 0.020);
+  for (i = 0; i < 5; i++)
+    {
+      ack = (40 + i * 40) * snd_mss;
+      tcp_test_cubic_hystart_ack (tc, ack, ack + 40 * snd_mss, snd_mss, 0.020);
+    }
+  TCP_TEST ((tc->ssthresh == tc->cwnd), "HyStart++ exits CSS after five rounds");
+  TCP_TEST ((tc->cwnd % snd_mss == 0), "lossless HyStart++ exit rounds cwnd to segments");
+  TCP_TEST ((tcp_cc_get_pacing_rate (tc) == (u64) ((f64) tc->cwnd / 0.010)),
+	    "HyStart++ exit restores 1x avoidance pacing");
+
+  /* Unpaced growth capped at 8 mss per ack */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  before = tc->cwnd;
+  tcp_test_cubic_hystart_ack (tc, 2 * snd_mss, 40 * snd_mss, 16 * snd_mss, 0.010);
+  TCP_TEST ((tc->cwnd == before + 8 * snd_mss), "HyStart++ caps unpaced ACK growth");
+
+  /* Paced growth is not capped */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  tc->connection.flags |= TRANSPORT_CONNECTION_F_IS_TX_PACED;
+  before = tc->cwnd;
+  tcp_test_cubic_hystart_ack (tc, 2 * snd_mss, 40 * snd_mss, 16 * snd_mss, 0.010);
+  TCP_TEST ((tc->cwnd == before + 16 * snd_mss), "HyStart++ preserves paced ACK growth");
+
+  /* FIFO limited acks do not grow cwnd but are sampled */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  before = tc->cwnd;
+  tc->tx_fifo_size = before;
+  ack = tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+  TCP_TEST ((tc->cwnd == before), "HyStart++ respects FIFO ceiling in standard slow start");
+  tcp_test_cubic_hystart_ack (tc, ack + snd_mss, 40 * snd_mss, snd_mss, 0.020);
+  TCP_TEST ((tc->cwnd == before), "HyStart++ respects FIFO ceiling in conservative slow start");
+  tc->tx_fifo_size *= 2;
+  tcp_test_cubic_hystart_ack (tc, ack + 2 * snd_mss, 40 * snd_mss, snd_mss, 0.020);
+  TCP_TEST ((tc->cwnd == before + snd_mss / 4), "FIFO-limited RTT samples still trigger CSS");
+
+  /* Undo restores HyStart++, only it caps unpaced growth */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  initial_cwnd = tc->cwnd;
+  initial_ssthresh = tc->ssthresh;
+  tc->cc_algo->congestion (tc);
+  tc->cwnd = initial_cwnd;
+  tc->ssthresh = initial_ssthresh;
+  tc->cc_algo->undo_recovery (tc);
+  tcp_test_cubic_hystart_ack (tc, 2 * snd_mss, 40 * snd_mss, 16 * snd_mss, 0.010);
+  TCP_TEST ((tc->cwnd == initial_cwnd + 8 * snd_mss), "spurious loss restores HyStart++");
+
+  /* Undo restores CSS, which can still resume slow start */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  ack = tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+  initial_cwnd = tc->cwnd;
+  initial_ssthresh = tc->ssthresh;
+  tc->cc_algo->congestion (tc);
+  tc->cwnd = initial_cwnd;
+  tc->ssthresh = initial_ssthresh;
+  tc->cc_algo->undo_recovery (tc);
+  ack += snd_mss;
+  tcp_test_cubic_hystart_ack (tc, ack, 40 * snd_mss, snd_mss, 0.010);
+  TCP_TEST ((tc->cwnd == initial_cwnd + snd_mss / 4), "spurious loss in CSS restores CSS");
+  for (i = 1; i < 8; i++)
+    {
+      ack += snd_mss;
+      tcp_test_cubic_hystart_ack (tc, ack, 40 * snd_mss, snd_mss, 0.010);
+    }
+  before = tc->cwnd;
+  ack += snd_mss;
+  tcp_test_cubic_hystart_ack (tc, ack, 40 * snd_mss, snd_mss, 0.010);
+  TCP_TEST ((tc->cwnd == before + snd_mss), "restored CSS resumes slow start on lower RTT");
+
+  /* CSS rounds before undo still count */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+  for (i = 0; i < 3; i++)
+    {
+      ack = (40 + i * 40) * snd_mss;
+      tcp_test_cubic_hystart_ack (tc, ack, ack + 40 * snd_mss, snd_mss, 0.020);
+    }
+  initial_cwnd = tc->cwnd;
+  initial_ssthresh = tc->ssthresh;
+  tc->cc_algo->congestion (tc);
+  tc->cwnd = initial_cwnd;
+  tc->ssthresh = initial_ssthresh;
+  tc->cc_algo->undo_recovery (tc);
+  for (i = 3; i < 5; i++)
+    {
+      ack = (40 + i * 40) * snd_mss;
+      tcp_test_cubic_hystart_ack (tc, ack, ack + 40 * snd_mss, snd_mss, 0.020);
+    }
+  TCP_TEST ((tc->ssthresh == tc->cwnd), "CSS rounds before a spurious loss still count");
+
+  /* Under N_RTT_SAMPLE samples per round, e.g., no timestamps, no CSS */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  tcp_test_cubic_hystart_ack (tc, 2 * snd_mss, 11 * snd_mss, snd_mss, 0.010);
+  tcp_test_cubic_hystart_ack (tc, 11 * snd_mss, 40 * snd_mss, snd_mss, 0.020);
+  before = tc->cwnd;
+  tcp_test_cubic_hystart_ack (tc, 12 * snd_mss, 40 * snd_mss, snd_mss, 0.020);
+  TCP_TEST ((tc->cwnd == before + snd_mss), "HyStart++ needs N_RTT_SAMPLE samples per round");
+
+  /* Without CSS, a delay increase exits slow start */
+  tcp_test_cubic_config ("no-hystart-css");
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  ack = tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+  /* Restore before asserts can return */
+  tcp_test_cubic_config ("hystart-css");
+  TCP_TEST ((tc->ssthresh == tc->cwnd), "HyStart++ without CSS exits slow start");
+  before = tc->cwnd;
+  ack += snd_mss;
+  tcp_test_cubic_hystart_ack (tc, ack, 40 * snd_mss, snd_mss, 0.020);
+  TCP_TEST ((tc->cwnd < before + snd_mss / 4), "HyStart++ without CSS skips CSS growth");
+
+  /* Empty acks after a drain do not end CSS rounds */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  ack = tcp_test_cubic_hystart_enter_css (tc, snd_mss);
+  tcp_test_cubic_hystart_ack (tc, 40 * snd_mss, 40 * snd_mss, 40 * snd_mss - ack, 0.020);
+  for (i = 0; i < 5; i++)
+    tcp_test_cubic_hystart_ack (tc, 40 * snd_mss, 40 * snd_mss, 0, 0);
+  TCP_TEST ((tcp_in_slowstart (tc)), "HyStart++ ignores empty ACKs for CSS rounds");
+
+  /* ssthresh exit rounds cwnd, Reno-friendly growth follows */
+  tcp_test_cubic_hystart_init (tc, thread_index, snd_mss);
+  tc->ssthresh = 28 * snd_mss;
+  tc->cwnd = tc->ssthresh + snd_mss / 2;
+  before = tc->ssthresh;
+  ack = tc->snd_una;
+  for (u32 rtt = 1; rtt <= 10; rtt++)
+    {
+      tcp_test_set_time (thread_index, 1 + rtt * 0.010);
+      for (i = 0; i < 28; i++)
+	{
+	  ack += snd_mss;
+	  tcp_test_cubic_hystart_ack (tc, ack, ack + tc->cwnd, snd_mss, 0.010);
+	}
+    }
+  TCP_TEST ((tc->cwnd % snd_mss == 0), "ssthresh exit rounds cwnd to segments");
+  TCP_TEST ((tc->cwnd > before), "ssthresh exit grows the Reno-friendly window");
+  tcp_test_set_time (thread_index, 1);
+
+  return 0;
+}
+
 /* RFC 9438 excludes continuously application-limited time from the CUBIC
  * epoch even when the flight never drains and START_TX is not generated. */
 static int
@@ -2672,6 +2984,12 @@ tcp_test_cubic (vlib_main_t *vm, unformat_input_t *input)
   if ((rv = tcp_test_cwnd_limited_growth ()))
     return rv;
 
+  if ((rv = tcp_test_cubic_hystart ()))
+    return rv;
+
+  if ((rv = tcp_test_cubic_hystart_drained_rounds ()))
+    return rv;
+
   if ((rv = tcp_test_cubic_app_limited ()))
     return rv;
 
@@ -6480,6 +6798,7 @@ tcp_test_delivery (vlib_main_t * vm, unformat_input_t * input)
   TCP_TEST (ac->delivered == 2 * burst, "delivered should be 200 is %u", ac->delivered);
   TCP_TEST (ac->prior_delivered == 3 * burst + 30, "sample delivered should be %u", 3 * burst + 30);
   TCP_TEST (ac->flags & TCP_BTS_IS_RXT, "is retransmitted");
+  TCP_TEST (ac->rtt_time == 0, "BT does not export an ambiguous retransmit RTT");
   /* Sample is app limited because of the retransmits */
   TCP_TEST (ac->flags & TCP_BTS_IS_APP_LIMITED, "is app limited");
   TCP_TEST (tc->app_limited, "app limited should be set");