X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Ftests%2Fvnet%2Fsession%2Fudp_echo.c;h=9ab77517898dbd93b8dd5cde5fdf371325580c44;hb=b7b929931a07fbb27b43d5cd105f366c3e29807e;hp=d796b6b8de0aeb73feb5bc4733dd108ec2a7a7ef;hpb=3c2fed5145d9e40a9ecd178c2866c813eddc6203;p=vpp.git

diff --git a/src/tests/vnet/session/udp_echo.c b/src/tests/vnet/session/udp_echo.c
index d796b6b8de0..9ab77517898 100644
--- a/src/tests/vnet/session/udp_echo.c
+++ b/src/tests/vnet/session/udp_echo.c
@@ -50,10 +50,12 @@
 typedef enum
 {
   STATE_START,
+  STATE_ATTACHED,
   STATE_BOUND,
   STATE_READY,
   STATE_FAILED,
   STATE_DISCONNECTING,
+  STATE_DETACHED
 } connection_state_t;
 
 typedef struct
@@ -88,6 +90,7 @@ typedef struct
 
   /* Our event queue */
   svm_msg_q_t *our_event_queue;
+  svm_msg_q_t *ct_event_queue;
 
   /* $$$ single thread only for the moment */
   svm_msg_q_t *vpp_event_queue;
@@ -126,15 +129,11 @@ typedef struct
   uword *segments_table;
   u8 do_echo;
   u8 have_return;
+  u64 total_to_send;
   u64 bytes_to_send;
+  u64 bytes_sent;
 } udp_echo_main_t;
 
-#if CLIB_DEBUG > 0
-#define NITER 10000
-#else
-#define NITER 4000000
-#endif
-
 udp_echo_main_t udp_echo_main;
 
 static void
@@ -298,12 +297,12 @@ unformat_uri (unformat_input_t * input, va_list * args)
   return 0;
 }
 
-void
+static void
 application_send_attach (udp_echo_main_t * utm)
 {
   vl_api_application_attach_t *bmp;
   bmp = vl_msg_api_alloc (sizeof (*bmp));
-  memset (bmp, 0, sizeof (*bmp));
+  clib_memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
   bmp->client_index = utm->my_client_index;
@@ -311,6 +310,7 @@ application_send_attach (udp_echo_main_t * utm)
   bmp->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_ADD_SEGMENT;
   bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
   bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
+  bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
   bmp->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = 2;
   bmp->options[APP_OPTIONS_RX_FIFO_SIZE] = utm->fifo_size;
   bmp->options[APP_OPTIONS_TX_FIFO_SIZE] = utm->fifo_size;
@@ -325,7 +325,7 @@ application_detach (udp_echo_main_t * utm)
 {
   vl_api_application_detach_t *bmp;
   bmp = vl_msg_api_alloc (sizeof (*bmp));
-  memset (bmp, 0, sizeof (*bmp));
+  clib_memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
   bmp->client_index = utm->my_client_index;
@@ -368,8 +368,9 @@ vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
       return;
     }
 
-  utm->our_event_queue =
-    uword_to_pointer (mp->app_event_queue_address, svm_msg_q_t *);
+  utm->our_event_queue = uword_to_pointer (mp->app_event_queue_address,
+					   svm_msg_q_t *);
+  utm->state = STATE_ATTACHED;
 }
 
 static void
@@ -378,6 +379,7 @@ vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
 {
   if (mp->retval)
     clib_warning ("detach returned with err: %d", mp->retval);
+  udp_echo_main.state = STATE_DETACHED;
 }
 
 u8 *
@@ -411,6 +413,8 @@ wait_for_state_change (udp_echo_main_t * utm, connection_state_t state)
     {
       if (utm->state == state)
 	return 0;
+      if (utm->state == STATE_FAILED)
+	return -1;
     }
   return -1;
 }
@@ -426,7 +430,7 @@ cut_through_thread_fn (void *arg)
   u8 *my_copy_buffer = 0;
   udp_echo_main_t *utm = &udp_echo_main;
   i32 actual_transfer;
-  int rv;
+  int rv, do_dequeue = 0;
   u32 buffer_offset;
 
   while (utm->cut_through_session_index == ~0)
@@ -439,31 +443,42 @@ cut_through_thread_fn (void *arg)
 
   vec_validate (my_copy_buffer, 64 * 1024 - 1);
 
-  while (true)
+  while (1)
     {
-      /* We read from the tx fifo and write to the rx fifo */
       do
 	{
-	  actual_transfer = svm_fifo_dequeue_nowait (rx_fifo,
-						     vec_len (my_copy_buffer),
-						     my_copy_buffer);
+	  /* We read from the tx fifo and write to the rx fifo */
+	  if (utm->have_return || do_dequeue)
+	    actual_transfer = svm_fifo_dequeue_nowait (rx_fifo,
+						       vec_len
+						       (my_copy_buffer),
+						       my_copy_buffer);
+	  else
+	    {
+	      /* We don't do anything with the data, drop it */
+	      actual_transfer = svm_fifo_max_dequeue (rx_fifo);
+	      svm_fifo_dequeue_drop (rx_fifo, actual_transfer);
+	    }
 	}
       while (actual_transfer <= 0);
 
       server_bytes_received += actual_transfer;
 
-      buffer_offset = 0;
-      while (actual_transfer > 0)
+      if (utm->have_return)
 	{
-	  rv = svm_fifo_enqueue_nowait (tx_fifo, actual_transfer,
-					my_copy_buffer + buffer_offset);
-	  if (rv > 0)
+	  buffer_offset = 0;
+	  while (actual_transfer > 0)
 	    {
-	      actual_transfer -= rv;
-	      buffer_offset += rv;
-	      server_bytes_sent += rv;
-	    }
+	      rv = svm_fifo_enqueue_nowait (tx_fifo, actual_transfer,
+					    my_copy_buffer + buffer_offset);
+	      if (rv > 0)
+		{
+		  actual_transfer -= rv;
+		  buffer_offset += rv;
+		  server_bytes_sent += rv;
+		}
 
+	    }
 	}
       if (PREDICT_FALSE (utm->time_to_stop))
 	break;
