dpdk: complete rework of the dpdk-input node

Change-Id: If174d189de40e6f9ffae99997bba93a2519d9fda
Signed-off-by: Damjan Marion <damarion@cisco.com>

1 files changed, 515 insertions, 424 deletions

diff --git a/src/plugins/dpdk/device/node.c b/src/plugins/dpdk/device/node.c
index e1674dcd88d..c2d66ae6f82 100644
--- a/src/plugins/dpdk/device/node.c
+++ b/src/plugins/dpdk/device/node.c
@@ -36,92 +36,46 @@ static char *dpdk_error_strings[] = {
 };
 #endif
 
-always_inline u32
-dpdk_rx_next_from_etype (struct rte_mbuf *mb)
-{
-  ethernet_header_t *h = rte_pktmbuf_mtod (mb, ethernet_header_t *);
-  if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP4)))
-    {
-      if (PREDICT_TRUE ((mb->ol_flags & PKT_RX_IP_CKSUM_GOOD) != 0))
-	return VNET_DEVICE_INPUT_NEXT_IP4_NCS_INPUT;
-      else
-	return VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
-    }
-  else if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_IP6)))
-    return VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
-  else
-    if (PREDICT_TRUE (h->type == clib_host_to_net_u16 (ETHERNET_TYPE_MPLS)))
-    return VNET_DEVICE_INPUT_NEXT_MPLS_INPUT;
-  else
-    return VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
-}
+STATIC_ASSERT (VNET_DEVICE_INPUT_NEXT_IP4_INPUT - 1 ==
+	       VNET_DEVICE_INPUT_NEXT_IP4_NCS_INPUT,
+	       "IP4_INPUT must follow IP4_NCS_INPUT");
 
-always_inline void
-dpdk_rx_error_from_mb (struct rte_mbuf *mb, u32 * next, u8 * error)
+enum
 {
-  if (mb->ol_flags & PKT_RX_IP_CKSUM_BAD)
-    {
-      *error = DPDK_ERROR_IP_CHECKSUM_ERROR;
-      *next = VNET_DEVICE_INPUT_NEXT_DROP;
-    }
-  else
-    *error = DPDK_ERROR_NONE;
-}
-
-static_always_inline void
-dpdk_add_trace (vlib_main_t * vm, vlib_node_runtime_t * node, u32 next,
-		dpdk_device_t * xd, u16 queue_id,
-		vlib_buffer_t * b, struct rte_mbuf *mb)
-{
-  vlib_trace_buffer (vm, node, next, b, /* follow_chain */ 0);
-
-  dpdk_rx_dma_trace_t *t0 = vlib_add_trace (vm, node, b, sizeof t0[0]);
-  t0->queue_index = queue_id;
-  t0->device_index = xd->device_index;
-  t0->buffer_index = vlib_get_buffer_index (vm, b);
+  DPDK_RX_F_CKSUM_GOOD = 7,
+  DPDK_RX_F_CKSUM_BAD = 4,
+  DPDK_RX_F_FDIR = 2,
+};
 
-  clib_memcpy (&t0->mb, mb, sizeof t0->mb);
-  clib_memcpy (&t0->buffer, b, sizeof b[0] - sizeof b->pre_data);
-  clib_memcpy (t0->buffer.pre_data, b->data, sizeof t0->buffer.pre_data);
-  clib_memcpy (&t0->data, mb->buf_addr + mb->data_off, sizeof t0->data);
-}
+/* currently we are just copying bit positions from DPDK, but that
+   might change in future, in case we strart to be interested in something
+   stored in upper bytes. Curently we store only lower byte for perf reasons */
+STATIC_ASSERT (1 << DPDK_RX_F_CKSUM_GOOD == PKT_RX_IP_CKSUM_GOOD, "");
+STATIC_ASSERT (1 << DPDK_RX_F_CKSUM_BAD == PKT_RX_IP_CKSUM_BAD, "");
+STATIC_ASSERT (1 << DPDK_RX_F_FDIR == PKT_RX_FDIR, "");
+STATIC_ASSERT ((PKT_RX_IP_CKSUM_GOOD | PKT_RX_IP_CKSUM_BAD | PKT_RX_FDIR) <
+	       256, "dpdk flags not un lower byte, fix needed");
 
-static inline u32
-dpdk_rx_burst (dpdk_main_t * dm, dpdk_device_t * xd, u16 queue_id)
+always_inline u32
+dpdk_rx_next (vlib_node_runtime_t * node, u16 etype, u8 flags)
 {
-  u32 n_buffers;
-  u32 n_left;
-  u32 n_this_chunk;
-
-  n_left = VLIB_FRAME_SIZE;
-  n_buffers = 0;
-
-  if (PREDICT_TRUE (xd->flags & DPDK_DEVICE_FLAG_PMD))
+  if (PREDICT_TRUE (etype == clib_host_to_net_u16 (ETHERNET_TYPE_IP4)))
     {
-      while (n_left)
-	{
-	  n_this_chunk = rte_eth_rx_burst (xd->device_index, queue_id,
-					   xd->rx_vectors[queue_id] +
-					   n_buffers, n_left);
-	  n_buffers += n_this_chunk;
-	  n_left -= n_this_chunk;
-
-	  /* Empirically, DPDK r1.8 produces vectors w/ 32 or fewer elts */
-	  if (n_this_chunk < 32)
-	    break;
-	}
+      /* keep it branchless */
+      u32 is_good = (flags >> DPDK_RX_F_CKSUM_GOOD) & 1;
+      return VNET_DEVICE_INPUT_NEXT_IP4_INPUT - is_good;
     }
+  else if (PREDICT_TRUE (etype == clib_host_to_net_u16 (ETHERNET_TYPE_IP6)))
+    return VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
+  else if (PREDICT_TRUE (etype == clib_host_to_net_u16 (ETHERNET_TYPE_MPLS)))
+    return VNET_DEVICE_INPUT_NEXT_MPLS_INPUT;
   else
-    {
-      ASSERT (0);
-    }
-
-  return n_buffers;
+    return VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 }
 
