tcp: minimize use of tls

Also propagate tcp worker context instead of retrieving it multiple
times.

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

diff --git a/src/vnet/tcp/tcp.c b/src/vnet/tcp/tcp.c
index bdf9c7a..1726355 100644 (file)
--- a/src/vnet/tcp/tcp.c
+++ b/src/vnet/tcp/tcp.c
@@ -546,7 +546,7 @@ tcp_init_snd_vars (tcp_connection_t * tc)
    * 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);
@@ -1113,12 +1113,12 @@ tcp_session_tx_fifo_offset (transport_connection_t * trans_conn)
 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
@@ -1291,13 +1291,12 @@ tcp_initialize_timer_wheels (tcp_main_t * tm)
 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;
@@ -1320,27 +1319,11 @@ tcp_main_enable (vlib_main_t * vm)
   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)
+  for (thread = 0; thread < num_threads; thread++)
     {
-      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++)
-    {
-      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);
@@ -1348,6 +1331,13 @@ tcp_main_enable (vlib_main_t * vm)
       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);
     }
 
   /*

diff --git a/src/vnet/tcp/tcp.h b/src/vnet/tcp/tcp.h
index f7424c3..71af461 100644 (file)
--- a/src/vnet/tcp/tcp.h
+++ b/src/vnet/tcp/tcp.h
@@ -470,6 +470,12 @@ vnet_get_tcp_main ()
   return &tcp_main;
 }
 
+always_inline tcp_worker_ctx_t *
+tcp_get_worker (u32 thread_index)
+{
+  return &tcp_main.wrk_ctx[thread_index];
+}
+
 always_inline tcp_header_t *
 tcp_buffer_hdr (vlib_buffer_t * b)
 {
@@ -559,10 +565,11 @@ void tcp_send_fin (tcp_connection_t * tc);
 void tcp_init_mss (tcp_connection_t * tc);
 void tcp_update_burst_snd_vars (tcp_connection_t * tc);
 void tcp_update_rto (tcp_connection_t * tc);
-void tcp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4);
-void tcp_flush_frames_to_output (u8 thread_index);
-void tcp_program_fastretransmit (tcp_connection_t * tc);
-void tcp_do_fastretransmits (u32 thread_index);
+void tcp_flush_frame_to_output (tcp_worker_ctx_t * wrk, u8 is_ip4);
+void tcp_flush_frames_to_output (tcp_worker_ctx_t * wrk);
+void tcp_program_fastretransmit (tcp_worker_ctx_t * wrk,
+                                tcp_connection_t * tc);
+void tcp_do_fastretransmits (tcp_worker_ctx_t * wrk);
 
 always_inline u32
 tcp_end_seq (tcp_header_t * th, u32 len)
@@ -680,10 +687,14 @@ tcp_is_lost_fin (tcp_connection_t * tc)
 }
 
 u32 tcp_snd_space (tcp_connection_t * tc);
-int tcp_retransmit_first_unacked (tcp_connection_t * tc);
-int tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size);
-int tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size);
-int tcp_fast_retransmit (tcp_connection_t * tc, u32 burst_size);
+int tcp_retransmit_first_unacked (tcp_worker_ctx_t * wrk,
+                                 tcp_connection_t * tc);
+int tcp_fast_retransmit_no_sack (tcp_worker_ctx_t * wrk,
+                                tcp_connection_t * tc, u32 burst_size);
+int tcp_fast_retransmit_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+                             u32 burst_size);
+int tcp_fast_retransmit (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+                        u32 burst_size);
 void tcp_cc_init_congestion (tcp_connection_t * tc);
 void tcp_cc_fastrecovery_exit (tcp_connection_t * tc);
 
@@ -699,6 +710,12 @@ tcp_time_now (void)
   return tcp_main.wrk_ctx[vlib_get_thread_index ()].time_now;
 }
 
+always_inline u32
+tcp_time_now_w_thread (u32 thread_index)
+{
+  return tcp_main.wrk_ctx[thread_index].time_now;
+}
+
 always_inline f64
 tcp_time_now_us (u32 thread_index)
 {
@@ -706,11 +723,10 @@ tcp_time_now_us (u32 thread_index)
 }
 
 always_inline u32
-tcp_set_time_now (u32 thread_index)
+tcp_set_time_now (tcp_worker_ctx_t * wrk)
 {
-  tcp_main.wrk_ctx[thread_index].time_now = clib_cpu_time_now ()
-    * tcp_main.tstamp_ticks_per_clock;
-  return tcp_main.wrk_ctx[thread_index].time_now;
+  wrk->time_now = clib_cpu_time_now () * tcp_main.tstamp_ticks_per_clock;
+  return wrk->time_now;
 }
 
 u32 tcp_push_header (tcp_connection_t * tconn, vlib_buffer_t * b);

diff --git a/src/vnet/tcp/tcp_input.c b/src/vnet/tcp/tcp_input.c
index 154b9ac..af13c5f 100644 (file)
--- a/src/vnet/tcp/tcp_input.c
+++ b/src/vnet/tcp/tcp_input.c
@@ -258,7 +258,7 @@ tcp_update_timestamp (tcp_connection_t * tc, u32 seq, u32 seq_end)
     {
       ASSERT (timestamp_leq (tc->tsval_recent, tc->rcv_opts.tsval));
       tc->tsval_recent = tc->rcv_opts.tsval;
-      tc->tsval_recent_age = tcp_time_now ();
+      tc->tsval_recent_age = tcp_time_now_w_thread (tc->c_thread_index);
     }
 }
 
@@ -308,7 +308,7 @@ tcp_segment_validate (vlib_main_t * vm, tcp_connection_t * tc0,
       /* If it just so happens that a segment updates tsval_recent for a
        * segment over 24 days old, invalidate tsval_recent. */
       if (timestamp_lt (tc0->tsval_recent_age + TCP_PAWS_IDLE,
-                       tcp_time_now ()))
+                       tcp_time_now_w_thread (tc0->c_thread_index)))
        {
          /* Age isn't reset until we get a valid tsval (bsd inspired) */
          tc0->tsval_recent = 0;
@@ -470,7 +470,8 @@ tcp_update_rtt (tcp_connection_t * tc, u32 ack)
    * seq_lt (tc->snd_una, ack). This is a condition for calling update_rtt */
   else if (tcp_opts_tstamp (&tc->rcv_opts) && tc->rcv_opts.tsecr)
     {
-      mrtt = clib_max (tcp_time_now () - tc->rcv_opts.tsecr, 1);
+      u32 now = tcp_time_now_w_thread (tc->c_thread_index);
+      mrtt = clib_max (now - tc->rcv_opts.tsecr, 1);
     }
 
   /* Ignore dubious measurements */
@@ -1185,9 +1186,8 @@ tcp_should_fastrecover (tcp_connection_t * tc)
 }
 
 void