@@ -473,148 +488,288 @@ cut_through_thread_fn (void *arg)
 }
 
 static void
-udp_client_connect (udp_echo_main_t * utm)
+session_accepted_handler (session_accepted_msg_t * mp)
 {
-  vl_api_connect_uri_t *cmp;
-  cmp = vl_msg_api_alloc (sizeof (*cmp));
-  memset (cmp, 0, sizeof (*cmp));
+  app_session_evt_t _app_evt, *app_evt = &_app_evt;
+  udp_echo_main_t *utm = &udp_echo_main;
+  session_accepted_reply_msg_t *rmp;
+  svm_fifo_t *rx_fifo, *tx_fifo;
+  app_session_t *session;
+  static f64 start_time;
+  u32 session_index;
+  int rv = 0;
 
-  cmp->_vl_msg_id = ntohs (VL_API_CONNECT_URI);
-  cmp->client_index = utm->my_client_index;
-  cmp->context = ntohl (0xfeedface);
-  memcpy (cmp->uri, utm->connect_uri, vec_len (utm->connect_uri));
-  vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & cmp);
+  if (start_time == 0.0)
+    start_time = clib_time_now (&utm->clib_time);
+
+  utm->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
+					   svm_msg_q_t *);
+  rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
+  tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
+
+  pool_get (utm->sessions, session);
+  clib_memset (session, 0, sizeof (*session));
+  session_index = session - utm->sessions;
+  session->session_index = session_index;
+
+  /* Cut-through case */
+  if (mp->server_event_queue_address)
+    {
+      clib_warning ("cut-through session");
+      session->vpp_evt_q = uword_to_pointer (mp->client_event_queue_address,
+					     svm_msg_q_t *);
+      sleep (1);
+      rx_fifo->master_session_index = session_index;
+      tx_fifo->master_session_index = session_index;
+      utm->cut_through_session_index = session_index;
+      session->rx_fifo = rx_fifo;
+      session->tx_fifo = tx_fifo;
+      session->is_dgram = 0;
+
+      rv = pthread_create (&utm->cut_through_thread_handle,
+			   NULL /*attr */ , cut_through_thread_fn, 0);
+      if (rv)
+	{
+	  clib_warning ("pthread_create returned %d", rv);
+	  rv = VNET_API_ERROR_SYSCALL_ERROR_1;
+	}
+    }
+  else
+    {
+      rx_fifo->client_session_index = session_index;
+      tx_fifo->client_session_index = session_index;
+      session->rx_fifo = rx_fifo;
+      session->tx_fifo = tx_fifo;
+      clib_memcpy (&session->transport.rmt_ip, mp->ip,
+		   sizeof (ip46_address_t));
+      session->transport.is_ip4 = mp->is_ip4;
+      session->transport.rmt_port = mp->port;
+    }
+
+  hash_set (utm->session_index_by_vpp_handles, mp->handle, session_index);
+  if (pool_elts (utm->sessions) && (pool_elts (utm->sessions) % 20000) == 0)
+    {
+      f64 now = clib_time_now (&utm->clib_time);
+      fformat (stdout, "%d active sessions in %.2f seconds, %.2f/sec...\n",
+	       pool_elts (utm->sessions), now - start_time,
+	       (f64) pool_elts (utm->sessions) / (now - start_time));
+    }
+
+  app_alloc_ctrl_evt_to_vpp (utm->vpp_event_queue, app_evt,
+			     SESSION_CTRL_EVT_ACCEPTED_REPLY);
+  rmp = (session_accepted_reply_msg_t *) app_evt->evt->data;
+  rmp->handle = mp->handle;
+  rmp->context = mp->context;
+  rmp->retval = rv;
+  app_send_ctrl_evt_to_vpp (utm->vpp_event_queue, app_evt);
+
+  CLIB_MEMORY_BARRIER ();
+  utm->state = STATE_READY;
 }
 
 static void
-client_send_cut_through (udp_echo_main_t * utm, app_session_t * session)
+session_disconnected_handler (session_disconnected_msg_t * mp)
 {
-  int i;
-  u8 *test_data = 0;
-  u64 bytes_received = 0, bytes_sent = 0;
-  i32 bytes_to_read;
-  int rv;
-  f64 before, after, delta, bytes_per_second;
-  svm_fifo_t *rx_fifo, *tx_fifo;
-  int buffer_offset, bytes_to_send = 0;
+  app_session_evt_t _app_evt, *app_evt = &_app_evt;
+  udp_echo_main_t *utm = &udp_echo_main;
+  session_disconnected_reply_msg_t *rmp;
+  app_session_t *session;
+  uword *p;
+  int rv = 0;
 
-  /*
-   * Prepare test data
-   */
-  vec_validate (test_data, 64 * 1024 - 1);
-  for (i = 0; i < vec_len (test_data); i++)
-    test_data[i] = i & 0xff;
+  p = hash_get (utm->session_index_by_vpp_handles, mp->handle);
 
-  rx_fifo = session->rx_fifo;
-  tx_fifo = session->tx_fifo;
+  if (p)
+    {
+      session = pool_elt_at_index (utm->sessions, p[0]);
+      hash_unset (utm->session_index_by_vpp_handles, mp->handle);
+      clib_warning ("disconnecting %u", session->session_index);
+      pool_put (utm->sessions, session);
+    }
+  else
+    {
+      clib_warning ("couldn't find session key %llx", mp->handle);
+      return;
+    }
+
+  app_alloc_ctrl_evt_to_vpp (session->vpp_evt_q, app_evt,
+			     SESSION_CTRL_EVT_DISCONNECTED_REPLY);
+  rmp = (session_disconnected_reply_msg_t *) app_evt->evt->data;
+  rmp->retval = rv;
+  rmp->handle = mp->handle;
+  rmp->context = mp->context;
+  app_send_ctrl_evt_to_vpp (session->vpp_evt_q, app_evt);
+}
 