-static_always_inline void
+static_always_inline uword
 dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
-			  struct rte_mbuf *mb, vlib_buffer_free_list_t * fl)
+			  struct rte_mbuf * mb, vlib_buffer_free_list_t * fl)
 {
   u8 nb_seg = 1;
   struct rte_mbuf *mb_seg = 0;
@@ -130,7 +84,7 @@ dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
   b_chain = b;
 
   if (mb->nb_segs < 2)
-    return;
+    return 0;
 
   b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
   b->total_length_not_including_first_buffer = 0;
@@ -162,346 +116,44 @@ dpdk_process_subseq_segs (vlib_main_t * vm, vlib_buffer_t * b,
       mb_seg = mb_seg->next;
       nb_seg++;
     }
+  return b->total_length_not_including_first_buffer;
 }
 
 static_always_inline void
-dpdk_prefetch_buffer (struct rte_mbuf *mb)
+dpdk_prefetch_mbuf_x4 (struct rte_mbuf *mb[])
 {
-  vlib_buffer_t *b = vlib_buffer_from_rte_mbuf (mb);
-  CLIB_PREFETCH (mb, CLIB_CACHE_LINE_BYTES, LOAD);
-  CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, STORE);
+  CLIB_PREFETCH (mb[0], CLIB_CACHE_LINE_BYTES, LOAD);
+  CLIB_PREFETCH (mb[1], CLIB_CACHE_LINE_BYTES, LOAD);
+  CLIB_PREFETCH (mb[2], CLIB_CACHE_LINE_BYTES, LOAD);
+  CLIB_PREFETCH (mb[3], CLIB_CACHE_LINE_BYTES, LOAD);
 }
 
 static_always_inline void
-dpdk_prefetch_ethertype (struct rte_mbuf *mb)
+dpdk_prefetch_buffer_x4 (struct rte_mbuf *mb[])
 {
-  CLIB_PREFETCH (mb->buf_addr + mb->data_off +
-		 STRUCT_OFFSET_OF (ethernet_header_t, type),
-		 CLIB_CACHE_LINE_BYTES, LOAD);
+  vlib_buffer_t *b;
+  b = vlib_buffer_from_rte_mbuf (mb[0]);
+  CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
+  b = vlib_buffer_from_rte_mbuf (mb[1]);
+  CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
+  b = vlib_buffer_from_rte_mbuf (mb[2]);
+  CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
+  b = vlib_buffer_from_rte_mbuf (mb[3]);
+  CLIB_PREFETCH (b, CLIB_CACHE_LINE_BYTES, LOAD);
 }
 
