nsim: basic reorder support

Reorder delayed packets, i.e., flush instead of delay, with a configured
rate.

Type: feature

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

1 files changed, 162 insertions, 305 deletions

diff --git a/src/plugins/nsim/node.c b/src/plugins/nsim/node.c
index 57afbd273a7..5d72a911cec 100644
--- a/src/plugins/nsim/node.c
+++ b/src/plugins/nsim/node.c
@@ -54,7 +54,8 @@ vlib_node_registration_t nsim_node;
 #define foreach_nsim_error                              \
 _(BUFFERED, "Packets buffered")                         \
 _(DROPPED, "Packets dropped due to lack of space")	\
-_(LOSS, "Network loss simulation drop packets")
+_(LOSS, "Network loss simulation drop packets")		\
+_(REORDERED, "Packets reordered")
 
 typedef enum
 {
@@ -78,27 +79,124 @@ typedef enum
   NSIM_N_NEXT,
 } nsim_next_t;
 
+static void
+nsim_set_actions (nsim_main_t * nsm, vlib_buffer_t ** b,
+		  nsim_node_ctx_t * ctx, u32 n_actions)
+{
+  int i;
+
+  memset (ctx->action, 0, n_actions * sizeof (ctx->action[0]));
+
+  if (PREDICT_FALSE (nsm->drop_fraction != 0.0))
+    {
+      for (i = 0; i < n_actions; i++)
+	if (random_f64 (&nsm->seed) <= nsm->drop_fraction)
+	  ctx->action[i] |= NSIM_ACTION_DROP;
+    }
+
+  if (PREDICT_FALSE (nsm->reorder_fraction != 0.0))
+    {
+      for (i = 0; i < n_actions; i++)
+	if (random_f64 (&nsm->seed) <= nsm->reorder_fraction)
+	  ctx->action[i] |= NSIM_ACTION_REORDER;
+    }
+}
+
+static void
+nsim_trace_buffer (vlib_main_t * vm, vlib_node_runtime_t * node,
+		   vlib_buffer_t * b, nsim_node_ctx_t * ctx, u32 is_drop)
+{
+  if (b->flags & VLIB_BUFFER_IS_TRACED)
+    {
+      nsim_trace_t *t = vlib_add_trace (vm, node, b, sizeof (*t));
+      t->expires = ctx->expires;
+      t->is_drop = is_drop;
+      t->is_lost = ctx->action[0] & NSIM_ACTION_DROP;
+      t->tx_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
+    }
+}
+
+always_inline void
+nsim_buffer_fwd_lookup (nsim_main_t * nsm, vlib_buffer_t * b,
+			u32 * next, u8 is_cross_connect)
+{
+  if (is_cross_connect)
+    {
+      vnet_buffer (b)->sw_if_index[VLIB_TX] =
+	(vnet_buffer (b)->sw_if_index[VLIB_RX] == nsm->sw_if_index0) ?
+	nsm->sw_if_index1 : nsm->sw_if_index0;
+      *next =
+	(vnet_buffer (b)->sw_if_index[VLIB_TX] == nsm->sw_if_index0) ?
+	nsm->output_next_index0 : nsm->output_next_index1;
+    }
+  else				/* output feature, even easier... */
+    {
+      u32 sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
+      *next = nsm->output_next_index_by_sw_if_index[sw_if_index];
+    }
+}
+
+always_inline void
+nsim_dispatch_buffer (vlib_main_t * vm, vlib_node_runtime_t * node,
+		      nsim_main_t * nsm, nsim_wheel_t * wp, vlib_buffer_t * b,
+		      u32 bi, nsim_node_ctx_t * ctx, u8 is_cross_connect,
+		      u8 is_trace)
+{
+  if (PREDICT_TRUE (!(ctx->action[0] & NSIM_ACTION_DROP)))
+    {
+      if (PREDICT_FALSE (ctx->action[0] & NSIM_ACTION_REORDER))
+	{
+	  u32 next;
+	  ctx->reord[0] = bi;
+	  vnet_get_config_data (&ctx->fcm->config_main,
+				&b->current_config_index, &next, 0);
+	  ctx->reord_nexts[0] = next;
+	  ctx->reord += 1;
+	  ctx->reord_nexts += 1;
+	  goto trace;
+	}
+
+      nsim_wheel_entry_t *ep = wp->entries + wp->tail;
+      wp->tail++;
+      if (wp->tail == wp->wheel_size)
+	wp->tail = 0;
+      wp->cursize++;
+
+      ep->tx_time = ctx->expires;
+      ep->rx_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
+      nsim_buffer_fwd_lookup (nsm, b, &ep->output_next_index,
+			      is_cross_connect);
+      ep->tx_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
+      ep->buffer_index = bi;
+      ctx->n_buffered += 1;
+    }
+  else
+    {
+      ctx->n_loss += 1;
+      ctx->drop[0] = bi;
+      ctx->drop += 1;
+    }
+
+trace:
+
+  if (PREDICT_FALSE (is_trace))
+    nsim_trace_buffer (vm, node, b, ctx, 0);
+
+  ctx->action += 1;
+}
+
 always_inline uword
 nsim_inline (vlib_main_t * vm,
 	     vlib_node_runtime_t * node, vlib_frame_t * frame, int is_trace,
 	     int is_cross_connect)
 {
   nsim_main_t *nsm = &nsim_main;
-  u32 n_left_from, *from;
-  u32 *to_next, n_left_to_next;
-  u32 drops[VLIB_FRAME_SIZE], *drop;
+  u32 n_left_from, *from, drops[VLIB_FRAME_SIZE], reorders[VLIB_FRAME_SIZE];
+  nsim_wheel_t *wp = nsm->wheel_by_thread[vm->thread_index];
   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
-  u8 is_drop[4];
-  u16 nexts[VLIB_FRAME_SIZE], *next;
-  u32 my_thread_index = vm->thread_index;
-  nsim_wheel_t *wp = nsm->wheel_by_thread[my_thread_index];
-  f64 now = vlib_time_now (vm);
-  f64 expires = now + nsm->delay;
-  f64 rnd[4];
-  u32 no_buffer_error = node->errors[NSIM_ERROR_DROPPED];
-  u32 loss_error = node->errors[NSIM_ERROR_LOSS];
-  u32 buffered = 0;
-  nsim_wheel_entry_t *ep = 0;
+  u16 reorders_nexts[VLIB_FRAME_SIZE];
+  u8 actions[VLIB_FRAME_SIZE];
+  nsim_node_ctx_t ctx;
 
   ASSERT (wp);
 
@@ -107,8 +205,17 @@ nsim_inline (vlib_main_t * vm,
 
   vlib_get_buffers (vm, from, bufs, n_left_from);
   b = bufs;
-  next = nexts;
-  drop = drops;
+
+  ctx.fcm = vnet_feature_get_config_main (nsm->arc_index);
+  ctx.n_loss = 0;
+  ctx.n_buffered = 0;
+  ctx.drop = drops;
+  ctx.reord = reorders;
+  ctx.reord_nexts = reorders_nexts;
+  ctx.action = actions;
+  ctx.expires = vlib_time_now (vm) + nsm->delay;
+
+  nsim_set_actions (nsm, b, &ctx, n_left_from);
 
   while (n_left_from >= 8)
     {
@@ -117,217 +224,19 @@ nsim_inline (vlib_main_t * vm,
       vlib_prefetch_buffer_header (b[6], STORE);
       vlib_prefetch_buffer_header (b[7], STORE);
 
-      memset (&is_drop, 0, sizeof (is_drop));
-      next[0] = next[1] = next[2] = next[3] = NSIM_NEXT_DROP;
       if (PREDICT_FALSE (wp->cursize + 4 >= wp->wheel_size))
 	goto slow_path;
-      if (PREDICT_FALSE (nsm->drop_fraction != 0.0))
-	{
-	  rnd[0] = random_f64 (&nsm->seed);
-	  rnd[1] = random_f64 (&nsm->seed);
-	  rnd[2] = random_f64 (&nsm->seed);
-	  rnd[3] = random_f64 (&nsm->seed);
-
-	  if (rnd[0] <= nsm->drop_fraction)
-	    {
-	      b[0]->error = loss_error;
-	      is_drop[0] = 1;
-	    }
-	  if (rnd[1] <= nsm->drop_fraction)
-	    {
-	      b[1]->error = loss_error;
-	      is_drop[1] = 1;
-	    }
-	  if (rnd[2] <= nsm->drop_fraction)
-	    {
-	      b[2]->error = loss_error;
-	      is_drop[2] = 1;
-	    }
-	  if (rnd[3] <= nsm->drop_fraction)
-	    {
-	      b[3]->error = loss_error;
-	      is_drop[3] = 1;
-	    }
-	}
-
-      if (PREDICT_TRUE (is_drop[0] == 0))
-	{
-	  ep = wp->entries + wp->tail;
-	  wp->tail++;
-	  if (wp->tail == wp->wheel_size)
-	    wp->tail = 0;
-	  wp->cursize++;
-
-	  ep->tx_time = expires;
-	  ep->rx_sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
-	  if (is_cross_connect)
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_TX] =
-		(vnet_buffer (b[0])->sw_if_index[VLIB_RX] ==
-		 nsm->sw_if_index0) ? nsm->sw_if_index1 : nsm->sw_if_index0;
-	      ep->output_next_index =
-		(ep->tx_sw_if_index ==
-		 nsm->sw_if_index0) ? nsm->
-		output_next_index0 : nsm->output_next_index1;
-	    }
-	  else			/* output feature, even easier... */
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
-	      ep->output_next_index =
-		nsm->output_next_index_by_sw_if_index[ep->tx_sw_if_index];
-	    }
-	  ep->buffer_index = from[0];
-	  buffered++;
-	}
-      if (is_trace)
-	{
-	  if (b[0]->flags & VLIB_BUFFER_IS_TRACED)
-	    {
-	      nsim_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t));
-	      t->expires = expires;
-	      t->is_drop = is_drop[0];
-	      t->is_lost = b[0]->error == loss_error;
-	      t->tx_sw_if_index = (is_drop[0] == 0) ? ep->tx_sw_if_index : 0;
-	    }
-	}
 