-  before = clib_time_now (&utm->clib_time);
+static void
+session_connected_handler (session_connected_msg_t * mp)
+{
+  udp_echo_main_t *utm = &udp_echo_main;
+  unformat_input_t _input, *input = &_input;
+  session_endpoint_extended_t _sep, *sep = &_sep;
+  app_session_t *session;
 
-  vec_validate (utm->rx_buf, vec_len (test_data) - 1);
+  ASSERT (utm->i_am_server == 0);
 
-  for (i = 0; i < NITER; i++)
+  if (mp->retval)
     {
-      bytes_to_send = vec_len (test_data);
-      buffer_offset = 0;
-      while (bytes_to_send > 0)
-	{
-	  rv = svm_fifo_enqueue_nowait (tx_fifo, bytes_to_send,
-					test_data + buffer_offset);
+      clib_warning ("failed connect");
+      return;
+    }
 
-	  if (rv > 0)
-	    {
-	      bytes_to_send -= rv;
-	      buffer_offset += rv;
-	      bytes_sent += rv;
-	    }
-	}
+  ASSERT (mp->server_rx_fifo && mp->server_tx_fifo);
 
-      bytes_to_read = svm_fifo_max_dequeue (rx_fifo);
-      bytes_to_read = vec_len (utm->rx_buf) > bytes_to_read ?
-	bytes_to_read : vec_len (utm->rx_buf);
+  pool_get (utm->sessions, session);
+  session->session_index = session - utm->sessions;
+  session->rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
+  session->tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
 
-      buffer_offset = 0;
-      while (bytes_to_read > 0)
-	{
-	  rv = svm_fifo_dequeue_nowait (rx_fifo,
-					bytes_to_read,
-					utm->rx_buf + buffer_offset);
-	  if (rv > 0)
-	    {
-	      bytes_to_read -= rv;
-	      buffer_offset += rv;
-	      bytes_received += rv;
-	    }
-	}
+  /* Cut-through case */
+  if (mp->client_event_queue_address)
+    {
+      clib_warning ("cut-through session");
+      session->vpp_evt_q = uword_to_pointer (mp->server_event_queue_address,
+					     svm_msg_q_t *);
+      utm->ct_event_queue = uword_to_pointer (mp->client_event_queue_address,
+					      svm_msg_q_t *);
+      utm->cut_through_session_index = session->session_index;
+      session->is_dgram = 0;
+      sleep (1);
+      session->rx_fifo->client_session_index = session->session_index;
+      session->tx_fifo->client_session_index = session->session_index;
     }
-  while (bytes_received < bytes_sent)
+  else
     {
-      rv =
-	svm_fifo_dequeue_nowait (rx_fifo, vec_len (utm->rx_buf), utm->rx_buf);
-      if (rv > 0)
+      utm->connected_session = session->session_index;
+      utm->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
+					       svm_msg_q_t *);
+
+      session->rx_fifo->client_session_index = session->session_index;
+      session->tx_fifo->client_session_index = session->session_index;
+      clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
+		   sizeof (ip46_address_t));
+      session->transport.is_ip4 = mp->is_ip4;
+      session->transport.lcl_port = mp->lcl_port;
+
+      unformat_init_vector (input, utm->connect_uri);
+      if (!unformat (input, "%U", unformat_uri, sep))
 	{
-#if CLIB_DEBUG > 0
-	  int j;
-	  for (j = 0; j < rv; j++)
-	    {
-	      if (utm->rx_buf[j] != ((bytes_received + j) & 0xff))
-		{
-		  clib_warning ("error at byte %lld, 0x%x not 0x%x",
-				bytes_received + j,
-				utm->rx_buf[j],
-				((bytes_received + j) & 0xff));
-		}
-	    }
-#endif
-	  bytes_received += (u64) rv;
+	  clib_warning ("can't figure out remote ip and port");
+	  utm->state = STATE_FAILED;
+	  unformat_free (input);
+	  return;
 	}
