* handshake may make it look as if time has flown in the opposite
* direction for us.
*/
- tcp_set_time_now (vlib_get_thread_index ());
+ tcp_set_time_now (tcp_get_worker (vlib_get_thread_index ()));
time_now = tcp_time_now ();
tc->iss = random_u32 (&time_now);
void
tcp_enable_pacing (tcp_connection_t * tc)
{
- u32 max_burst, byte_rate;
- max_burst = 16 * tc->snd_mss;
+ u32 initial_bucket, byte_rate;
+ initial_bucket = 16 * tc->snd_mss;
byte_rate = 2 << 16;
- transport_connection_tx_pacer_init (&tc->connection, byte_rate, max_burst);
+ transport_connection_tx_pacer_init (&tc->connection, byte_rate,
+ initial_bucket);
tc->mrtt_us = (u32) ~ 0;
}
}
static int
-tcp_connection_open (transport_endpoint_t * rmt)
+tcp_session_open (transport_endpoint_cfg_t * rmt)
{
tcp_main_t *tm = vnet_get_tcp_main ();
tcp_connection_t *tc;
return tc->c_c_index;
}
-static int
-tcp_session_open (transport_endpoint_t * tep)
-{
- return tcp_connection_open (tep);
-}
-
const char *tcp_dbg_evt_str[] = {
#define _(sym, str) str,
foreach_tcp_dbg_evt
hole = scoreboard_first_hole (sb);
if (hole)
- s = format (s, "\n%Uhead %u tail %u %u holes:\n", format_white_space,
- indent, sb->head, sb->tail, pool_elts (sb->holes));
+ s = format (s, "\n%Uhead %u tail %u %u holes:\n%U", format_white_space,
+ indent, sb->head, sb->tail, pool_elts (sb->holes),
+ format_white_space, indent);
while (hole)
{
- s = format (s, "%U%U", format_white_space, indent, format_tcp_sack_hole,
- hole, tc);
+ s = format (s, "%U", format_tcp_sack_hole, hole, tc);
hole = scoreboard_next_hole (sb, hole);
}
{
int snd_space, snt_limited;
- if (PREDICT_TRUE (!tcp_in_fastrecovery (tc)))
- {
- snd_space = tcp_available_output_snd_space (tc);
+ if (PREDICT_FALSE (tcp_in_fastrecovery (tc)))
+ return 0;
- /* If we haven't gotten dupacks or if we did and have gotten sacked
- * bytes then we can still send as per Limited Transmit (RFC3042) */
- if (PREDICT_FALSE (tc->rcv_dupacks != 0
- && (tcp_opts_sack_permitted (tc)
- && tc->sack_sb.last_sacked_bytes == 0)))
- {
- if (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt)
- tc->limited_transmit = tc->snd_nxt;
- ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt));
-
- snt_limited = tc->snd_nxt - tc->limited_transmit;
- snd_space = clib_max (2 * tc->snd_mss - snt_limited, 0);
- }
- return tcp_round_snd_space (tc, snd_space);
- }
+ snd_space = tcp_available_output_snd_space (tc);
- /* RFC 5681: When previously unsent data is available and the new value of
- * cwnd and the receiver's advertised window allow, a TCP SHOULD send 1*SMSS
- * bytes of previously unsent data. */
- if (tcp_in_fastrecovery (tc) && !tcp_fastrecovery_sent_1_smss (tc))
+ /* If we haven't gotten dupacks or if we did and have gotten sacked
+ * bytes then we can still send as per Limited Transmit (RFC3042) */
+ if (PREDICT_FALSE (tc->rcv_dupacks != 0
+ && (tcp_opts_sack_permitted (tc)
+ && tc->sack_sb.last_sacked_bytes == 0)))
{
- if (tcp_available_cc_snd_space (tc) < tc->snd_mss)
- return 0;
- tcp_fastrecovery_1_smss_on (tc);
- return tc->snd_mss;
- }
+ if (tc->rcv_dupacks == 1 && tc->limited_transmit != tc->snd_nxt)
+ tc->limited_transmit = tc->snd_nxt;
+ ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt));
- return 0;
+ snt_limited = tc->snd_nxt - tc->limited_transmit;
+ snd_space = clib_max (2 * tc->snd_mss - snt_limited, 0);
+ }
+ return tcp_round_snd_space (tc, snd_space);
}
u32
static void
tcp_update_time (f64 now, u8 thread_index)
{
- tcp_set_time_now (thread_index);
- tw_timer_expire_timers_16t_2w_512sl (&tcp_main.
- wrk_ctx[thread_index].timer_wheel,
- now);
- tcp_do_fastretransmits (thread_index);
- tcp_flush_frames_to_output (thread_index);
+ tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
+
+ tcp_set_time_now (wrk);
+ tw_timer_expire_timers_16t_2w_512sl (&wrk->timer_wheel, now);
+ tcp_do_fastretransmits (wrk);
+ tcp_flush_frames_to_output (wrk);
}
static u32
/* *INDENT-ON* */
void
-tcp_update_pacer (tcp_connection_t * tc)
+tcp_connection_tx_pacer_update (tcp_connection_t * tc)
{
f64 srtt;
((f64) tc->cwnd) / srtt);
}
+void
+tcp_connection_tx_pacer_reset (tcp_connection_t * tc, u32 window,
+ u32 start_bucket)
+{
+ tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+ u32 byte_rate = window / ((f64) TCP_TICK * tc->srtt);
+ u64 last_time = wrk->vm->clib_time.last_cpu_time;
+ transport_connection_tx_pacer_reset (&tc->connection, byte_rate,
+ start_bucket, last_time);
+}
+
static void
tcp_timer_keep_handler (u32 conn_index)
{
static clib_error_t *
tcp_main_enable (vlib_main_t * vm)
{
- tcp_main_t *tm = vnet_get_tcp_main ();
vlib_thread_main_t *vtm = vlib_get_thread_main ();
+ u32 num_threads, n_workers, prealloc_conn_per_wrk;
+ tcp_connection_t *tc __attribute__ ((unused));
+ tcp_main_t *tm = vnet_get_tcp_main ();
clib_error_t *error = 0;
- u32 num_threads;
int thread;
- tcp_connection_t *tc __attribute__ ((unused));
- u32 preallocated_connections_per_thread;
if ((error = vlib_call_init_function (vm, ip_main_init)))
return error;
num_threads = 1 /* main thread */ + vtm->n_threads;
vec_validate (tm->connections, num_threads - 1);
+ vec_validate (tm->wrk_ctx, num_threads - 1);
+ n_workers = num_threads == 1 ? 1 : vtm->n_threads;
+ prealloc_conn_per_wrk = tm->preallocated_connections / n_workers;
- /*
- * Preallocate connections. Assume that thread 0 won't
- * use preallocated threads when running multi-core
- */
- if (num_threads == 1)
- {
- thread = 0;
- preallocated_connections_per_thread = tm->preallocated_connections;
- }
- else
- {
- thread = 1;
- preallocated_connections_per_thread =
- tm->preallocated_connections / (num_threads - 1);
- }
- for (; thread < num_threads; thread++)
+ for (thread = 0; thread < num_threads; thread++)
{
- if (preallocated_connections_per_thread)
- pool_init_fixed (tm->connections[thread],
- preallocated_connections_per_thread);
+ vec_validate (tm->wrk_ctx[thread].pending_fast_rxt, 0);
+ vec_validate (tm->wrk_ctx[thread].ongoing_fast_rxt, 0);
+ vec_validate (tm->wrk_ctx[thread].postponed_fast_rxt, 0);
+ vec_reset_length (tm->wrk_ctx[thread].pending_fast_rxt);
+ vec_reset_length (tm->wrk_ctx[thread].ongoing_fast_rxt);
+ vec_reset_length (tm->wrk_ctx[thread].postponed_fast_rxt);
+ tm->wrk_ctx[thread].vm = vlib_mains[thread];
+
+ /*
+ * Preallocate connections. Assume that thread 0 won't
+ * use preallocated threads when running multi-core
+ */
+ if ((thread > 0 || num_threads == 1) && prealloc_conn_per_wrk)
+ pool_init_fixed (tm->connections[thread], prealloc_conn_per_wrk);
}
/*
clib_spinlock_init (&tm->half_open_lock);
}
- vec_validate (tm->wrk_ctx, num_threads - 1);
tcp_initialize_timer_wheels (tm);
tm->bytes_per_buffer = vlib_buffer_free_list_buffer_size
tcp_connection_t _dummy_tc, *dummy_tc = &_dummy_tc;
sack_block_t *block;
+ if (!TCP_SCOREBOARD_TRACE)
+ {
+ s = format (s, "scoreboard tracing not enabled");
+ return s;
+ }
+
if (!tc)
return s;
#if TCP_SCOREBOARD_TRACE
trace = tc->sack_sb.trace;
trace_len = vec_len (tc->sack_sb.trace);
-#else
- trace = 0;
- trace_len = 0;
#endif
for (i = 0; i < trace_len; i++)
Code Review / vpp.git / blobdiff