-      if (PREDICT_TRUE (is_drop[1] == 0))
-	{
-	  ep = wp->entries + wp->tail;
-	  wp->tail++;
-	  if (wp->tail == wp->wheel_size)
-	    wp->tail = 0;
-	  wp->cursize++;
-
-	  ep->tx_time = expires;
-	  ep->rx_sw_if_index = vnet_buffer (b[1])->sw_if_index[VLIB_RX];
-	  if (is_cross_connect)
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[1])->sw_if_index[VLIB_TX] =
-		(vnet_buffer (b[1])->sw_if_index[VLIB_RX] ==
-		 nsm->sw_if_index0) ? nsm->sw_if_index1 : nsm->sw_if_index0;
-	      ep->output_next_index =
-		(ep->tx_sw_if_index ==
-		 nsm->sw_if_index0) ? nsm->
-		output_next_index0 : nsm->output_next_index1;
-	    }
-	  else			/* output feature, even easier... */
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[1])->sw_if_index[VLIB_TX];
-	      ep->output_next_index =
-		nsm->output_next_index_by_sw_if_index[ep->tx_sw_if_index];
-	    }
-	  ep->buffer_index = from[1];
-	  buffered++;
-	}
-
-      if (is_trace)
-	{
-	  if (b[1]->flags & VLIB_BUFFER_IS_TRACED)
-	    {
-	      nsim_trace_t *t = vlib_add_trace (vm, node, b[1], sizeof (*t));
-	      t->expires = expires;
-	      t->is_drop = is_drop[1];
-	      t->is_lost = b[1]->error == loss_error;
-	      t->tx_sw_if_index = (is_drop[1] == 0) ? ep->tx_sw_if_index : 0;
-	    }
-	}
-
-      if (PREDICT_TRUE (is_drop[2] == 0))
-	{
-	  ep = wp->entries + wp->tail;
-	  wp->tail++;
-	  if (wp->tail == wp->wheel_size)
-	    wp->tail = 0;
-	  wp->cursize++;
-
-	  ep->tx_time = expires;
-	  ep->rx_sw_if_index = vnet_buffer (b[2])->sw_if_index[VLIB_RX];
-	  if (is_cross_connect)
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[2])->sw_if_index[VLIB_TX] =
-		(vnet_buffer (b[2])->sw_if_index[VLIB_RX] ==
-		 nsm->sw_if_index0) ? nsm->sw_if_index1 : nsm->sw_if_index0;
-	      ep->output_next_index =
-		(ep->tx_sw_if_index ==
-		 nsm->sw_if_index0) ? nsm->
-		output_next_index0 : nsm->output_next_index1;
-	    }
-	  else			/* output feature, even easier... */
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[2])->sw_if_index[VLIB_TX];
-	      ep->output_next_index =
-		nsm->output_next_index_by_sw_if_index[ep->tx_sw_if_index];
-	    }
-	  ep->buffer_index = from[2];
-	  buffered++;
-	}
-
-      if (is_trace)
-	{
-	  if (b[2]->flags & VLIB_BUFFER_IS_TRACED)
-	    {
-	      nsim_trace_t *t = vlib_add_trace (vm, node, b[2], sizeof (*t));
-	      t->expires = expires;
-	      t->is_drop = is_drop[2];
-	      t->is_lost = b[2]->error == loss_error;
-	      t->tx_sw_if_index = (is_drop[2] == 0) ? ep->tx_sw_if_index : 0;
-	    }
-	}
-
-      if (PREDICT_TRUE (is_drop[3] == 0))
-	{
-	  ep = wp->entries + wp->tail;
-	  wp->tail++;
-	  if (wp->tail == wp->wheel_size)
-	    wp->tail = 0;
-	  wp->cursize++;
-
-	  ep->tx_time = expires;
-	  ep->rx_sw_if_index = vnet_buffer (b[3])->sw_if_index[VLIB_RX];
-	  if (is_cross_connect)
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[3])->sw_if_index[VLIB_TX] =
-		(vnet_buffer (b[3])->sw_if_index[VLIB_RX] ==
-		 nsm->sw_if_index0) ? nsm->sw_if_index1 : nsm->sw_if_index0;
-	      ep->output_next_index =
-		(ep->tx_sw_if_index ==
-		 nsm->sw_if_index0) ? nsm->
-		output_next_index0 : nsm->output_next_index1;
-	    }
-	  else			/* output feature, even easier... */
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[3])->sw_if_index[VLIB_TX];
-	      ep->output_next_index =
-		nsm->output_next_index_by_sw_if_index[ep->tx_sw_if_index];
-	    }
-	  ep->buffer_index = from[3];
-	  buffered++;
-	}
-
-      if (is_trace)
-	{
-	  if (b[3]->flags & VLIB_BUFFER_IS_TRACED)
-	    {
-	      nsim_trace_t *t = vlib_add_trace (vm, node, b[3], sizeof (*t));
-	      t->expires = expires;
-	      t->is_drop = is_drop[3];
-	      t->is_lost = b[3]->error == loss_error;
-	      t->tx_sw_if_index = (is_drop[3] == 0) ? ep->tx_sw_if_index : 0;
-	    }
-	}
-
-      if (PREDICT_FALSE (is_drop[0]))
-	*drop++ = from[0];
-      if (PREDICT_FALSE (is_drop[1]))
-	*drop++ = from[1];
-      if (PREDICT_FALSE (is_drop[2]))
-	*drop++ = from[2];
-      if (PREDICT_FALSE (is_drop[3]))
-	*drop++ = from[3];
+      nsim_dispatch_buffer (vm, node, nsm, wp, b[0], from[0], &ctx,
+			    is_cross_connect, is_trace);
+      nsim_dispatch_buffer (vm, node, nsm, wp, b[1], from[1], &ctx,
+			    is_cross_connect, is_trace);
+      nsim_dispatch_buffer (vm, node, nsm, wp, b[2], from[2], &ctx,
+			    is_cross_connect, is_trace);
+      nsim_dispatch_buffer (vm, node, nsm, wp, b[3], from[3], &ctx,
+			    is_cross_connect, is_trace);
 
       b += 4;