+      unformat_free (input);
+      clib_memcpy (&session->transport.rmt_ip, &sep->ip,
+		   sizeof (ip46_address_t));
+      session->transport.rmt_port = sep->port;
+      session->is_dgram = !utm->is_connected;
+    }
+  utm->state = STATE_READY;
+}
+
+static void
+session_bound_handler (session_bound_msg_t * mp)
+{
+  udp_echo_main_t *utm = &udp_echo_main;
+  svm_fifo_t *rx_fifo, *tx_fifo;
+  app_session_t *session;
+  u32 session_index;
+
+  if (mp->retval)
+    {
+      clib_warning ("bind failed: %d", mp->retval);
+      utm->state = STATE_FAILED;
+      return;
+    }
+
+  rx_fifo = uword_to_pointer (mp->rx_fifo, svm_fifo_t *);
+  tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
+
+  pool_get (utm->sessions, session);
+  clib_memset (session, 0, sizeof (*session));
+  session_index = session - utm->sessions;
+
+  rx_fifo->client_session_index = session_index;
+  tx_fifo->client_session_index = session_index;
+  session->rx_fifo = rx_fifo;
+  session->tx_fifo = tx_fifo;
+  clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
+	       sizeof (ip46_address_t));
+  session->transport.is_ip4 = mp->lcl_is_ip4;
+  session->transport.lcl_port = mp->lcl_port;
+  session->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
+
+  utm->state = utm->is_connected ? STATE_BOUND : STATE_READY;
+}
+
+static void
+handle_mq_event (session_event_t * e)
+{
+  switch (e->event_type)
+    {
+    case SESSION_CTRL_EVT_BOUND:
+      session_bound_handler ((session_bound_msg_t *) e->data);
+      break;
+    case SESSION_CTRL_EVT_ACCEPTED:
+      session_accepted_handler ((session_accepted_msg_t *) e->data);
+      break;
+    case SESSION_CTRL_EVT_CONNECTED:
+      session_connected_handler ((session_connected_msg_t *) e->data);
+      break;
+    case SESSION_CTRL_EVT_DISCONNECTED:
+      session_disconnected_handler ((session_disconnected_msg_t *) e->data);
+      break;
+    default:
+      clib_warning ("unhandled %u", e->event_type);
     }
+}
+
+static void
+udp_client_send_connect (udp_echo_main_t * utm)
+{
+  vl_api_connect_uri_t *cmp;
+  cmp = vl_msg_api_alloc (sizeof (*cmp));
+  clib_memset (cmp, 0, sizeof (*cmp));
 
-  after = clib_time_now (&utm->clib_time);
-  delta = after - before;
-  bytes_per_second = 0.0;
-
-  if (delta > 0.0)
-    bytes_per_second = (f64) bytes_received / delta;
-
-  fformat (stdout,
-	   "Done: %lld recv bytes in %.2f seconds, %.2f bytes/sec...\n\n",
-	   bytes_received, delta, bytes_per_second);
-  fformat (stdout,
-	   "Done: %lld sent bytes in %.2f seconds, %.2f bytes/sec...\n\n",
-	   bytes_sent, delta, bytes_per_second);
-  fformat (stdout,
-	   "client -> server -> client round trip: %.2f Gbit/sec \n\n",
-	   (bytes_per_second * 8.0) / 1e9);
+  cmp->_vl_msg_id = ntohs (VL_API_CONNECT_URI);
+  cmp->client_index = utm->my_client_index;
+  cmp->context = ntohl (0xfeedface);
+  memcpy (cmp->uri, utm->connect_uri, vec_len (utm->connect_uri));
+  vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & cmp);
 }
 
 static void
 send_test_chunk (udp_echo_main_t * utm, app_session_t * s, u32 bytes)
 {
+  u64 test_buf_len, bytes_this_chunk, test_buf_offset;
+
   u8 *test_data = utm->connect_test_data;
-  int test_buf_offset = 0;
-  u64 bytes_sent = 0;
   u32 bytes_to_snd, enq_space, min_chunk;
-  int rv;
-
-  min_chunk = clib_min (65536, s->tx_fifo->nitems);
-  bytes_to_snd = (bytes == 0) ? vec_len (test_data) : bytes;
-  if (bytes_to_snd > vec_len (test_data))
-    bytes_to_snd = vec_len (test_data);
+  session_evt_type_t et = FIFO_EVENT_APP_TX;
+  int written;
+
+  test_buf_len = vec_len (test_data);
+  test_buf_offset = utm->bytes_sent % test_buf_len;
+  bytes_this_chunk = clib_min (test_buf_len - test_buf_offset,
+			       utm->bytes_to_send);
+  enq_space = svm_fifo_max_enqueue (s->tx_fifo);
+  bytes_this_chunk = clib_min (bytes_this_chunk, enq_space);
+  et += (s->session_index == utm->cut_through_session_index);
+
+  if (s->is_dgram)
+    written = app_send_dgram_raw (s->tx_fifo, &s->transport, s->vpp_evt_q,
+				  test_data + test_buf_offset,
+				  bytes_this_chunk, et, SVM_Q_WAIT);
+  else
+    written = app_send_stream_raw (s->tx_fifo, s->vpp_evt_q,
+				   test_data + test_buf_offset,
+				   bytes_this_chunk, et, SVM_Q_WAIT);
 
-  while (bytes_to_snd > 0 && !utm->time_to_stop)
+  if (written > 0)
     {
-      enq_space = svm_fifo_max_enqueue (s->tx_fifo);
-      if (enq_space < clib_min (bytes_to_snd, min_chunk))
-	continue;
-
-      rv = app_send (s, test_data + test_buf_offset, bytes_to_snd, 0);
-      if (rv > 0)
-	{
-	  bytes_to_snd -= rv;
-	  test_buf_offset += rv;
-	  bytes_sent += rv;
-	}
+      utm->bytes_to_send -= written;
+      utm->bytes_sent += written;
     }
 }
 
@@ -625,30 +780,27 @@ recv_test_chunk (udp_echo_main_t * utm, app_session_t * s)
 }
 
 void