-tcp_program_fastretransmit (tcp_connection_t * tc)
+tcp_program_fastretransmit (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
 {
-  tcp_worker_ctx_t *wrk = &tcp_main.wrk_ctx[tc->c_thread_index];
   if (!(tc->flags & TCP_CONN_FRXT_PENDING))
     {
       vec_add1 (wrk->pending_fast_rxt, tc->c_c_index);
@@ -1196,11 +1196,10 @@ tcp_program_fastretransmit (tcp_connection_t * tc)
 }
 
 void
-tcp_do_fastretransmits (u32 thread_index)
+tcp_do_fastretransmits (tcp_worker_ctx_t * wrk)
 {
-  tcp_worker_ctx_t *wrk = &tcp_main.wrk_ctx[thread_index];
+  u32 *ongoing_fast_rxt, burst_bytes, sent_bytes, thread_index;
   u32 max_burst_size, burst_size, n_segs = 0, n_segs_now;
-  u32 *ongoing_fast_rxt, burst_bytes, sent_bytes;
   tcp_connection_t *tc;
   u64 last_cpu_time;
   int i;
@@ -1209,6 +1208,7 @@ tcp_do_fastretransmits (u32 thread_index)
       && vec_len (wrk->postponed_fast_rxt) == 0)
     return;
 
+  thread_index = wrk->vm->thread_index;
   last_cpu_time = wrk->vm->clib_time.last_cpu_time;
   ongoing_fast_rxt = wrk->ongoing_fast_rxt;
   vec_append (ongoing_fast_rxt, wrk->postponed_fast_rxt);
@@ -1240,15 +1240,14 @@ tcp_do_fastretransmits (u32 thread_index)
       burst_size = clib_min (burst_size, burst_bytes / tc->snd_mss);
       if (!burst_size)
        {
-         tcp_program_fastretransmit (tc);
+         tcp_program_fastretransmit (wrk, tc);
          continue;
        }
 
-      n_segs_now = tcp_fast_retransmit (tc, burst_size);
+      n_segs_now = tcp_fast_retransmit (wrk, tc, burst_size);
       sent_bytes = clib_min (n_segs_now * tc->snd_mss, burst_bytes);
       transport_connection_tx_pacer_update_bytes (&tc->connection,
                                                  sent_bytes);
-
       n_segs += n_segs_now;
     }
   _vec_len (ongoing_fast_rxt) = 0;
@@ -1267,7 +1266,7 @@ tcp_cc_handle_event (tcp_connection_t * tc, u32 is_dack)
     {
       if (tc->bytes_acked)
        goto partial_ack;
-      tcp_program_fastretransmit (tc);
+      tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index), tc);
       return;
     }
   /*
@@ -1322,7 +1321,8 @@ tcp_cc_handle_event (tcp_connection_t * tc, u32 is_dack)
 
          byte_rate = (0.3 * tc->cwnd) / ((f64) TCP_TICK * tc->srtt);
          transport_connection_tx_pacer_init (&tc->connection, byte_rate, 0);
-         tcp_program_fastretransmit (tc);
+         tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index),
+                                     tc);
          return;
        }
       else if (!tc->bytes_acked
@@ -1439,7 +1439,7 @@ partial_ack:
   /*
    * Since this was a partial ack, try to retransmit some more data
    */