-/*
- * This function is used when there are no worker threads.
- * The main thread performs IO and forwards the packets.
- */
-static_always_inline u32
-dpdk_device_input (dpdk_main_t * dm, dpdk_device_t * xd,
-		   vlib_node_runtime_t * node, u32 thread_index, u16 queue_id,
-		   int maybe_multiseg, u32 n_trace)
-{
-  u32 n_buffers;
-  u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
-  u32 n_left_to_next, *to_next;
-  u32 mb_index;
-  vlib_main_t *vm = vlib_get_main ();
-  uword n_rx_bytes = 0;
-  vlib_buffer_free_list_t *fl;
-  vlib_buffer_t *bt = vec_elt_at_index (dm->buffer_templates, thread_index);
-
-  if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
-    return 0;
-
-  n_buffers = dpdk_rx_burst (dm, xd, queue_id);
-
-  if (n_buffers == 0)
-    {
-      return 0;
-    }
-
-  fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
-
-  /* Update buffer template */
-  vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->vlib_sw_if_index;
-  bt->error = node->errors[DPDK_ERROR_NONE];
-  /* as DPDK is allocating empty buffers from mempool provided before interface
-     start for each queue, it is safe to store this in the template */
-  bt->buffer_pool_index = xd->buffer_pool_for_queue[queue_id];
-
-  mb_index = 0;
-
-  while (n_buffers > 0)
-    {
-      vlib_buffer_t *b0, *b1, *b2, *b3;
-      u32 bi0, next0;
-      u32 bi1, next1;
-      u32 bi2, next2;
-      u32 bi3, next3;
-      u8 error0, error1, error2, error3;
-      i16 offset0, offset1, offset2, offset3;
-      u64 or_ol_flags;
-
-      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
-
-      while (n_buffers >= 12 && n_left_to_next >= 4)
-	{
-	  struct rte_mbuf *mb0, *mb1, *mb2, *mb3;
-
-	  /* prefetches are interleaved with the rest of the code to reduce
-	     pressure on L1 cache */
-	  dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 8]);
-	  dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 4]);
-
-	  mb0 = xd->rx_vectors[queue_id][mb_index];
-	  mb1 = xd->rx_vectors[queue_id][mb_index + 1];
-	  mb2 = xd->rx_vectors[queue_id][mb_index + 2];
-	  mb3 = xd->rx_vectors[queue_id][mb_index + 3];
-
-	  ASSERT (mb0);
-	  ASSERT (mb1);
-	  ASSERT (mb2);
-	  ASSERT (mb3);
-
-	  if (maybe_multiseg)
-	    {
-	      if (PREDICT_FALSE (mb0->nb_segs > 1))
-		dpdk_prefetch_buffer (mb0->next);
-	      if (PREDICT_FALSE (mb1->nb_segs > 1))
-		dpdk_prefetch_buffer (mb1->next);
-	      if (PREDICT_FALSE (mb2->nb_segs > 1))
-		dpdk_prefetch_buffer (mb2->next);
-	      if (PREDICT_FALSE (mb3->nb_segs > 1))
-		dpdk_prefetch_buffer (mb3->next);
-	    }
-
-	  b0 = vlib_buffer_from_rte_mbuf (mb0);
-	  b1 = vlib_buffer_from_rte_mbuf (mb1);
-	  b2 = vlib_buffer_from_rte_mbuf (mb2);
-	  b3 = vlib_buffer_from_rte_mbuf (mb3);
-
-	  dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 9]);
-	  dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 5]);
-
-	  clib_memcpy64_x4 (b0, b1, b2, b3, bt);
-
-	  dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 10]);
-	  dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 6]);
-
-	  bi0 = vlib_get_buffer_index (vm, b0);
-	  bi1 = vlib_get_buffer_index (vm, b1);
-	  bi2 = vlib_get_buffer_index (vm, b2);
-	  bi3 = vlib_get_buffer_index (vm, b3);
-
-	  to_next[0] = bi0;
-	  to_next[1] = bi1;
-	  to_next[2] = bi2;
-	  to_next[3] = bi3;
-	  to_next += 4;
-	  n_left_to_next -= 4;
-
-	  if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
-	    {
-	      next0 = next1 = next2 = next3 = xd->per_interface_next_index;
-	    }
-	  else
-	    {
-	      next0 = dpdk_rx_next_from_etype (mb0);
-	      next1 = dpdk_rx_next_from_etype (mb1);
-	      next2 = dpdk_rx_next_from_etype (mb2);
-	      next3 = dpdk_rx_next_from_etype (mb3);
-
-	      or_ol_flags = (mb0->ol_flags | mb1->ol_flags |
-			     mb2->ol_flags | mb3->ol_flags);
-	      if (PREDICT_FALSE (or_ol_flags & PKT_RX_IP_CKSUM_BAD))
-		{
-		  dpdk_rx_error_from_mb (mb0, &next0, &error0);
-		  dpdk_rx_error_from_mb (mb1, &next1, &error1);
-		  dpdk_rx_error_from_mb (mb2, &next2, &error2);
-		  dpdk_rx_error_from_mb (mb3, &next3, &error3);
-		  b0->error = node->errors[error0];
-		  b1->error = node->errors[error1];
-		  b2->error = node->errors[error2];
-		  b3->error = node->errors[error3];
-		}
-	    }
-
-	  dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 11]);
-	  dpdk_prefetch_ethertype (xd->rx_vectors[queue_id][mb_index + 7]);
-
-	  offset0 = device_input_next_node_advance[next0];
-	  b0->current_data = mb0->data_off + offset0 - RTE_PKTMBUF_HEADROOM;
-	  b0->flags |= device_input_next_node_flags[next0];
-	  vnet_buffer (b0)->l3_hdr_offset = b0->current_data;
-	  vnet_buffer (b0)->l2_hdr_offset =
-	    mb0->data_off - RTE_PKTMBUF_HEADROOM;
-	  b0->current_length = mb0->data_len - offset0;
-	  n_rx_bytes += mb0->pkt_len;
-
-	  offset1 = device_input_next_node_advance[next1];
-	  b1->current_data = mb1->data_off + offset1 - RTE_PKTMBUF_HEADROOM;
-	  b1->flags |= device_input_next_node_flags[next1];
-	  vnet_buffer (b1)->l3_hdr_offset = b1->current_data;
-	  vnet_buffer (b1)->l2_hdr_offset =
-	    mb1->data_off - RTE_PKTMBUF_HEADROOM;
-	  b1->current_length = mb1->data_len - offset1;
-	  n_rx_bytes += mb1->pkt_len;
-
-	  offset2 = device_input_next_node_advance[next2];
-	  b2->current_data = mb2->data_off + offset2 - RTE_PKTMBUF_HEADROOM;
-	  b2->flags |= device_input_next_node_flags[next2];
-	  vnet_buffer (b2)->l3_hdr_offset = b2->current_data;
-	  vnet_buffer (b2)->l2_hdr_offset =
-	    mb2->data_off - RTE_PKTMBUF_HEADROOM;
-	  b2->current_length = mb2->data_len - offset2;
-	  n_rx_bytes += mb2->pkt_len;
-
-	  offset3 = device_input_next_node_advance[next3];
-	  b3->current_data = mb3->data_off + offset3 - RTE_PKTMBUF_HEADROOM;
-	  b3->flags |= device_input_next_node_flags[next3];
-	  vnet_buffer (b3)->l3_hdr_offset = b3->current_data;
-	  vnet_buffer (b3)->l2_hdr_offset =
-	    mb3->data_off - RTE_PKTMBUF_HEADROOM;
-	  b3->current_length = mb3->data_len - offset3;
-	  n_rx_bytes += mb3->pkt_len;
-
-
-	  /* Process subsequent segments of multi-segment packets */
-	  if (maybe_multiseg)
-	    {
-	      dpdk_process_subseq_segs (vm, b0, mb0, fl);
-	      dpdk_process_subseq_segs (vm, b1, mb1, fl);
-	      dpdk_process_subseq_segs (vm, b2, mb2, fl);
-	      dpdk_process_subseq_segs (vm, b3, mb3, fl);
-	    }
-
-	  /*
-	   * Turn this on if you run into
-	   * "bad monkey" contexts, and you want to know exactly
-	   * which nodes they've visited... See main.c...
-	   */
-	  VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
-	  VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b1);
-	  VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b2);
-	  VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b3);
-
-	  /* Do we have any driver RX features configured on the interface? */
-	  vnet_feature_start_device_input_x4 (xd->vlib_sw_if_index,
-					      &next0, &next1, &next2, &next3,
-					      b0, b1, b2, b3);
-
-	  vlib_validate_buffer_enqueue_x4 (vm, node, next_index,
-					   to_next, n_left_to_next,
-					   bi0, bi1, bi2, bi3,
-					   next0, next1, next2, next3);
-	  n_buffers -= 4;
-	  mb_index += 4;
-
-	  if (n_trace)
-	    {
-	      dpdk_add_trace (vm, node, next0, xd, queue_id, b0, mb0);
-	      n_trace--;
-	    }
-	  if (n_trace)
-	    {
-	      dpdk_add_trace (vm, node, next1, xd, queue_id, b1, mb1);
-	      n_trace--;
-	    }
-	  if (n_trace)
-	    {
-	      dpdk_add_trace (vm, node, next2, xd, queue_id, b2, mb2);
-	      n_trace--;
-	    }
-	  if (n_trace)
-	    {
-	      dpdk_add_trace (vm, node, next3, xd, queue_id, b3, mb3);
-	      n_trace--;
-	    }
-	}
-      while (n_buffers > 0 && n_left_to_next > 0)
-	{
-	  struct rte_mbuf *mb0 = xd->rx_vectors[queue_id][mb_index];
-
-	  if (PREDICT_TRUE (n_buffers > 3))
-	    {
-	      dpdk_prefetch_buffer (xd->rx_vectors[queue_id][mb_index + 2]);
-	      dpdk_prefetch_ethertype (xd->rx_vectors[queue_id]
-				       [mb_index + 1]);
-	    }
-
-	  ASSERT (mb0);
-
-	  b0 = vlib_buffer_from_rte_mbuf (mb0);
-
-	  /* Prefetch one next segment if it exists. */
-	  if (PREDICT_FALSE (mb0->nb_segs > 1))
-	    dpdk_prefetch_buffer (mb0->next);
-
-	  clib_memcpy (b0, bt, CLIB_CACHE_LINE_BYTES);
-
-	  bi0 = vlib_get_buffer_index (vm, b0);
-
-	  to_next[0] = bi0;
-	  to_next++;
-	  n_left_to_next--;
-
-	  if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
-	    next0 = xd->per_interface_next_index;
-	  else
-	    {
-	      next0 = dpdk_rx_next_from_etype (mb0);
-
-	      dpdk_rx_error_from_mb (mb0, &next0, &error0);
-	      b0->error = node->errors[error0];
-	    }
-
-	  offset0 = device_input_next_node_advance[next0];
-	  b0->current_data = mb0->data_off + offset0 - RTE_PKTMBUF_HEADROOM;
-	  b0->flags |= device_input_next_node_flags[next0];
-	  vnet_buffer (b0)->l3_hdr_offset = b0->current_data;
-	  vnet_buffer (b0)->l2_hdr_offset =
-	    mb0->data_off - RTE_PKTMBUF_HEADROOM;
-	  b0->current_length = mb0->data_len - offset0;
-	  n_rx_bytes += mb0->pkt_len;
-
-	  /* Process subsequent segments of multi-segment packets */
-	  dpdk_process_subseq_segs (vm, b0, mb0, fl);
-
-	  /*
-	   * Turn this on if you run into
-	   * "bad monkey" contexts, and you want to know exactly
-	   * which nodes they've visited... See main.c...
-	   */
-	  VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
-
-	  /* Do we have any driver RX features configured on the interface? */
-	  vnet_feature_start_device_input_x1 (xd->vlib_sw_if_index, &next0,
-					      b0);
-
-	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
-					   to_next, n_left_to_next,
-					   bi0, next0);
-	  n_buffers--;
-	  mb_index++;
-
-	  if (n_trace)
-	    {
-	      dpdk_add_trace (vm, node, next0, xd, queue_id, b0, mb0);
-	      n_trace--;
-	    }
-	}
-      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
-    }
-
-  vlib_increment_combined_counter
-    (vnet_get_main ()->interface_main.combined_sw_if_counters
-     + VNET_INTERFACE_COUNTER_RX,
-     thread_index, xd->vlib_sw_if_index, mb_index, n_rx_bytes);
-
-  vnet_device_increment_rx_packets (thread_index, mb_index);
-
-  return mb_index;
-}
-
-static_always_inline u32
-dpdk_device_input_mseg (dpdk_main_t * dm, dpdk_device_t * xd,
-			vlib_node_runtime_t * node, u32 thread_index,
-			u16 queue_id, u32 n_trace)
+static_always_inline void
+dpdk_prefetch_buffer_data_x4 (struct rte_mbuf *mb[])
 {
-  if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
-    return dpdk_device_input (dm, xd, node, thread_index, queue_id,
-			      /* maybe_multiseg */ 1, n_trace);
-  else
-    return dpdk_device_input (dm, xd, node, thread_index, queue_id,
-			      /* maybe_multiseg */ 0, n_trace);
+  vlib_buffer_t *b;
+  b = vlib_buffer_from_rte_mbuf (mb[0]);
+  CLIB_PREFETCH (b->data, CLIB_CACHE_LINE_BYTES, LOAD);
+  b = vlib_buffer_from_rte_mbuf (mb[1]);
+  CLIB_PREFETCH (b->data, CLIB_CACHE_LINE_BYTES, LOAD);
+  b = vlib_buffer_from_rte_mbuf (mb[2]);
+  CLIB_PREFETCH (b->data, CLIB_CACHE_LINE_BYTES, LOAD);
+  b = vlib_buffer_from_rte_mbuf (mb[3]);
+  CLIB_PREFETCH (b->data, CLIB_CACHE_LINE_BYTES, LOAD);
 }
 
 static inline void