-client_send_data (udp_echo_main_t * utm)
+client_send_data (udp_echo_main_t * utm, u32 session_index)
 {
   f64 start_time, end_time, delta;
   app_session_t *session;
   char *transfer_type;
-  u32 n_iterations;
   u8 *test_data;
   int i;
 
-  vec_validate (utm->connect_test_data, 1024 * 1024 - 1);
+  vec_validate_aligned (utm->connect_test_data, 1024 * 1024 - 1,
+			CLIB_CACHE_LINE_BYTES);
   for (i = 0; i < vec_len (utm->connect_test_data); i++)
     utm->connect_test_data[i] = i & 0xff;
 
   test_data = utm->connect_test_data;
-  session = pool_elt_at_index (utm->sessions, utm->connected_session);
+  session = pool_elt_at_index (utm->sessions, session_index);
   ASSERT (vec_len (test_data) > 0);
 
+  utm->total_to_send = utm->bytes_to_send;
   vec_validate (utm->rx_buf, vec_len (test_data) - 1);
-  n_iterations = utm->bytes_to_send / vec_len (test_data);
-  if (!n_iterations)
-    n_iterations = 1;
-
   start_time = clib_time_now (&utm->clib_time);
-  for (i = 0; i < n_iterations; i++)
+  while (!utm->time_to_stop && utm->bytes_to_send)
     {
       send_test_chunk (utm, session, 0);
       if (utm->have_return)
@@ -668,42 +820,59 @@ client_send_data (udp_echo_main_t * utm)
   delta = end_time - start_time;
   transfer_type = utm->have_return ? "full-duplex" : "half-duplex";
   clib_warning ("%lld bytes (%lld mbytes, %lld gbytes) in %.2f seconds",
-		utm->bytes_to_send, utm->bytes_to_send / (1ULL << 20),
-		utm->bytes_to_send / (1ULL << 30), delta);
-  clib_warning ("%.2f bytes/second %s", ((f64) utm->bytes_to_send) / (delta),
+		utm->total_to_send, utm->total_to_send / (1ULL << 20),
+		utm->total_to_send / (1ULL << 30), delta);
+  clib_warning ("%.2f bytes/second %s", ((f64) utm->total_to_send) / (delta),
 		transfer_type);
   clib_warning ("%.4f gbit/second %s",
-		(((f64) utm->bytes_to_send * 8.0) / delta / 1e9),
+		(((f64) utm->total_to_send * 8.0) / delta / 1e9),
 		transfer_type);
 }
 
+static int
+application_attach (udp_echo_main_t * utm)
+{
+  application_send_attach (utm);
+  if (wait_for_state_change (utm, STATE_ATTACHED))
+    {
+      clib_warning ("timeout waiting for STATE_ATTACHED");
+      return -1;
+    }
+  return 0;
+}
+
 static void
 client_test (udp_echo_main_t * utm)
 {
+  f64 start_time, timeout = 100.0;
   app_session_t *session;
+  svm_msg_q_msg_t msg;
+  session_event_t *e;
 
-  application_send_attach (utm);
-  udp_client_connect (utm);
+  if (application_attach (utm))
+    return;
 
-  if (wait_for_state_change (utm, STATE_READY))
+  udp_client_send_connect (utm);
+
+  start_time = clib_time_now (&utm->clib_time);
+  while (pool_elts (utm->sessions) != 1 && utm->state != STATE_FAILED)
     {
-      clib_warning ("timeout waiting for STATE_READY");
-      return;
+      svm_msg_q_sub (utm->our_event_queue, &msg, SVM_Q_WAIT, 0);
+      e = svm_msg_q_msg_data (utm->our_event_queue, &msg);
+      handle_mq_event (e);
+      svm_msg_q_free_msg (utm->our_event_queue, &msg);
+
+      if (clib_time_now (&utm->clib_time) - start_time >= timeout)
+	break;
     }
 
   if (utm->cut_through_session_index != ~0)
-    {
-      session = pool_elt_at_index (utm->sessions,
-				   utm->cut_through_session_index);
-      client_send_cut_through (utm, session);
-    }
+    client_send_data (utm, utm->cut_through_session_index);
   else
-    {
-      session = pool_elt_at_index (utm->sessions, utm->connected_session);
-      client_send_data (utm);
-    }
+    client_send_data (utm, utm->connected_session);
 
   application_detach (utm);
+  wait_for_state_change (utm, STATE_DETACHED);
 }
 
 static void
@@ -725,7 +894,7 @@ vl_api_bind_uri_reply_t_handler (vl_api_bind_uri_reply_t * mp)
   tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
 
   pool_get (utm->sessions, session);
-  memset (session, 0, sizeof (*session));
+  clib_memset (session, 0, sizeof (*session));
   session_index = session - utm->sessions;
 
   rx_fifo->client_session_index = session_index;
@@ -750,7 +919,7 @@ vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
   u8 *seg_name;
   int rv;
 
-  memset (a, 0, sizeof (*a));
+  clib_memset (a, 0, sizeof (*a));
   a->segment_name = (char *) mp->segment_name;
   a->segment_size = mp->segment_size;
   /* Attach to the segment vpp created */
@@ -792,84 +961,6 @@ vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
   vec_free (seg_name);
 }
 