-  tcp_program_fastretransmit (tc);
+  tcp_program_fastretransmit (tcp_get_worker (tc->c_thread_index), tc);
 }
 
 /**
@@ -2102,7 +2102,7 @@ tcp46_established_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
                                                 thread_index);
   err_counters[TCP_ERROR_EVENT_FIFO_FULL] = errors;
   tcp_store_err_counters (established, err_counters);
-  tcp_flush_frame_to_output (vm, thread_index, is_ip4);
+  tcp_flush_frame_to_output (tcp_get_worker (thread_index), is_ip4);
 
   return frame->n_vectors;
 }
@@ -3393,7 +3393,7 @@ tcp46_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
   u16 nexts[VLIB_FRAME_SIZE], *next;
 
-  tcp_set_time_now (thread_index);
+  tcp_set_time_now (tcp_get_worker (thread_index));
 
   from = vlib_frame_vector_args (frame);
   n_left_from = frame->n_vectors;

diff --git a/src/vnet/tcp/tcp_output.c b/src/vnet/tcp/tcp_output.c
index 81579ef..c315c03 100644 (file)
--- a/src/vnet/tcp/tcp_output.c
+++ b/src/vnet/tcp/tcp_output.c
@@ -361,7 +361,7 @@ tcp_make_established_options (tcp_connection_t * tc, tcp_options_t * opts)
   if (tcp_opts_tstamp (&tc->rcv_opts))
     {
       opts->flags |= TCP_OPTS_FLAG_TSTAMP;
-      opts->tsval = tcp_time_now ();
+      opts->tsval = tcp_time_now_w_thread (tc->c_thread_index);
       opts->tsecr = tc->tsval_recent;
       len += TCP_OPTION_LEN_TIMESTAMP;
     }
@@ -459,41 +459,37 @@ tcp_init_mss (tcp_connection_t * tc)
 }
 
 static int
-tcp_alloc_tx_buffers (tcp_main_t * tm, u8 thread_index, u16 * n_bufs,
-                     u32 wanted)
+tcp_alloc_tx_buffers (tcp_worker_ctx_t * wrk, u16 * n_bufs, u32 wanted)
 {
-  tcp_worker_ctx_t *ctx = &tm->wrk_ctx[thread_index];
   vlib_main_t *vm = vlib_get_main ();
   u32 n_alloc;
 
   ASSERT (wanted > *n_bufs);
-  vec_validate_aligned (ctx->tx_buffers, wanted - 1, CLIB_CACHE_LINE_BYTES);
-  n_alloc = vlib_buffer_alloc (vm, &ctx->tx_buffers[*n_bufs],
+  vec_validate_aligned (wrk->tx_buffers, wanted - 1, CLIB_CACHE_LINE_BYTES);
+  n_alloc = vlib_buffer_alloc (vm, &wrk->tx_buffers[*n_bufs],
                               wanted - *n_bufs);
   *n_bufs += n_alloc;
-  _vec_len (ctx->tx_buffers) = *n_bufs;
+  _vec_len (wrk->tx_buffers) = *n_bufs;
   return n_alloc;
 }
 
 always_inline int
-tcp_get_free_buffer_index (tcp_main_t * tm, u32 * bidx)
+tcp_get_free_buffer_index (tcp_worker_ctx_t * wrk, u32 * bidx)
 {
-  u32 thread_index = vlib_get_thread_index ();
-  tcp_worker_ctx_t *ctx = &tm->wrk_ctx[thread_index];
-  u16 n_bufs = vec_len (ctx->tx_buffers);
+  u16 n_bufs = vec_len (wrk->tx_buffers);
 
-  TCP_DBG_BUFFER_ALLOC_MAYBE_FAIL (thread_index);
+  TCP_DBG_BUFFER_ALLOC_MAYBE_FAIL (wrk->vm->thread_index);
 
   if (PREDICT_FALSE (!n_bufs))
     {
-      if (!tcp_alloc_tx_buffers (tm, thread_index, &n_bufs, VLIB_FRAME_SIZE))
+      if (!tcp_alloc_tx_buffers (wrk, &n_bufs, VLIB_FRAME_SIZE))
        {
          *bidx = ~0;
          return -1;
        }
     }
-  *bidx = ctx->tx_buffers[--n_bufs];
-  _vec_len (ctx->tx_buffers) = n_bufs;
+  *bidx = wrk->tx_buffers[--n_bufs];
+  _vec_len (wrk->tx_buffers) = n_bufs;
   return 0;
 }
 
@@ -644,11 +640,10 @@ tcp_make_synack (tcp_connection_t * tc, vlib_buffer_t * b)
 }
 
 always_inline void
-tcp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_ip_lookup_i (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
                            u8 is_ip4, u32 fib_index, u8 flush)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  u32 thread_index = vlib_get_thread_index ();
+  vlib_main_t *vm = wrk->vm;
   u32 *to_next, next_index;
   vlib_frame_t *f;
 
@@ -662,12 +657,12 @@ tcp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
   next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
   tcp_trajectory_add_start (b, 1);
 
-  f = tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4];
+  f = wrk->ip_lookup_tx_frames[!is_ip4];
   if (!f)
     {
       f = vlib_get_frame_to_node (vm, next_index);
       ASSERT (f);
-      tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = f;
+      wrk->ip_lookup_tx_frames[!is_ip4] = f;
     }
 
   to_next = vlib_frame_vector_args (f);
@@ -676,32 +671,30 @@ tcp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
   if (flush || f->n_vectors == VLIB_FRAME_SIZE)
     {
       vlib_put_frame_to_node (vm, next_index, f);
-      tm->wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = 0;
+      wrk->ip_lookup_tx_frames[!is_ip4] = 0;
     }
 }
 
 static void
-tcp_enqueue_to_ip_lookup_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
-                             u8 is_ip4, u32 fib_index)
+tcp_enqueue_to_ip_lookup_now (tcp_worker_ctx_t * wrk, vlib_buffer_t * b,
+                             u32 bi, u8 is_ip4, u32 fib_index)
 {
-  tcp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 1);
+  tcp_enqueue_to_ip_lookup_i (wrk, b, bi, is_ip4, fib_index, 1);
 }
 
 static void
-tcp_enqueue_to_ip_lookup (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_ip_lookup (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
                          u8 is_ip4, u32 fib_index)
 {
-  tcp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 0);
-  if (vm->thread_index == 0 && vlib_num_workers ())
-    session_flush_frames_main_thread (vm);
+  tcp_enqueue_to_ip_lookup_i (wrk, b, bi, is_ip4, fib_index, 0);
+  if (wrk->vm->thread_index == 0 && vlib_num_workers ())
+    session_flush_frames_main_thread (wrk->vm);
 }
 
 always_inline void
-tcp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_output_i (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
                         u8 is_ip4, u8 flush)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  u32 thread_index = vlib_get_thread_index ();
   u32 *to_next, next_index;
   vlib_frame_t *f;
 
@@ -713,34 +706,35 @@ tcp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
   tcp_trajectory_add_start (b, 2);
 
   /* Get frame to v4/6 output node */