-      next += 4;
       from += 4;
       n_left_from -= 4;
     }
@@ -336,99 +245,47 @@ slow_path:
 
   while (n_left_from > 0)
     {
-      next[0] = NSIM_NEXT_DROP;
-      is_drop[0] = 0;
-      if (PREDICT_TRUE (wp->cursize < wp->wheel_size))
-	{
-	  if (PREDICT_FALSE (nsm->drop_fraction != 0.0))
-	    {
-	      /* Get a random number on the closed interval [0,1] */
-	      rnd[0] = random_f64 (&nsm->seed);
-	      /* Drop the pkt? */
-	      if (rnd[0] <= nsm->drop_fraction)
-		{
-		  b[0]->error = loss_error;
-		  is_drop[0] = 1;
-		  goto do_trace;
-		}
-	    }
-
-	  ep = wp->entries + wp->tail;
-	  wp->tail++;
-	  if (wp->tail == wp->wheel_size)
-	    wp->tail = 0;
-	  wp->cursize++;
-
-	  ep->tx_time = expires;
-	  ep->rx_sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
-	  if (is_cross_connect)
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_TX] =
-		(vnet_buffer (b[0])->sw_if_index[VLIB_RX] ==
-		 nsm->sw_if_index0) ? nsm->sw_if_index1 : nsm->sw_if_index0;
-	      ep->output_next_index =
-		(ep->tx_sw_if_index ==
-		 nsm->sw_if_index0) ? nsm->
-		output_next_index0 : nsm->output_next_index1;
-	    }
-	  else			/* output feature, even easier... */
-	    {
-	      ep->tx_sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
-	      ep->output_next_index =
-		nsm->output_next_index_by_sw_if_index[ep->tx_sw_if_index];
-	    }
-	  ep->buffer_index = from[0];
-	  buffered++;
-	}
-      else			/* out of wheel space, drop pkt */
+      /* Drop if out of wheel space and not drop or reorder */
+      if (PREDICT_TRUE (wp->cursize < wp->wheel_size
+			|| (ctx.action[0] & NSIM_ACTION_DROP)
+			|| (ctx.action[0] & NSIM_ACTION_REORDER)))
 	{
-	  b[0]->error = no_buffer_error;
-	  is_drop[0] = 1;
+	  nsim_dispatch_buffer (vm, node, nsm, wp, b[0], from[0], &ctx,
+				is_cross_connect, is_trace);
 	}