-/**
- * Acting as server for redirected connect requests
- */
-static void
-vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp)
-{
-  u32 segment_index;
-  udp_echo_main_t *utm = &udp_echo_main;
-  svm_fifo_segment_main_t *sm = &svm_fifo_segment_main;
-  svm_fifo_segment_create_args_t _a, *a = &_a;
-  svm_fifo_segment_private_t *seg;
-  svm_queue_t *client_q;
-  vl_api_connect_session_reply_t *rmp;
-  app_session_t *session = 0;
-  int rv = 0;
-
-  /* Create the segment */
-  a->segment_name = (char *) format (0, "%d:segment%d%c", utm->my_pid,
-				     utm->unique_segment_index++, 0);
-  a->segment_size = utm->configured_segment_size;
-
-  rv = svm_fifo_segment_create (a);
-  if (rv)
-    {
-      clib_warning ("sm_fifo_segment_create ('%s') failed", a->segment_name);
-      rv = VNET_API_ERROR_URI_FIFO_CREATE_FAILED;
-      goto send_reply;
-    }
-
-  vec_add2 (utm->seg, seg, 1);
-
-  segment_index = vec_len (sm->segments) - 1;
-  memcpy (seg, sm->segments + segment_index, sizeof (utm->seg[0]));
-
-  pool_get (utm->sessions, session);
-
-  session->rx_fifo = svm_fifo_segment_alloc_fifo
-    (utm->seg, 128 * 1024, FIFO_SEGMENT_RX_FREELIST);
-  ASSERT (session->rx_fifo);
-
-  session->tx_fifo = svm_fifo_segment_alloc_fifo
-    (utm->seg, 128 * 1024, FIFO_SEGMENT_TX_FREELIST);
-  ASSERT (session->tx_fifo);
-
-  session->rx_fifo->master_session_index = session - utm->sessions;
-  session->tx_fifo->master_session_index = session - utm->sessions;
-  utm->cut_through_session_index = session - utm->sessions;
-
-  rv = pthread_create (&utm->cut_through_thread_handle,
-		       NULL /*attr */ , cut_through_thread_fn, 0);
-  if (rv)
-    {
-      clib_warning ("pthread_create returned %d", rv);
-      rv = VNET_API_ERROR_SYSCALL_ERROR_1;
-    }
-
-send_reply:
-  rmp = vl_msg_api_alloc (sizeof (*rmp));
-  memset (rmp, 0, sizeof (*rmp));
-
-  rmp->_vl_msg_id = ntohs (VL_API_CONNECT_SESSION_REPLY);
-  rmp->context = mp->context;
-  rmp->retval = ntohl (rv);
-  rmp->segment_name_length = vec_len (a->segment_name);
-  if (session)
-    {
-      rmp->server_rx_fifo = pointer_to_uword (session->rx_fifo);
-      rmp->server_tx_fifo = pointer_to_uword (session->tx_fifo);
-    }
-
-  memcpy (rmp->segment_name, a->segment_name, vec_len (a->segment_name));
-
-  vec_free (a->segment_name);
-
-  client_q = uword_to_pointer (mp->client_queue_address, svm_queue_t *);
-  vl_msg_api_send_shmem (client_q, (u8 *) & rmp);
-}
-
 static void
 vl_api_unbind_uri_reply_t_handler (vl_api_unbind_uri_reply_t * mp)
 {
@@ -882,187 +973,20 @@ vl_api_unbind_uri_reply_t_handler (vl_api_unbind_uri_reply_t * mp)
 }
 
 static void
-vl_api_accept_session_t_handler (vl_api_accept_session_t * mp)
+  vl_api_app_cut_through_registration_add_t_handler
+  (vl_api_app_cut_through_registration_add_t * mp)
 {
-  udp_echo_main_t *utm = &udp_echo_main;
-  vl_api_accept_session_reply_t *rmp;
-  svm_fifo_t *rx_fifo, *tx_fifo;
-  app_session_t *session;
-  static f64 start_time;
-  u32 session_index;
-  int rv = 0;
-
-  if (start_time == 0.0)
-    start_time = clib_time_now (&utm->clib_time);
-
-  utm->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
-					   svm_msg_q_t *);
-  rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
-  tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
-
-  pool_get (utm->sessions, session);
-  memset (session, 0, sizeof (*session));
-  session_index = session - utm->sessions;
-
-  /* Cut-through case */
-  if (mp->server_event_queue_address)
-    {
-      clib_warning ("cut-through session");
-      utm->our_event_queue = uword_to_pointer (mp->server_event_queue_address,
-					       svm_msg_q_t *);
-      rx_fifo->master_session_index = session_index;
-      tx_fifo->master_session_index = session_index;
-      utm->cut_through_session_index = session_index;
-      session->rx_fifo = rx_fifo;
-      session->tx_fifo = tx_fifo;
-
-      rv = pthread_create (&utm->cut_through_thread_handle,
-			   NULL /*attr */ , cut_through_thread_fn, 0);
-      if (rv)
-	{
-	  clib_warning ("pthread_create returned %d", rv);
-	  rv = VNET_API_ERROR_SYSCALL_ERROR_1;
-	}
-      utm->do_echo = 1;
-    }
-  else
-    {
-      rx_fifo->client_session_index = session_index;
-      tx_fifo->client_session_index = session_index;
-      session->rx_fifo = rx_fifo;
-      session->tx_fifo = tx_fifo;
-      clib_memcpy (&session->transport.rmt_ip, mp->ip,
-		   sizeof (ip46_address_t));
-      session->transport.is_ip4 = mp->is_ip4;
-      session->transport.rmt_port = mp->port;
-    }
-
-  hash_set (utm->session_index_by_vpp_handles, mp->handle, session_index);
-  if (pool_elts (utm->sessions) && (pool_elts (utm->sessions) % 20000) == 0)
-    {
-      f64 now = clib_time_now (&utm->clib_time);
-      fformat (stdout, "%d active sessions in %.2f seconds, %.2f/sec...\n",
-	       pool_elts (utm->sessions), now - start_time,
-	       (f64) pool_elts (utm->sessions) / (now - start_time));
-    }
 