-  f = tm->wrk_ctx[thread_index].tx_frames[!is_ip4];
+  f = wrk->tx_frames[!is_ip4];
   if (!f)
     {
-      f = vlib_get_frame_to_node (vm, next_index);
+      f = vlib_get_frame_to_node (wrk->vm, next_index);
       ASSERT (f);
-      tm->wrk_ctx[thread_index].tx_frames[!is_ip4] = f;
+      wrk->tx_frames[!is_ip4] = f;
     }
   to_next = vlib_frame_vector_args (f);
   to_next[f->n_vectors] = bi;
   f->n_vectors += 1;
   if (flush || f->n_vectors == VLIB_FRAME_SIZE)
     {
-      vlib_put_frame_to_node (vm, next_index, f);
-      tm->wrk_ctx[thread_index].tx_frames[!is_ip4] = 0;
+      vlib_put_frame_to_node (wrk->vm, next_index, f);
+      wrk->tx_frames[!is_ip4] = 0;
     }
 }
 
 static void
-tcp_enqueue_to_output (vlib_main_t * vm, vlib_buffer_t * b, u32 bi, u8 is_ip4)
+tcp_enqueue_to_output (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
+                      u8 is_ip4)
 {
-  tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 0);
+  tcp_enqueue_to_output_i (wrk, b, bi, is_ip4, 0);
 }
 
 static void
-tcp_enqueue_to_output_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
+tcp_enqueue_to_output_now (tcp_worker_ctx_t * wrk, vlib_buffer_t * b, u32 bi,
                           u8 is_ip4)
 {
-  tcp_enqueue_to_output_i (vm, b, bi, is_ip4, 1);
+  tcp_enqueue_to_output_i (wrk, b, bi, is_ip4, 1);
 }
 
 static int
@@ -830,10 +824,10 @@ tcp_make_reset_in_place (vlib_main_t * vm, vlib_buffer_t * b0,
 void
 tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
 {
+  tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+  vlib_main_t *vm = wrk->vm;
   vlib_buffer_t *b;
   u32 bi, sw_if_index, fib_index;
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  vlib_main_t *vm = vlib_get_main ();
   u8 tcp_hdr_len, flags = 0;
   tcp_header_t *th, *pkt_th;
   u32 seq, ack;
@@ -841,7 +835,7 @@ tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
   ip6_header_t *ih6, *pkt_ih6;
   fib_protocol_t fib_proto;
 
-  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
     return;
 
   b = vlib_get_buffer (vm, bi);
@@ -899,7 +893,7 @@ tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
       ASSERT (!bogus);
     }
 
-  tcp_enqueue_to_ip_lookup_now (vm, b, bi, is_ip4, fib_index);
+  tcp_enqueue_to_ip_lookup_now (wrk, b, bi, is_ip4, fib_index);
   TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
 }
 
@@ -909,15 +903,15 @@ tcp_send_reset_w_pkt (tcp_connection_t * tc, vlib_buffer_t * pkt, u8 is_ip4)
 void
 tcp_send_reset (tcp_connection_t * tc)
 {
-  vlib_main_t *vm = vlib_get_main ();
-  tcp_main_t *tm = vnet_get_tcp_main ();
+  tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+  vlib_main_t *vm = wrk->vm;
   vlib_buffer_t *b;
   u32 bi;
   tcp_header_t *th;
   u16 tcp_hdr_opts_len, advertise_wnd, opts_write_len;
   u8 flags;
 
-  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
     return;
   b = vlib_get_buffer (vm, bi);
   tcp_init_buffer (vm, b);
@@ -948,15 +942,16 @@ tcp_send_reset (tcp_connection_t * tc)
       th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ih6, &bogus);
       ASSERT (!bogus);
     }