@@ -527,8 +179,8 @@ poll_rate_limit (dpdk_main_t * dm)
 
     This is the main DPDK input node: across each assigned interface,
     call rte_eth_rx_burst(...) or similar to obtain a vector of
-    packets to process. Handle early packet discard. Derive @c
-    vlib_buffer_t metadata from <code>struct rte_mbuf</code> metadata,
+    packets to process. Derive @c vlib_buffer_t metadata from
+    <code>struct rte_mbuf</code> metadata,
     Depending on the resulting metadata: adjust <code>b->current_data,
     b->current_length </code> and dispatch directly to
     ip4-input-no-checksum, or ip6-input. Trace the packet if required.
@@ -542,8 +194,6 @@ poll_rate_limit (dpdk_main_t * dm)
     @em Uses:
     - <code>struct rte_mbuf mb->ol_flags</code>
         - PKT_RX_IP_CKSUM_BAD
-    - <code> RTE_ETH_IS_xxx_HDR(mb->packet_type) </code>
-        - packet classification result
 
     @em Sets:
     - <code>b->error</code> if the packet is to be dropped immediately
@@ -563,7 +213,458 @@ poll_rate_limit (dpdk_main_t * dm)
       <code>xd->per_interface_next_index</code>
 */
 
-uword
+static_always_inline void
+dpdk_mbuf_to_buffer_index_x4 (vlib_main_t * vm, struct rte_mbuf **mb,
+			      u32 * buffers)
+{
+#ifdef CLIB_HAVE_VEC256
+  vlib_buffer_main_t *bm = &buffer_main;
+  u64x4 v = *(u64x4 *) mb;
+  u32x8 v2, mask = { 0, 2, 4, 6, 1, 3, 5, 7 };
+
+  /* load 4 pointers into 256-bit register */
+  v = u64x4_load_unaligned (mb);
+
+  /* vlib_buffer_t is straight after rte_mbuf so advance all 4
+     pointers for size of rte_mbuf */
+  v += u64x4_splat (sizeof (struct rte_mbuf));
+
+  /* calculate 4 buffer indices in paralled */
+  v = (v - u64x4_splat (bm->buffer_mem_start)) >> CLIB_LOG2_CACHE_LINE_BYTES;
+
+  /* permute 256-bit register so lower u32s of each buffer index are
+   * placed into lower 128-bits */
+  v2 = u32x8_permute ((u32x8) v, mask);
+
+  /* extract lower 128-bits and save them to the array of buffer indices */
+  u32x4_store_unaligned (u32x8_extract_lo (v2), buffers);
+#else
+  /* equivalent non-nector implementation */
+  buffers[0] = vlib_get_buffer_index (vm, vlib_buffer_from_rte_mbuf (mb[0]));
+  buffers[1] = vlib_get_buffer_index (vm, vlib_buffer_from_rte_mbuf (mb[1]));
+  buffers[2] = vlib_get_buffer_index (vm, vlib_buffer_from_rte_mbuf (mb[2]));
+  buffers[3] = vlib_get_buffer_index (vm, vlib_buffer_from_rte_mbuf (mb[3]));
+#endif
+}
+
+static_always_inline u8
+dpdk_ol_flags_extract (struct rte_mbuf **mb, u8 * flags, int count)
+{
+  u8 rv = 0;
+  int i;
+  for (i = 0; i < count; i++)
+    {
+      /* all flags we are interested in are in lower 8 bits but
+         that might change */
+      flags[i] = (u8) mb[i]->ol_flags;
+      rv |= flags[i];
+    }
+  return rv;
+}
+
+static_always_inline uword
+dpdk_process_rx_burst (vlib_main_t * vm, dpdk_per_thread_data_t * ptd,
+		       uword n_rx_packets, int maybe_multiseg, u8 * or_flagsp)
+{
+  u32 n_left = n_rx_packets;
+  vlib_buffer_t *b[4];
+  vlib_buffer_free_list_t *fl;
+  struct rte_mbuf **mb = ptd->mbufs;
+  uword n_bytes = 0;
+  i16 off;
+  u8 *flags, or_flags = 0;
+  u16 *next;
+
+  fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
+
+  mb = ptd->mbufs;
+  flags = ptd->flags;
+  next = ptd->next;
+
+  while (n_left >= 8)
+    {
+      CLIB_PREFETCH (mb + 8, CLIB_CACHE_LINE_BYTES, LOAD);
+
+      dpdk_prefetch_buffer_x4 (mb + 4);
+
+      b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
+      b[1] = vlib_buffer_from_rte_mbuf (mb[1]);
+      b[2] = vlib_buffer_from_rte_mbuf (mb[2]);
+      b[3] = vlib_buffer_from_rte_mbuf (mb[3]);
+
+      clib_memcpy64_x4 (b[0], b[1], b[2], b[3], &ptd->buffer_template);
+
+      dpdk_prefetch_mbuf_x4 (mb + 4);
+
+      or_flags |= dpdk_ol_flags_extract (mb, flags, 4);
+      flags += 4;
+
+      /* we temporary store relative offset of ethertype into next[x]
+         so we can prefetch and get it faster later */
+
+      off = mb[0]->data_off;
+      next[0] = off + STRUCT_OFFSET_OF (ethernet_header_t, type);
+      off -= RTE_PKTMBUF_HEADROOM;
+      vnet_buffer (b[0])->l2_hdr_offset = off;
+      b[0]->current_data = off;
+
+      off = mb[0]->data_off;
+      next[1] = off + STRUCT_OFFSET_OF (ethernet_header_t, type);
+      off -= RTE_PKTMBUF_HEADROOM;
+      vnet_buffer (b[1])->l2_hdr_offset = off;
+      b[1]->current_data = off;
+
+      off = mb[0]->data_off;
+      next[2] = off + STRUCT_OFFSET_OF (ethernet_header_t, type);
+      off -= RTE_PKTMBUF_HEADROOM;
+      vnet_buffer (b[2])->l2_hdr_offset = off;
+      b[2]->current_data = off;
+
+      off = mb[0]->data_off;
+      next[3] = off + STRUCT_OFFSET_OF (ethernet_header_t, type);
+      off -= RTE_PKTMBUF_HEADROOM;
+      vnet_buffer (b[3])->l2_hdr_offset = off;
+      b[3]->current_data = off;
+
+      b[0]->current_length = mb[0]->data_len;
+      b[1]->current_length = mb[1]->data_len;
+      b[2]->current_length = mb[2]->data_len;
+      b[3]->current_length = mb[3]->data_len;
+
+      n_bytes += mb[0]->data_len;
+      n_bytes += mb[1]->data_len;
+      n_bytes += mb[2]->data_len;
+      n_bytes += mb[3]->data_len;
+
+      if (maybe_multiseg)
+	{
+	  n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], fl);
+	  n_bytes += dpdk_process_subseq_segs (vm, b[1], mb[1], fl);
+	  n_bytes += dpdk_process_subseq_segs (vm, b[2], mb[2], fl);
+	  n_bytes += dpdk_process_subseq_segs (vm, b[3], mb[3], fl);
+	}
+
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[1]);
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[2]);
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[3]);
+
+      /* next */
+      mb += 4;
+      n_left -= 4;
+      next += 4;
+    }
+
+  while (n_left)
+    {
+      b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
+      clib_memcpy (b[0], &ptd->buffer_template, 64);
+      or_flags |= dpdk_ol_flags_extract (mb, flags, 1);
+      flags += 1;
+
+      off = mb[0]->data_off;
+      next[0] = off + STRUCT_OFFSET_OF (ethernet_header_t, type);
+      off -= RTE_PKTMBUF_HEADROOM;
+      vnet_buffer (b[0])->l2_hdr_offset = off;
+      b[0]->current_data = off;
+      b[0]->current_length = mb[0]->data_len;
+      n_bytes += mb[0]->data_len;
+      if (maybe_multiseg)
+	n_bytes += dpdk_process_subseq_segs (vm, b[0], mb[0], fl);
+      VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b[0]);
+
+      /* next */
+      mb += 1;
+      n_left -= 1;
+      next += 1;
+    }
+
+  *or_flagsp = or_flags;
+  return n_bytes;
+}
+
+static_always_inline void
+dpdk_set_next_from_etype (vlib_main_t * vm, vlib_node_runtime_t * node,
+			  dpdk_per_thread_data_t * ptd, uword n_rx_packets)
+{
+  vlib_buffer_t *b[4];
+  i16 adv[4];
+  u16 etype[4];
+  struct rte_mbuf **mb = ptd->mbufs;
+  u8 *flags = ptd->flags;
+  u16 *next = ptd->next;
+  u32 n_left = n_rx_packets;
+
+  while (n_left >= 12)
+    {
+      dpdk_prefetch_buffer_data_x4 (mb + 8);
+      dpdk_prefetch_buffer_x4 (mb + 8);
+
+      b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
+      b[1] = vlib_buffer_from_rte_mbuf (mb[1]);
+      b[2] = vlib_buffer_from_rte_mbuf (mb[2]);
+      b[3] = vlib_buffer_from_rte_mbuf (mb[3]);
+      etype[0] = *(u16 *) ((u8 *) mb[0] + next[0] + sizeof (vlib_buffer_t));
+      etype[1] = *(u16 *) ((u8 *) mb[1] + next[1] + sizeof (vlib_buffer_t));
+      etype[2] = *(u16 *) ((u8 *) mb[2] + next[2] + sizeof (vlib_buffer_t));
+      etype[3] = *(u16 *) ((u8 *) mb[3] + next[3] + sizeof (vlib_buffer_t));
+      next[0] = dpdk_rx_next (node, etype[0], flags[0]);
+      next[1] = dpdk_rx_next (node, etype[1], flags[1]);
+      next[2] = dpdk_rx_next (node, etype[2], flags[2]);
+      next[3] = dpdk_rx_next (node, etype[3], flags[3]);
+      adv[0] = device_input_next_node_advance[next[0]];
+      adv[1] = device_input_next_node_advance[next[1]];
+      adv[2] = device_input_next_node_advance[next[2]];
+      adv[3] = device_input_next_node_advance[next[3]];
+      b[0]->current_data += adv[0];
+      b[1]->current_data += adv[1];
+      b[2]->current_data += adv[2];
+      b[3]->current_data += adv[3];
+      b[0]->current_length -= adv[0];
+      b[1]->current_length -= adv[1];
+      b[2]->current_length -= adv[2];
+      b[3]->current_length -= adv[3];
+
+      /* next */
+      next += 4;
+      mb += 4;
+      n_left -= 4;
+      flags += 4;
+    }
+
+  while (n_left)
+    {
+      b[0] = vlib_buffer_from_rte_mbuf (mb[0]);
+      next[0] = *(u16 *) ((u8 *) mb[0] + next[0] + sizeof (vlib_buffer_t));
+      next[0] = dpdk_rx_next (node, next[0], flags[0]);
+      adv[0] = device_input_next_node_advance[next[0]];
+      b[0]->current_data += adv[0];
+      b[0]->current_length -= adv[0];
+
+      /* next */
+      next += 1;
+      mb += 1;
+      n_left -= 1;
+      flags += 1;
+    }
+}
+
+static_always_inline u32
+dpdk_device_input (vlib_main_t * vm, dpdk_main_t * dm, dpdk_device_t * xd,
+		   vlib_node_runtime_t * node, u32 thread_index, u16 queue_id)
+{
+  uword n_rx_packets = 0, n_rx_bytes;
+  u32 n_left, n_trace;
+  u32 *buffers;
+  u32 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
+  struct rte_mbuf **mb;
+  vlib_buffer_t *b0;
+  int known_next = 0;
+  u16 *next;
+  u8 or_flags;
+  u32 n;
+
+  dpdk_per_thread_data_t *ptd = vec_elt_at_index (dm->per_thread_data,
+						  thread_index);
+  vlib_buffer_t *bt = &ptd->buffer_template;
+
+  if ((xd->flags & DPDK_DEVICE_FLAG_ADMIN_UP) == 0)
+    return 0;
+
+  /* get up to DPDK_RX_BURST_SZ buffers from PMD */
+  while (n_rx_packets < DPDK_RX_BURST_SZ)
+    {
+      n = rte_eth_rx_burst (xd->device_index, queue_id,
+			    ptd->mbufs + n_rx_packets,
+			    DPDK_RX_BURST_SZ - n_rx_packets);
+      n_rx_packets += n;
+
+      if (n < 32)
+	break;
+    }
+
+  if (n_rx_packets == 0)
+    return 0;
+
+  /* Update buffer template */
+  vnet_buffer (bt)->sw_if_index[VLIB_RX] = xd->sw_if_index;
+  bt->error = node->errors[DPDK_ERROR_NONE];
+  /* as DPDK is allocating empty buffers from mempool provided before interface
+     start for each queue, it is safe to store this in the template */
+  bt->buffer_pool_index = xd->buffer_pool_for_queue[queue_id];
+
+  /* receive burst of packets from DPDK PMD */
+  if (PREDICT_FALSE (xd->per_interface_next_index != ~0))
+    {
+      known_next = 1;
+      next_index = xd->per_interface_next_index;
+    }
+
+  /* as all packets belong to thr same interface feature arc lookup
+     can be don once and result stored in the buffer template */
+  if (PREDICT_FALSE (vnet_device_input_have_features (xd->sw_if_index)))
+    {
+      vnet_feature_start_device_input_x1 (xd->sw_if_index, &next_index, bt);
+      known_next = 1;
+    }
+
+  if (xd->flags & DPDK_DEVICE_FLAG_MAYBE_MULTISEG)
+    n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 1, &or_flags);
+  else
+    n_rx_bytes = dpdk_process_rx_burst (vm, ptd, n_rx_packets, 0, &or_flags);
+
+  if (PREDICT_FALSE (known_next))
+    {
+      for (n = 0; n < n_rx_packets; n++)
+	ptd->next[n] = next_index;
+
+      bt->feature_arc_index = 0;
+      bt->current_config_index = 0;
+    }
+  else
+    dpdk_set_next_from_etype (vm, node, ptd, n_rx_packets);
+
+  /* is at least one packet marked as ip4 checksum bad? */
+  if (PREDICT_FALSE (or_flags & (1 << DPDK_RX_F_CKSUM_BAD)))
+    for (n = 0; n < n_rx_packets; n++)
+      {
+	if ((ptd->flags[n] & (1 << DPDK_RX_F_CKSUM_BAD)) == 0)
+	  continue;
+	if (ptd->next[n] != VNET_DEVICE_INPUT_NEXT_IP4_INPUT)
+	  continue;
+
+	b0 = vlib_buffer_from_rte_mbuf (ptd->mbufs[n]);
+	b0->error = node->errors[DPDK_ERROR_IP_CHECKSUM_ERROR];
+	ptd->next[n] = VNET_DEVICE_INPUT_NEXT_DROP;
+      }
+
+  /* enqueue buffers to the next node */
+  n_left = n_rx_packets;
+  next = ptd->next;
+  buffers = ptd->buffers;
+  mb = ptd->mbufs;
+  while (n_left)
+    {
+      u32 n_left_to_next;
+      u32 *to_next;
+      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+#ifdef CLIB_HAVE_VEC256
+      while (n_left >= 16 && n_left_to_next >= 16)
+	{
+	  u16x16 next16 = u16x16_load_unaligned (next);
+	  if (u16x16_is_all_equal (next16, next_index))
+	    {
+	      dpdk_mbuf_to_buffer_index_x4 (vm, mb, buffers);
+	      dpdk_mbuf_to_buffer_index_x4 (vm, mb + 4, buffers + 4);
+	      dpdk_mbuf_to_buffer_index_x4 (vm, mb + 8, buffers + 8);
+	      dpdk_mbuf_to_buffer_index_x4 (vm, mb + 12, buffers + 12);
+	      clib_memcpy (to_next, buffers, 16 * sizeof (u32));
+	      to_next += 16;
+	      n_left_to_next -= 16;
+	      buffers += 16;
+	      n_left -= 16;
+	      next += 16;
+	      mb += 16;
+	    }
+	  else
+	    {
+	      dpdk_mbuf_to_buffer_index_x4 (vm, mb, buffers);
+	      clib_memcpy (to_next, buffers, 4 * sizeof (u32));
+	      to_next += 4;
+	      n_left_to_next -= 4;
+
+	      vlib_validate_buffer_enqueue_x4 (vm, node, next_index, to_next,
+					       n_left_to_next, buffers[0],
+					       buffers[1], buffers[2],
+					       buffers[3], next[0], next[1],
+					       next[2], next[3]);
+	      /* next */
+	      buffers += 4;
+	      n_left -= 4;
+	      next += 4;
+	      mb += 4;
+	    }
+	}
+#endif
+      while (n_left >= 4 && n_left_to_next >= 4)
+	{
+	  dpdk_mbuf_to_buffer_index_x4 (vm, mb, buffers);
+	  clib_memcpy (to_next, buffers, 4 * sizeof (u32));
+	  to_next += 4;
+	  n_left_to_next -= 4;
+
+	  vlib_validate_buffer_enqueue_x4 (vm, node, next_index, to_next,
+					   n_left_to_next, buffers[0],
+					   buffers[1], buffers[2], buffers[3],
+					   next[0], next[1], next[2],
+					   next[3]);
+	  /* next */
+	  buffers += 4;
+	  n_left -= 4;
+	  next += 4;
+	  mb += 4;
+	}
+      while (n_left && n_left_to_next)
+	{
+	  to_next[0] = buffers[0] =
+	    vlib_get_buffer_index (vm, vlib_buffer_from_rte_mbuf (mb[0]));
+	  to_next += 1;
+	  n_left_to_next -= 1;
+	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+					   n_left_to_next, buffers[0],
+					   next[0]);
+	  /* next */
+	  buffers += 1;
+	  n_left -= 1;
+	  next += 1;
+	  mb += 1;
+	}
+      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
+    }
+
+  /* packet trace if enabled */
+  if ((n_trace = vlib_get_trace_count (vm, node)))
+    {
+      n_left = n_rx_packets;
+      buffers = ptd->buffers;
+      mb = ptd->mbufs;
+      next = ptd->next;
+      while (n_trace && n_left)
+	{
+	  b0 = vlib_get_buffer (vm, buffers[0]);
+	  vlib_trace_buffer (vm, node, next[0], b0, /* follow_chain */ 0);
+
+	  dpdk_rx_trace_t *t0 = vlib_add_trace (vm, node, b0, sizeof t0[0]);
+	  t0->queue_index = queue_id;
+	  t0->device_index = xd->device_index;
+	  t0->buffer_index = vlib_get_buffer_index (vm, b0);
+
+	  clib_memcpy (&t0->mb, mb[0], sizeof t0->mb);
+	  clib_memcpy (&t0->buffer, b0, sizeof b0[0] - sizeof b0->pre_data);
+	  clib_memcpy (t0->buffer.pre_data, b0->data,
+		       sizeof t0->buffer.pre_data);
+	  clib_memcpy (&t0->data, mb[0]->buf_addr + mb[0]->data_off,
+		       sizeof t0->data);
+	  n_trace--;
+	  n_left--;
+	  buffers++;
+	  mb++;
+	  next++;
+	}
+      vlib_set_trace_count (vm, node, n_trace);
+    }
+
+  vlib_increment_combined_counter
+    (vnet_get_main ()->interface_main.combined_sw_if_counters
+     + VNET_INTERFACE_COUNTER_RX, thread_index, xd->sw_if_index,
+     n_rx_packets, n_rx_bytes);
+
+  vnet_device_increment_rx_packets (thread_index, n_rx_packets);
+
+  return n_rx_packets;
+}
+
+uword CLIB_CPU_OPTIMIZED
 CLIB_MULTIARCH_FN (dpdk_input) (vlib_main_t * vm, vlib_node_runtime_t * node,
 				vlib_frame_t * f)
 {
@@ -582,19 +683,9 @@ CLIB_MULTIARCH_FN (dpdk_input) (vlib_main_t * vm, vlib_node_runtime_t * node,
     {
       xd = vec_elt_at_index(dm->devices, dq->dev_instance);
       if (PREDICT_FALSE (xd->flags & DPDK_DEVICE_FLAG_BOND_SLAVE))
-	continue; 	/* Do not poll slave to a bonded interface */
-      u32 n_trace = vlib_get_trace_count (vm, node);
-      if (PREDICT_TRUE(n_trace == 0))
-        n_rx_packets += dpdk_device_input_mseg (dm, xd, node, thread_index,
-						dq->queue_id, 0);
-      else
-        {
-          u32 n_tr_packets = dpdk_device_input_mseg (dm, xd, node, thread_index,
-						     dq->queue_id, n_trace);
-          n_rx_packets += n_tr_packets;
-          vlib_set_trace_count (vm, node,
-				n_trace - clib_min(n_trace, n_tr_packets));
-        }
+	continue;	/* Do not poll slave to a bonded interface */
+      n_rx_packets += dpdk_device_input (vm, dm, xd, node, thread_index,
+					 dq->queue_id);
     }
   /* *INDENT-ON* */
 
@@ -615,7 +706,7 @@ VLIB_REGISTER_NODE (dpdk_input_node) = {
   .state = VLIB_NODE_STATE_DISABLED,
 
   .format_buffer = format_ethernet_header_with_length,
-  .format_trace = format_dpdk_rx_dma_trace,
+  .format_trace = format_dpdk_rx_trace,
 
   .n_errors = DPDK_N_ERROR,
   .error_strings = dpdk_error_strings,