-  rmp = vl_msg_api_alloc (sizeof (*rmp));
-  memset (rmp, 0, sizeof (*rmp));
-  rmp->_vl_msg_id = ntohs (VL_API_ACCEPT_SESSION_REPLY);
-  rmp->handle = mp->handle;
-  rmp->context = mp->context;
-  rmp->retval = rv;
-  vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & rmp);
-
-  CLIB_MEMORY_BARRIER ();
-  utm->state = STATE_READY;
-}
-
-static void
-vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
-{
-  udp_echo_main_t *utm = &udp_echo_main;
-  app_session_t *session;
-  vl_api_disconnect_session_reply_t *rmp;
-  uword *p;
-  int rv = 0;
-
-  p = hash_get (utm->session_index_by_vpp_handles, mp->handle);
-
-  if (p)
-    {
-      session = pool_elt_at_index (utm->sessions, p[0]);
-      hash_unset (utm->session_index_by_vpp_handles, mp->handle);
-      pool_put (utm->sessions, session);
-    }
-  else
-    {
-      clib_warning ("couldn't find session key %llx", mp->handle);
-      rv = -11;
-    }
-
-  rmp = vl_msg_api_alloc (sizeof (*rmp));
-  memset (rmp, 0, sizeof (*rmp));
-  rmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION_REPLY);
-  rmp->retval = rv;
-  rmp->handle = mp->handle;
-  rmp->context = mp->context;
-  vl_msg_api_send_shmem (utm->vl_input_queue, (u8 *) & rmp);
 }
 
-static void
-vl_api_connect_session_reply_t_handler (vl_api_connect_session_reply_t * mp)
-{
-  udp_echo_main_t *utm = &udp_echo_main;
-  unformat_input_t _input, *input = &_input;
-  session_endpoint_extended_t _sep, *sep = &_sep;
-  app_session_t *session;
-
-  ASSERT (utm->i_am_server == 0);
-
-  if (mp->retval)
-    {
-      clib_warning ("failed connect");
-      return;
-    }
-
-  ASSERT (mp->server_rx_fifo && mp->server_tx_fifo);
-
-  pool_get (utm->sessions, session);
-  session->rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
-  session->tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
-  session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
-					 svm_msg_q_t *);
-  /* Cut-through case */
-  if (mp->client_event_queue_address)
-    {
-      clib_warning ("cut-through session");
-      utm->cut_through_session_index = session - utm->sessions;
-      utm->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
-					       svm_msg_q_t *);
-      utm->our_event_queue = uword_to_pointer (mp->client_event_queue_address,
-					       svm_msg_q_t *);
-      utm->do_echo = 1;
-    }
-  else
-    {
-      utm->connected_session = session - utm->sessions;
-      utm->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
-					       svm_msg_q_t *);
-
-      clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
-		   sizeof (ip46_address_t));
-      session->transport.is_ip4 = mp->is_ip4;
-      session->transport.lcl_port = mp->lcl_port;
-
-      unformat_init_vector (input, utm->connect_uri);
-      if (!unformat (input, "%U", unformat_uri, sep))
-	{
-	  clib_warning ("can't figure out remote ip and port");
-	  utm->state = STATE_FAILED;
-	  unformat_free (input);
-	  return;
-	}
-      unformat_free (input);
-      clib_memcpy (&session->transport.rmt_ip, &sep->ip,
-		   sizeof (ip46_address_t));
-      session->transport.rmt_port = sep->port;
-      session->is_dgram = !utm->is_connected;
-    }
-  utm->state = STATE_READY;
-}
-
-#define foreach_tcp_echo_msg                         	\
-_(BIND_URI_REPLY, bind_uri_reply)               	\
-_(CONNECT_URI, connect_uri)                     	\
-_(CONNECT_SESSION_REPLY, connect_session_reply)       	\
-_(UNBIND_URI_REPLY, unbind_uri_reply)           	\
-_(ACCEPT_SESSION, accept_session)			\
-_(DISCONNECT_SESSION, disconnect_session)		\
-_(MAP_ANOTHER_SEGMENT, map_another_segment)		\
-_(UNMAP_SEGMENT, unmap_segment)				\
-_(APPLICATION_ATTACH_REPLY, application_attach_reply)	\
-_(APPLICATION_DETACH_REPLY, application_detach_reply)	\
+#define foreach_tcp_echo_msg                         			\
+_(BIND_URI_REPLY, bind_uri_reply)               			\
+_(UNBIND_URI_REPLY, unbind_uri_reply)           			\
+_(MAP_ANOTHER_SEGMENT, map_another_segment)				\
+_(UNMAP_SEGMENT, unmap_segment)						\
+_(APPLICATION_ATTACH_REPLY, application_attach_reply)			\
+_(APPLICATION_DETACH_REPLY, application_detach_reply)			\
+_(APP_CUT_THROUGH_REGISTRATION_ADD, app_cut_through_registration_add)	\
 
 void
 tcp_echo_api_hookup (udp_echo_main_t * utm)
@@ -1113,56 +1037,107 @@ init_error_string_table (udp_echo_main_t * utm)
 }
 
 void