-
-    do_trace:
-      if (is_trace)
+      else
 	{
-	  if (b[0]->flags & VLIB_BUFFER_IS_TRACED)
-	    {
-	      nsim_trace_t *t = vlib_add_trace (vm, node, b[0], sizeof (*t));
-	      t->expires = expires;
-	      t->is_drop = is_drop[0];
-	      t->is_lost = b[0]->error == loss_error;
-	      t->tx_sw_if_index = (is_drop[0] == 0) ? ep->tx_sw_if_index : 0;
-	    }
+	  ctx.drop[0] = from[0];
+	  ctx.drop += 1;
+	  if (PREDICT_FALSE (is_trace))
+	    nsim_trace_buffer (vm, node, b[0], &ctx, 1);
+	  ctx.action += 1;
 	}
 
       b += 1;
-      next += 1;
-      if (PREDICT_FALSE (is_drop[0]))
-	{
-	  drop[0] = from[0];
-	  drop++;
-	}
-      from++;
+      from += 1;
       n_left_from -= 1;
     }
-  if (PREDICT_FALSE (drop > drops))
-    {
-      u32 n_left_to_drop = drop - drops;
-      drop = drops;
 
-      while (n_left_to_drop > 0)
-	{
-	  u32 this_copy_size;
-	  vlib_get_next_frame (vm, node, NSIM_NEXT_DROP, to_next,
-			       n_left_to_next);
-	  this_copy_size = clib_min (n_left_to_drop, n_left_to_next);
-	  clib_memcpy_fast (to_next, drop, this_copy_size * sizeof (u32));
-	  n_left_to_next -= this_copy_size;
-	  vlib_put_next_frame (vm, node, NSIM_NEXT_DROP, n_left_to_next);
-	  drop += this_copy_size;
-	  n_left_to_drop -= this_copy_size;
-	}
+  if (PREDICT_FALSE (ctx.drop > drops))
+    {
+      u32 n_left_to_drop = ctx.drop - drops;
+      vlib_buffer_free (vm, drops, n_left_to_drop);
+      vlib_node_increment_counter (vm, node->node_index, NSIM_ERROR_LOSS,
+				   ctx.n_loss);
+      vlib_node_increment_counter (vm, node->node_index, NSIM_ERROR_DROPPED,
+				   n_left_to_drop - ctx.n_loss);
+    }
+  if (PREDICT_FALSE (ctx.reord > reorders))
+    {
+      u32 n_reordered = ctx.reord - reorders;
+      vlib_buffer_enqueue_to_next (vm, node, reorders, reorders_nexts,
+				   n_reordered);
+      vlib_node_increment_counter (vm, node->node_index, NSIM_ERROR_REORDERED,
+				   n_reordered);
     }
   vlib_node_increment_counter (vm, node->node_index,
-			       NSIM_ERROR_BUFFERED, buffered);
+			       NSIM_ERROR_BUFFERED, ctx.n_buffered);
   return frame->n_vectors;
 }