-  tcp_enqueue_to_ip_lookup_now (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
+  tcp_enqueue_to_ip_lookup_now (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
   TCP_EVT_DBG (TCP_EVT_RST_SENT, tc);
 }
 
 static void
-tcp_push_ip_hdr (tcp_main_t * tm, tcp_connection_t * tc, vlib_buffer_t * b)
+tcp_push_ip_hdr (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+                vlib_buffer_t * b)
 {
   tcp_header_t *th = vlib_buffer_get_current (b);
-  vlib_main_t *vm = vlib_get_main ();
+  vlib_main_t *vm = wrk->vm;
   if (tc->c_is_ip4)
     {
       ip4_header_t *ih;
@@ -986,10 +981,10 @@ tcp_push_ip_hdr (tcp_main_t * tm, tcp_connection_t * tc, vlib_buffer_t * b)
 void
 tcp_send_syn (tcp_connection_t * tc)
 {
+  tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+  vlib_main_t *vm = wrk->vm;
   vlib_buffer_t *b;
   u32 bi;
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  vlib_main_t *vm = vlib_get_main ();
 
   /*
    * Setup retransmit and establish timers before requesting buffer
@@ -999,7 +994,7 @@ tcp_send_syn (tcp_connection_t * tc)
   tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
                    tc->rto * TCP_TO_TIMER_TICK);
 
-  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
     return;
 
   b = vlib_get_buffer (vm, bi);
@@ -1011,8 +1006,8 @@ tcp_send_syn (tcp_connection_t * tc)
   tc->rtt_seq = tc->snd_nxt;
   tc->rto_boff = 0;
 
-  tcp_push_ip_hdr (tm, tc, b);
-  tcp_enqueue_to_ip_lookup (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
+  tcp_push_ip_hdr (wrk, tc, b);
+  tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
   TCP_EVT_DBG (TCP_EVT_SYN_SENT, tc);
 }
 
@@ -1020,16 +1015,14 @@ tcp_send_syn (tcp_connection_t * tc)
  * Flush tx frame populated by retransmits and timer pops
  */
 void
-tcp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
+tcp_flush_frame_to_output (tcp_worker_ctx_t * wrk, u8 is_ip4)
 {
-  if (tcp_main.wrk_ctx[thread_index].tx_frames[!is_ip4])
+  if (wrk->tx_frames[!is_ip4])
     {
       u32 next_index;
       next_index = is_ip4 ? tcp4_output_node.index : tcp6_output_node.index;
-      vlib_put_frame_to_node (vm, next_index,
-                             tcp_main.
-                             wrk_ctx[thread_index].tx_frames[!is_ip4]);
-      tcp_main.wrk_ctx[thread_index].tx_frames[!is_ip4] = 0;
+      vlib_put_frame_to_node (wrk->vm, next_index, wrk->tx_frames[!is_ip4]);
+      wrk->tx_frames[!is_ip4] = 0;
     }
 }
 
@@ -1037,17 +1030,15 @@ tcp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
  * Flush ip lookup tx frames populated by timer pops
  */
 static void
-tcp_flush_frame_to_ip_lookup (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
+tcp_flush_frame_to_ip_lookup (tcp_worker_ctx_t * wrk, u8 is_ip4)
 {
-  if (tcp_main.wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4])
+  if (wrk->ip_lookup_tx_frames[!is_ip4])
     {
       u32 next_index;
       next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
-      vlib_put_frame_to_node (vm, next_index,
-                             tcp_main.
-                             wrk_ctx[thread_index].ip_lookup_tx_frames
-                             [!is_ip4]);
-      tcp_main.wrk_ctx[thread_index].ip_lookup_tx_frames[!is_ip4] = 0;
+      vlib_put_frame_to_node (wrk->vm, next_index,
+                             wrk->ip_lookup_tx_frames[!is_ip4]);
+      wrk->ip_lookup_tx_frames[!is_ip4] = 0;
     }
 }
 
@@ -1055,13 +1046,12 @@ tcp_flush_frame_to_ip_lookup (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
  * Flush v4 and v6 tcp and ip-lookup tx frames for thread index
  */
 void
-tcp_flush_frames_to_output (u8 thread_index)
+tcp_flush_frames_to_output (tcp_worker_ctx_t * wrk)
 {
-  vlib_main_t *vm = vlib_get_main ();
-  tcp_flush_frame_to_output (vm, thread_index, 1);
-  tcp_flush_frame_to_output (vm, thread_index, 0);
-  tcp_flush_frame_to_ip_lookup (vm, thread_index, 1);
-  tcp_flush_frame_to_ip_lookup (vm, thread_index, 0);
+  tcp_flush_frame_to_output (wrk, 1);
+  tcp_flush_frame_to_output (wrk, 0);
+  tcp_flush_frame_to_ip_lookup (wrk, 1);
+  tcp_flush_frame_to_ip_lookup (wrk, 0);
 }
 
 /**
@@ -1070,8 +1060,8 @@ tcp_flush_frames_to_output (u8 thread_index)
 void
 tcp_send_fin (tcp_connection_t * tc)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  vlib_main_t *vm = vlib_get_main ();
+  tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+  vlib_main_t *vm = wrk->vm;
   vlib_buffer_t *b;
   u32 bi;
   u8 fin_snt = 0;
@@ -1080,7 +1070,7 @@ tcp_send_fin (tcp_connection_t * tc)
   if (fin_snt)
     tc->snd_nxt = tc->snd_una;
 
-  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
     {
       /* Out of buffers so program fin retransmit ASAP */
       tcp_timer_update (tc, TCP_TIMER_RETRANSMIT, 1);
@@ -1091,7 +1081,7 @@ tcp_send_fin (tcp_connection_t * tc)
   b = vlib_get_buffer (vm, bi);
   tcp_init_buffer (vm, b);
   tcp_make_fin (tc, b);
-  tcp_enqueue_to_output_now (vm, b, bi, tc->c_is_ip4);
+  tcp_enqueue_to_output_now (wrk, b, bi, tc->c_is_ip4);
   TCP_EVT_DBG (TCP_EVT_FIN_SENT, tc);
 
 post_enqueue:
@@ -1217,21 +1207,20 @@ tcp_push_header (tcp_connection_t * tc, vlib_buffer_t * b)
 void
 tcp_send_ack (tcp_connection_t * tc)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  vlib_main_t *vm = vlib_get_main ();
-
+  tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
+  vlib_main_t *vm = wrk->vm;
   vlib_buffer_t *b;
   u32 bi;
 
   /* Get buffer */
-  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
     return;
   b = vlib_get_buffer (vm, bi);
   tcp_init_buffer (vm, b);
 
   /* Fill in the ACK */
   tcp_make_ack (tc, b);
-  tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+  tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
 }
 
 /**
@@ -1257,11 +1246,12 @@ tcp_timer_delack_handler (u32 index)
  *         retransmit
  */
 static u32
-tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
+tcp_prepare_retransmit_segment (tcp_worker_ctx_t * wrk,
+                               tcp_connection_t * tc, u32 offset,
                                u32 max_deq_bytes, vlib_buffer_t ** b)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  vlib_main_t *vm = vlib_get_main ();
+  u32 bytes_per_buffer = vnet_get_tcp_main ()->bytes_per_buffer;
+  vlib_main_t *vm = wrk->vm;
   int n_bytes = 0;
   u32 start, bi, available_bytes, seg_size;
   u8 *data;
@@ -1305,9 +1295,9 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
    */
 
   /* Easy case, buffer size greater than mss */
-  if (PREDICT_TRUE (seg_size <= tm->bytes_per_buffer))
+  if (PREDICT_TRUE (seg_size <= bytes_per_buffer))
     {
-      if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+      if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
        return 0;
       *b = vlib_get_buffer (vm, bi);
       data = tcp_init_buffer (vm, *b);
@@ -1323,19 +1313,16 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
   else
     {
       u32 chain_bi = ~0, n_bufs_per_seg;
-      u32 thread_index = vlib_get_thread_index ();
       u16 n_peeked, len_to_deq, available_bufs;
       vlib_buffer_t *chain_b, *prev_b;
       int i;
 
       /* Make sure we have enough buffers */
-      n_bufs_per_seg = ceil ((double) seg_size / tm->bytes_per_buffer);
-      available_bufs = vec_len (tm->wrk_ctx[thread_index].tx_buffers);
+      n_bufs_per_seg = ceil ((double) seg_size / bytes_per_buffer);
+      available_bufs = vec_len (wrk->tx_buffers);
       if (n_bufs_per_seg > available_bufs)
        {
-         tcp_alloc_tx_buffers (tm, thread_index, &available_bufs,
-                               VLIB_FRAME_SIZE);
-
+         tcp_alloc_tx_buffers (wrk, &available_bufs, VLIB_FRAME_SIZE);
          if (n_bufs_per_seg > available_bufs)
            {
              *b = 0;
@@ -1343,13 +1330,12 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
            }
        }
 
-      tcp_get_free_buffer_index (tm, &bi);
+      tcp_get_free_buffer_index (wrk, &bi);
       ASSERT (bi != (u32) ~ 0);
       *b = vlib_get_buffer (vm, bi);
       data = tcp_init_buffer (vm, *b);
       n_bytes = stream_session_peek_bytes (&tc->connection, data, offset,
-                                          tm->bytes_per_buffer -
-                                          MAX_HDRS_LEN);
+                                          bytes_per_buffer - MAX_HDRS_LEN);
       b[0]->current_length = n_bytes;
       b[0]->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
       b[0]->total_length_not_including_first_buffer = 0;
@@ -1359,8 +1345,8 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
       for (i = 1; i < n_bufs_per_seg; i++)
        {
          prev_b = chain_b;
-         len_to_deq = clib_min (max_deq_bytes, tm->bytes_per_buffer);
-         tcp_get_free_buffer_index (tm, &chain_bi);
+         len_to_deq = clib_min (max_deq_bytes, bytes_per_buffer);
+         tcp_get_free_buffer_index (wrk, &chain_bi);
          ASSERT (chain_bi != (u32) ~ 0);
          chain_b = vlib_get_buffer (vm, chain_bi);
          chain_b->current_data = 0;
@@ -1386,8 +1372,7 @@ tcp_prepare_retransmit_segment (tcp_connection_t * tc, u32 offset,
     }
 
   ASSERT (n_bytes > 0);
-  ASSERT (((*b)->current_data + (*b)->current_length) <=
-         tm->bytes_per_buffer);
+  ASSERT (((*b)->current_data + (*b)->current_length) <= bytes_per_buffer);
 
   if (tcp_in_fastrecovery (tc))
     tc->snd_rxt_bytes += n_bytes;
@@ -1428,9 +1413,9 @@ tcp_rxt_timeout_cc (tcp_connection_t * tc)
 static inline void
 tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  vlib_main_t *vm = vlib_get_main ();
   u32 thread_index = vlib_get_thread_index ();
+  tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
+  vlib_main_t *vm = wrk->vm;
   tcp_connection_t *tc;
   vlib_buffer_t *b = 0;
   u32 bi, n_bytes;
@@ -1503,7 +1488,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
 
       /* Send one segment. Note that n_bytes may be zero due to buffer
        * shortfall */
-      n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
+      n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, tc->snd_mss, &b);
 
       if (n_bytes == 0)
        {
@@ -1515,9 +1500,9 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
 
       /* For first retransmit, record timestamp (Eifel detection RFC3522) */
       if (tc->rto_boff == 1)
-       tc->snd_rxt_ts = tcp_time_now ();
+       tc->snd_rxt_ts = tcp_time_now_w_thread (tc->c_thread_index);
 
-      tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+      tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
       tcp_retransmit_timer_force_update (tc);
     }
   /* Retransmit for SYN */
@@ -1547,7 +1532,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
       tcp_timer_update (tc, TCP_TIMER_RETRANSMIT_SYN,
                        tc->rto * TCP_TO_TIMER_TICK);
 
-      if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+      if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
        return;
 
       b = vlib_get_buffer (vm, bi);
@@ -1558,8 +1543,8 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
       TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 0);
 
       /* This goes straight to ipx_lookup. Retransmit timer set already */
-      tcp_push_ip_hdr (tm, tc, b);
-      tcp_enqueue_to_ip_lookup (vm, b, bi, tc->c_is_ip4, tc->c_fib_index);
+      tcp_push_ip_hdr (wrk, tc, b);
+      tcp_enqueue_to_ip_lookup (wrk, b, bi, tc->c_is_ip4, tc->c_fib_index);
     }
   /* Retransmit SYN-ACK */
   else if (tc->state == TCP_STATE_SYN_RCVD)
@@ -1571,7 +1556,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
        tc->rto = clib_min (tc->rto << 1, TCP_RTO_MAX);
       tc->rtt_ts = 0;
 
-      if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+      if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
        {
          tcp_retransmit_timer_force_update (tc);
          return;
@@ -1583,7 +1568,7 @@ tcp_timer_retransmit_handler_i (u32 index, u8 is_syn)
       TCP_EVT_DBG (TCP_EVT_SYN_RXT, tc, 1);
 
       /* Retransmit timer already updated, just enqueue to output */
-      tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+      tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
     }
   else
     {
@@ -1611,12 +1596,13 @@ tcp_timer_retransmit_syn_handler (u32 index)
 void
 tcp_timer_persist_handler (u32 index)
 {
-  tcp_main_t *tm = vnet_get_tcp_main ();
-  vlib_main_t *vm = vlib_get_main ();
   u32 thread_index = vlib_get_thread_index ();
+  tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
+  u32 bi, max_snd_bytes, available_bytes, offset;
+  tcp_main_t *tm = vnet_get_tcp_main ();
+  vlib_main_t *vm = wrk->vm;
   tcp_connection_t *tc;
   vlib_buffer_t *b;
-  u32 bi, max_snd_bytes, available_bytes, offset;
   int n_bytes = 0;
   u8 *data;
 
@@ -1657,7 +1643,7 @@ tcp_timer_persist_handler (u32 index)
   /*
    * Try to force the first unsent segment (or buffer)
    */
-  if (PREDICT_FALSE (tcp_get_free_buffer_index (tm, &bi)))
+  if (PREDICT_FALSE (tcp_get_free_buffer_index (wrk, &bi)))
     {
       tcp_persist_timer_set (tc);
       return;
@@ -1678,7 +1664,7 @@ tcp_timer_persist_handler (u32 index)
   tcp_push_hdr_i (tc, b, tc->state, /* compute opts */ 0, /* burst */ 0);
   tc->snd_una_max = tc->snd_nxt;
   tcp_validate_txf_size (tc, tc->snd_una_max - tc->snd_una);
-  tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+  tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
 
   /* Just sent new data, enable retransmit */
   tcp_retransmit_timer_update (tc);
@@ -1688,23 +1674,23 @@ tcp_timer_persist_handler (u32 index)
  * Retransmit first unacked segment
  */
 int
-tcp_retransmit_first_unacked (tcp_connection_t * tc)
+tcp_retransmit_first_unacked (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
 {
-  vlib_main_t *vm = vlib_get_main ();
-  vlib_buffer_t *b;
   u32 bi, old_snd_nxt, n_bytes;
+  vlib_main_t *vm = wrk->vm;
+  vlib_buffer_t *b;
 
   old_snd_nxt = tc->snd_nxt;
   tc->snd_nxt = tc->snd_una;
 
   TCP_EVT_DBG (TCP_EVT_CC_EVT, tc, 1);
 
-  n_bytes = tcp_prepare_retransmit_segment (tc, 0, tc->snd_mss, &b);
+  n_bytes = tcp_prepare_retransmit_segment (wrk, tc, 0, tc->snd_mss, &b);
   if (!n_bytes)
     return -1;
 
   bi = vlib_get_buffer_index (vm, b);
-  tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+  tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
   tc->snd_nxt = old_snd_nxt;
 
   return 0;
@@ -1714,9 +1700,10 @@ tcp_retransmit_first_unacked (tcp_connection_t * tc)
  * Do fast retransmit with SACKs
  */
 int
-tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
+tcp_fast_retransmit_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+                         u32 burst_size)
 {
-  vlib_main_t *vm = vlib_get_main ();
+  vlib_main_t *vm = wrk->vm;
   u32 n_written = 0, offset, max_bytes, n_segs = 0;
   vlib_buffer_t *b = 0;
   sack_scoreboard_hole_t *hole;
@@ -1734,7 +1721,7 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
 
   if (snd_space < tc->snd_mss)
     {
-      tcp_program_fastretransmit (tc);
+      tcp_program_fastretransmit (wrk, tc);
       goto done;
     }
 
@@ -1758,7 +1745,7 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
              hole = scoreboard_first_hole (sb);
              if (hole && hole->start == tc->snd_una)
                {
-                 tcp_retransmit_first_unacked (tc);
+                 tcp_retransmit_first_unacked (wrk, tc);
                  tcp_fastrecovery_first_on (tc);
                  n_segs += 1;
                }
@@ -1776,13 +1763,13 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
          offset = tc->snd_congestion - tc->snd_una - max_bytes;
          sb->rescue_rxt = tc->snd_congestion;
          tc->snd_nxt = tc->snd_una + offset;
-         n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes,
-                                                     &b);
+         n_written = tcp_prepare_retransmit_segment (wrk, tc, offset,
+                                                     max_bytes, &b);
          if (!n_written)
            goto done;
 
          bi = vlib_get_buffer_index (vm, b);
-         tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+         tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
          n_segs += 1;
          break;
        }
@@ -1793,7 +1780,8 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
        break;
       offset = sb->high_rxt - tc->snd_una;
       tc->snd_nxt = sb->high_rxt;
-      n_written = tcp_prepare_retransmit_segment (tc, offset, max_bytes, &b);
+      n_written = tcp_prepare_retransmit_segment (wrk, tc, offset, max_bytes,
+                                                 &b);
 
       /* Nothing left to retransmit */
       if (n_written == 0)
@@ -1801,14 +1789,14 @@ tcp_fast_retransmit_sack (tcp_connection_t * tc, u32 burst_size)
 
       bi = vlib_get_buffer_index (vm, b);
       sb->high_rxt += n_written;
-      tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+      tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
       ASSERT (n_written <= snd_space);
       snd_space -= n_written;
       n_segs += 1;
     }
 
   if (hole)
-    tcp_program_fastretransmit (tc);
+    tcp_program_fastretransmit (wrk, tc);
 
 done:
   /* If window allows, send 1 SMSS of new data */
@@ -1820,10 +1808,11 @@ done:
  * Fast retransmit without SACK info
  */
 int
-tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size)
+tcp_fast_retransmit_no_sack (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+                            u32 burst_size)
 {
-  vlib_main_t *vm = vlib_get_main ();
   u32 n_written = 0, offset = 0, bi, old_snd_nxt;
+  vlib_main_t *vm = wrk->vm;
   int snd_space, n_segs = 0;
   vlib_buffer_t *b;
 
@@ -1838,21 +1827,22 @@ tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size)
   while (snd_space > 0 && n_segs < burst_size)
     {
       offset += n_written;
-      n_written = tcp_prepare_retransmit_segment (tc, offset, snd_space, &b);
+      n_written = tcp_prepare_retransmit_segment (wrk, tc, offset, snd_space,
+                                                 &b);
 
       /* Nothing left to retransmit */
       if (n_written == 0)
        break;
 
       bi = vlib_get_buffer_index (vm, b);
-      tcp_enqueue_to_output (vm, b, bi, tc->c_is_ip4);
+      tcp_enqueue_to_output (wrk, b, bi, tc->c_is_ip4);
       snd_space -= n_written;
       n_segs += 1;
     }
 
   /* More data to resend */
   if (seq_lt (tc->snd_nxt, tc->snd_congestion))
-    tcp_program_fastretransmit (tc);
+    tcp_program_fastretransmit (wrk, tc);
 
   /* Restore snd_nxt. If window allows, send 1 SMSS of new data */
   tc->snd_nxt = old_snd_nxt;
@@ -1864,12 +1854,13 @@ tcp_fast_retransmit_no_sack (tcp_connection_t * tc, u32 burst_size)
  * Do fast retransmit
  */
 int
-tcp_fast_retransmit (tcp_connection_t * tc, u32 burst_size)
+tcp_fast_retransmit (tcp_worker_ctx_t * wrk, tcp_connection_t * tc,
+                    u32 burst_size)
 {
   if (tcp_opts_sack_permitted (&tc->rcv_opts))
-    return tcp_fast_retransmit_sack (tc, burst_size);
+    return tcp_fast_retransmit_sack (wrk, tc, burst_size);
   else
-    return tcp_fast_retransmit_no_sack (tc, burst_size);
+    return tcp_fast_retransmit_no_sack (wrk, tc, burst_size);
 }
 
 static u32
@@ -2016,7 +2007,7 @@ tcp46_output_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 
   from = vlib_frame_vector_args (frame);
   n_left_from = frame->n_vectors;
-  tcp_set_time_now (thread_index);
+  tcp_set_time_now (tcp_get_worker (thread_index));
 
   if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
     tcp46_output_trace_frame (vm, node, from, n_left_from);