-server_handle_fifo_event_rx (udp_echo_main_t * utm, session_fifo_event_t * e)
+server_handle_fifo_event_rx (udp_echo_main_t * utm, u32 session_index)
 {
-  app_session_t *s;
+  svm_fifo_t *rx_fifo, *tx_fifo;
+  int n_read;
+  app_session_t *session;
   int rv;
+  u32 max_dequeue, offset, max_transfer, rx_buf_len;
+  session_evt_type_t et = FIFO_EVENT_APP_TX;
 
-  s = pool_elt_at_index (utm->sessions, e->fifo->client_session_index);
-  app_recv (s, utm->rx_buf, vec_len (utm->rx_buf));
+  session = pool_elt_at_index (utm->sessions, session_index);
+  rx_buf_len = vec_len (utm->rx_buf);
+  rx_fifo = session->rx_fifo;
+  tx_fifo = session->tx_fifo;
+
+  et += (session->session_index == utm->cut_through_session_index);
+
+  max_dequeue = svm_fifo_max_dequeue (rx_fifo);
+  /* Allow enqueuing of a new event */
+  svm_fifo_unset_event (rx_fifo);
+
+  if (PREDICT_FALSE (!max_dequeue))
+    return;
 
-  if (utm->do_echo)
+  /* Read the max_dequeue */
+  do
     {
-      do
+      max_transfer = clib_min (rx_buf_len, max_dequeue);
+      if (session->is_dgram)
+	n_read = app_recv_dgram_raw (rx_fifo, utm->rx_buf, max_transfer,
+				     &session->transport, 0, 0);
+      else
+	n_read = app_recv_stream_raw (rx_fifo, utm->rx_buf, max_transfer, 0,
+				      0);
+
+      if (n_read > 0)
+	max_dequeue -= n_read;
+
+      /* Reflect if a non-drop session */
+      if (utm->have_return && n_read > 0)
 	{
-	  rv = app_send_stream (s, utm->rx_buf, vec_len (utm->rx_buf), 0);
+	  offset = 0;
+	  do
+	    {
+	      if (session->is_dgram)
+		rv = app_send_dgram_raw (tx_fifo, &session->transport,
+					 session->vpp_evt_q,
+					 &utm->rx_buf[offset], n_read, et,
+					 SVM_Q_WAIT);
+	      else
+		rv = app_send_stream_raw (tx_fifo, session->vpp_evt_q,
+					  &utm->rx_buf[offset], n_read, et,
+					  SVM_Q_WAIT);
+	      if (rv > 0)
+		{
+		  n_read -= rv;
+		  offset += rv;
+		}
+	    }
+	  while ((rv <= 0 || n_read > 0) && !utm->time_to_stop);
+
+	  /* If event wasn't set, add one */
+	  if (svm_fifo_set_event (tx_fifo))
+	    app_send_io_evt_to_vpp (session->vpp_evt_q, tx_fifo,
+				    et, SVM_Q_WAIT);
 	}
-      while (rv == SVM_FIFO_FULL);
     }
+  while ((n_read < 0 || max_dequeue > 0) && !utm->time_to_stop);
 }
 
-void
+static void
 server_handle_event_queue (udp_echo_main_t * utm)
 {
-  session_fifo_event_t *e;
+  session_event_t *e;
   svm_msg_q_msg_t msg;
+  svm_msg_q_t *mq = utm->our_event_queue;
+  int i;
 
   while (utm->state != STATE_READY)
     sleep (5);
 
   while (1)
     {
-      if (svm_msg_q_sub (utm->our_event_queue, &msg, SVM_Q_WAIT, 0))
+      if (svm_msg_q_sub (mq, &msg, SVM_Q_WAIT, 0))
 	{
 	  clib_warning ("svm msg q returned");
 	  continue;
 	}
-      e = svm_msg_q_msg_data (utm->our_event_queue, &msg);
+      e = svm_msg_q_msg_data (mq, &msg);
       switch (e->event_type)
 	{
 	case FIFO_EVENT_APP_RX:
-	  server_handle_fifo_event_rx (utm, e);
+	  server_handle_fifo_event_rx (utm, e->fifo->client_session_index);
 	  break;
-
-	case FIFO_EVENT_DISCONNECT:
-	  utm->time_to_stop = 1;
+	case SESSION_IO_EVT_CT_TX:
 	  break;
 
 	default:
-	  clib_warning ("unknown event type %d", e->event_type);
+	  handle_mq_event (e);
 	  break;
 	}
-      svm_msg_q_free_msg (utm->our_event_queue, &msg);
+      svm_msg_q_free_msg (mq, &msg);
       if (PREDICT_FALSE (utm->time_to_stop == 1))
 	return;
       if (PREDICT_FALSE (utm->time_to_print_stats == 1))
@@ -1179,7 +1154,7 @@ server_unbind (udp_echo_main_t * utm)
   vl_api_unbind_uri_t *ump;
 
   ump = vl_msg_api_alloc (sizeof (*ump));
-  memset (ump, 0, sizeof (*ump));
+  clib_memset (ump, 0, sizeof (*ump));
 
   ump->_vl_msg_id = ntohs (VL_API_UNBIND_URI);
   ump->client_index = utm->my_client_index;
@@ -1193,7 +1168,7 @@ server_bind (udp_echo_main_t * utm)
   vl_api_bind_uri_t *bmp;
 
   bmp = vl_msg_api_alloc (sizeof (*bmp));
-  memset (bmp, 0, sizeof (*bmp));
+  clib_memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_BIND_URI);
   bmp->client_index = utm->my_client_index;
@@ -1243,19 +1218,14 @@ main (int argc, char **argv)
   app_session_t *session;
   u8 *chroot_prefix;
   char *app_name;
-  mheap_t *h;
-  u8 *heap;
   u32 tmp;
   int i;
 
-  clib_mem_init (0, 256 << 20);
-  heap = clib_mem_get_per_cpu_heap ();
-  h = mheap_header (heap);
-  /* make the main heap thread-safe */
-  h->flags |= MHEAP_FLAG_THREAD_SAFE;
+  clib_mem_init_thread_safe (0, 256 << 20);
+
   svm_fifo_segment_main_init (0x200000000ULL, 20);
 
-  vec_validate (utm->rx_buf, 8192);
+  vec_validate (utm->rx_buf, 128 << 10);
   utm->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
   utm->my_pid = getpid ();
   utm->configured_segment_size = 1 << 20;
@@ -1333,7 +1303,7 @@ main (int argc, char **argv)
   for (i = 0; i < 200000; i++)
     {
       pool_get (utm->sessions, session);
-      memset (session, 0, sizeof (*session));
+      clib_memset (session, 0, sizeof (*session));
     }
   for (i = 0; i < 200000; i++)
     pool_put_index (utm->sessions, i);