X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlib%2Fnode.c;h=e613a85adc8ba71a82911ff212798a679dbaf3d9;hb=a6b1a7d809e746325fe712b9de9ff086e55772dd;hp=0e6038d01fa438676891b550a025901baa51e78e;hpb=687c9021fda009caa2b7eb17bea2eaa51d275bde;p=vpp.git

diff --git a/src/vlib/node.c b/src/vlib/node.c
index 0e6038d01fa..e613a85adc8 100644
--- a/src/vlib/node.c
+++ b/src/vlib/node.c
@@ -47,8 +47,7 @@ vlib_get_node_by_name (vlib_main_t * vm, u8 * name)
   vlib_node_main_t *nm = &vm->node_main;
   uword *p;
   u8 *key = name;
-  if (!clib_mem_is_heap_object (vec_header (key, 0)))
-    key = format (0, "%s", key);
+  key = format (0, "%s", key);
   p = hash_get (nm->node_by_name, key);
   if (key != name)
     vec_free (key);
@@ -69,33 +68,8 @@ node_set_elog_name (vlib_main_t * vm, uword node_index)
   vec_free (t->format);
   t->format = (char *) format (0, "%v-return: %%d%c", n->name, 0);
 
-  n->name_elog_string = elog_string (&vm->elog_main, "%v%c", n->name, 0);
-}
-
-static void
-vlib_worker_thread_node_rename (u32 node_index)
-{
-  int i;
-  vlib_main_t *vm;
-  vlib_node_t *n;
-
-  if (vec_len (vlib_mains) == 1)
-    return;
-
-  vm = vlib_mains[0];
-  n = vlib_get_node (vm, node_index);
-
-  ASSERT (vlib_get_thread_index () == 0);
-  ASSERT (*vlib_worker_threads->wait_at_barrier == 1);
-
-  for (i = 1; i < vec_len (vlib_mains); i++)
-    {
-      vlib_main_t *vm_worker = vlib_mains[i];
-      vlib_node_t *n_worker = vlib_get_node (vm_worker, node_index);
-
-      n_worker->name = n->name;
-      n_worker->name_elog_string = n->name_elog_string;
-    }
+  n->name_elog_string =
+    elog_string (&vlib_global_main.elog_main, "%v%c", n->name, 0);
 }
 
 void
@@ -115,7 +89,7 @@ vlib_node_rename (vlib_main_t * vm, u32 node_index, char *fmt, ...)
   node_set_elog_name (vm, node_index);
 
   /* Propagate the change to all worker threads */
-  vlib_worker_thread_node_rename (node_index);
+  vlib_worker_thread_node_runtime_update ();
 }
 
 static void
@@ -128,10 +102,6 @@ vlib_node_runtime_update (vlib_main_t * vm, u32 node_index, u32 next_index)
   vlib_pending_frame_t *pf;
   i32 i, j, n_insert;
 
-  ASSERT (vlib_get_thread_index () == 0);
-
-  vlib_worker_thread_barrier_sync (vm);
-
   node = vec_elt (nm->nodes, node_index);
   r = vlib_node_get_runtime (vm, node_index);
 
@@ -161,10 +131,10 @@ vlib_node_runtime_update (vlib_main_t * vm, u32 node_index, u32 next_index)
 	  pf->next_frame_index += n_insert;
       }
       /* *INDENT-OFF* */
-      pool_foreach (pf, nm->suspended_process_frames, ({
+      pool_foreach (pf, nm->suspended_process_frames)  {
 	  if (pf->next_frame_index != ~0 && pf->next_frame_index >= i)
 	    pf->next_frame_index += n_insert;
-      }));
+      }
       /* *INDENT-ON* */
 
       r->n_next_nodes = vec_len (node->next_nodes);
@@ -176,8 +146,6 @@ vlib_node_runtime_update (vlib_main_t * vm, u32 node_index, u32 next_index)
   nf->node_runtime_index = next_node->runtime_index;
 
   vlib_worker_thread_node_runtime_update ();
-
-  vlib_worker_thread_barrier_release (vm);
 }
 
 uword
@@ -207,9 +175,12 @@ vlib_node_add_next_with_slot (vlib_main_t * vm,
 			      uword next_node_index, uword slot)
 {
   vlib_node_main_t *nm = &vm->node_main;
-  vlib_node_t *node, *next;
+  vlib_node_t *node, *next, *old_next;
+  u32 old_next_index;
   uword *p;
 
+  ASSERT (vlib_get_thread_index () == 0);
+
   node = vec_elt (nm->nodes, node_index);
   next = vec_elt (nm->nodes, next_node_index);
 
@@ -224,12 +195,22 @@ vlib_node_add_next_with_slot (vlib_main_t * vm,
       return p[0];
     }
 
+  vlib_worker_thread_barrier_sync (vm);
+
   if (slot == ~0)
     slot = vec_len (node->next_nodes);
 
   vec_validate_init_empty (node->next_nodes, slot, ~0);
   vec_validate (node->n_vectors_by_next_node, slot);
 
+  if ((old_next_index = node->next_nodes[slot]) != ~0u)
+    {
+      hash_unset (node->next_slot_by_node, old_next_index);
+      old_next = vlib_get_node (vm, old_next_index);
+      old_next->prev_node_bitmap =
+	clib_bitmap_andnoti (old_next->prev_node_bitmap, node_index);
+    }
+
   node->next_nodes[slot] = next_node_index;
   hash_set (node->next_slot_by_node, next_node_index, slot);
 
@@ -243,17 +224,18 @@ vlib_node_add_next_with_slot (vlib_main_t * vm,
     uword sib_node_index, sib_slot;
     vlib_node_t *sib_node;
     /* *INDENT-OFF* */
-    clib_bitmap_foreach (sib_node_index, node->sibling_bitmap, ({
+    clib_bitmap_foreach (sib_node_index, node->sibling_bitmap)  {
       sib_node = vec_elt (nm->nodes, sib_node_index);
       if (sib_node != node)
 	{
 	  sib_slot = vlib_node_add_next_with_slot (vm, sib_node_index, next_node_index, slot);
 	  ASSERT (sib_slot == slot);
 	}
-    }));
+    }
     /* *INDENT-ON* */
   }
 
+  vlib_worker_thread_barrier_release (vm);
   return slot;
 }
 
@@ -309,12 +291,76 @@ node_elog_init (vlib_main_t * vm, uword ni)
 #define STACK_ALIGN CLIB_CACHE_LINE_BYTES
 #endif
 
+vlib_node_function_t *
+vlib_node_get_preferred_node_fn_variant (vlib_main_t *vm,
+					 vlib_node_fn_registration_t *regs)
+{
+  vlib_node_main_t *nm = &vm->node_main;
+  vlib_node_fn_registration_t *r;
+  vlib_node_fn_variant_t *v;
+  vlib_node_function_t *fn = 0;
+  int priority = -1;
+
+  if (nm->node_fn_default_march_variant != ~0)
+    {
+      r = regs;
+      while (r)
+	{
+	  if (r->march_variant == nm->node_fn_default_march_variant)
+	    return r->function;
+	  r = r->next_registration;
+	}
+    }
+
+  r = regs;
+  while (r)
+    {
+      v = vec_elt_at_index (nm->variants, r->march_variant);
+      if (v->priority > priority)
+	{
+	  priority = v->priority;
+	  fn = r->function;
+	}
+      r = r->next_registration;
+    }
+
+  ASSERT (fn);
+  return fn;
+}
+
 static void
-register_node (vlib_main_t * vm, vlib_node_registration_t * r)
+vlib_node_add_to_sibling_bitmap (vlib_main_t *vm, vlib_node_t *n,
+				 vlib_node_t *sib)
+{
+  vlib_node_main_t *nm = &vm->node_main;
+  u32 si;
+
+  clib_bitmap_foreach (si, sib->sibling_bitmap)
+    {
+      vlib_node_t *m = vec_elt (nm->nodes, si);
+
+      /* Connect all of sibling's siblings to us. */
+      m->sibling_bitmap = clib_bitmap_ori (m->sibling_bitmap, n->index);
+
+      /* Connect us to all of sibling's siblings. */
+      n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, si);
+    }
+
+  /* Connect sibling to us. */
+  sib->sibling_bitmap = clib_bitmap_ori (sib->sibling_bitmap, n->index);
+
+  /* Connect us to sibling. */
+  n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, sib->index);
+}
+
+u32
+vlib_register_node (vlib_main_t *vm, vlib_node_registration_t *r, char *fmt,
+		    ...)
 {
   vlib_node_main_t *nm = &vm->node_main;
   vlib_node_t *n;
-  u32 page_size = clib_mem_get_page_size ();
+  va_list va;
+  u32 size;
   int i;
 
   if (CLIB_DEBUG > 0)
@@ -326,22 +372,12 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 
   if (r->node_fn_registrations)
     {
-      vlib_node_fn_registration_t *fnr = r->node_fn_registrations;
-      int priority = -1;
-
       /* to avoid confusion, please remove ".function " statiement from
          CLIB_NODE_REGISTRATION() if using function function candidates */
       ASSERT (r->function == 0);
 
-      while (fnr)
-	{
-	  if (fnr->priority > priority)
-	    {
-	      priority = fnr->priority;
-	      r->function = fnr->function;
-	    }
-	  fnr = fnr->next_registration;
-	}
+      r->function =
+	vlib_node_get_preferred_node_fn_variant (vm, r->node_fn_registrations);
     }
 
   ASSERT (r->function != 0);
@@ -354,11 +390,9 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 
   vec_add1 (nm->nodes, n);
 
-  /* Name is always a vector so it can be formatted with %v. */
-  if (clib_mem_is_heap_object (vec_header (r->name, 0)))
-    n->name = vec_dup ((u8 *) r->name);
-  else
-    n->name = format (0, "%s", r->name);
+  va_start (va, fmt);
+  n->name = va_format (0, fmt, &va);
+  va_end (va);
 
   if (!nm->node_by_name)
     nm->node_by_name = hash_create_vec ( /* size */ 32,
@@ -366,7 +400,10 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 
   /* Node names must be unique. */
   {
-    vlib_node_t *o = vlib_get_node_by_name (vm, n->name);
+    /* vlib_get_node_by_name() expects NULL-terminated strings */
+    u8 *name = format (0, "%v%c", n->name, 0);
+    vlib_node_t *o = vlib_get_node_by_name (vm, name);
+    vec_free (name);
     if (o)
       clib_error ("more than one node named `%v'", n->name);
   }
@@ -378,8 +415,34 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 
   /* Node index of next sibling will be filled in by vlib_node_main_init. */
   n->sibling_of = r->sibling_of;
-  if (r->sibling_of && r->n_next_nodes > 0)
-    clib_error ("sibling node should not have any next nodes `%v'", n->name);
+  if (r->sibling_of)
+    {
+      if (r->n_next_nodes > 0)
+	clib_error ("sibling node should not have any next nodes `%v'",
+		    n->name);
+
+      if (nm->flags & VLIB_NODE_MAIN_RUNTIME_STARTED)
+	{
+	  vlib_node_t *sib;
+	  u32 slot, i;
+
+	  sib = vlib_get_node_by_name (vm, (u8 *) n->sibling_of);
+
+	  if (sib == 0)
+	    clib_error ("unknown sibling node '%s'", n->sibling_of);
+
+	  vec_foreach_index (i, sib->next_nodes)
+	    {
+	      slot = vlib_node_add_next_with_slot (vm, n->index,
+						   sib->next_nodes[i], i);
+	      ASSERT (slot == i);
+	    }
+
+	  vlib_node_add_to_sibling_bitmap (vm, n, sib);
+
+	  r->n_next_nodes = vec_len (n->next_nodes);
+	}
+    }
 
   if (r->type == VLIB_NODE_TYPE_INTERNAL)
     ASSERT (r->vector_size > 0);
@@ -389,15 +452,69 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
   _(type);
   _(flags);
   _(state);
-  _(scalar_size);
-  _(vector_size);
   _(format_buffer);
   _(unformat_buffer);
   _(format_trace);
   _(validate_frame);
 
+  size = round_pow2 (sizeof (vlib_frame_t), VLIB_FRAME_DATA_ALIGN);
+
+  /* scalar data size */
+  if (r->scalar_size)
+    {
+      n->scalar_offset = size;
+      size += round_pow2 (r->scalar_size, VLIB_FRAME_DATA_ALIGN);
+    }
+  else
+    n->scalar_offset = 0;
+
+  /* Vecor data size */
+  n->vector_offset = size;
+  size += r->vector_size * VLIB_FRAME_SIZE;
+
+  /* Allocate a few extra slots of vector data to support
+     speculative vector enqueues which overflow vector data in next frame. */
+  size += r->vector_size * VLIB_FRAME_SIZE_EXTRA;
+
+  /* space for VLIB_FRAME_MAGIC */
+  n->magic_offset = size;
+  size += sizeof (u32);
+
+  /* round size to VLIB_FRAME_DATA_ALIGN */
+  size = round_pow2 (size, VLIB_FRAME_DATA_ALIGN);
+
+  if (r->aux_size)
+    {
+      n->aux_offset = size;
+      size += r->aux_size * VLIB_FRAME_SIZE;
+    }
+  else
+    n->aux_offset = 0;
+
+  /* final size */
+  n->frame_size = size = round_pow2 (size, CLIB_CACHE_LINE_BYTES);
+  ASSERT (size <= __UINT16_MAX__);
+
+  vlib_frame_size_t *fs = 0;
+
+  n->frame_size_index = (u16) ~0;
+  vec_foreach (fs, nm->frame_sizes)
+    if (fs->frame_size == size)
+      {
+	n->frame_size_index = fs - nm->frame_sizes;
+	break;
+      }
+
+  if (n->frame_size_index == (u16) ~0)
+    {
+      vec_add2 (nm->frame_sizes, fs, 1);
+      fs->frame_size = size;
+      n->frame_size_index = fs - nm->frame_sizes;
+    }
+
   /* Register error counters. */
-  vlib_register_errors (vm, n->index, r->n_errors, r->error_strings);
+  vlib_register_errors (vm, n->index, r->n_errors, r->error_strings,
+			r->error_counters);
   node_elog_init (vm, n->index);
 
   _(runtime_data_bytes);
@@ -427,34 +544,25 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 	vlib_process_t *p;
 	uword log2_n_stack_bytes;
 
-	log2_n_stack_bytes = clib_max (r->process_log2_n_stack_bytes, 15);
-
-#ifdef CLIB_UNIX
-	/*
-	 * Bump the stack size if running over a kernel with a large page size,
-	 * and the stack isn't any too big to begin with. Otherwise, we'll
-	 * trip over the stack guard page for sure.
-	 */
-	if ((page_size > (4 << 10)) && log2_n_stack_bytes < 19)
-	  {
-	    if ((1 << log2_n_stack_bytes) <= page_size)
-	      log2_n_stack_bytes = min_log2 (page_size) + 1;
-	    else
-	      log2_n_stack_bytes++;
-	  }
-#endif
-
-	p = clib_mem_alloc_aligned_at_offset
-	  (sizeof (p[0]) + (1 << log2_n_stack_bytes),
-	   STACK_ALIGN, STRUCT_OFFSET_OF (vlib_process_t, stack),
-	   0 /* no, don't call os_out_of_memory */ );
-	if (p == 0)
-	  clib_panic ("failed to allocate process stack (%d bytes)",
-		      1 << log2_n_stack_bytes);
+	log2_n_stack_bytes = clib_max (r->process_log2_n_stack_bytes,
+				       VLIB_PROCESS_LOG2_STACK_SIZE);
+	log2_n_stack_bytes = clib_max (log2_n_stack_bytes,
+				       clib_mem_get_log2_page_size ());
 
+	p = clib_mem_alloc_aligned (sizeof (p[0]), CLIB_CACHE_LINE_BYTES);
 	clib_memset (p, 0, sizeof (p[0]));
 	p->log2_n_stack_bytes = log2_n_stack_bytes;
 
+	p->stack = clib_mem_vm_map_stack (1ULL << log2_n_stack_bytes,
+					  CLIB_MEM_PAGE_SZ_DEFAULT,
+					  "process stack: %U",
+					  format_vlib_node_name, vm,
+					  n->index);
+
+	if (p->stack == CLIB_MEM_VM_MAP_FAILED)
+	  clib_panic ("failed to allocate process stack (%d bytes)",
+		      1ULL << log2_n_stack_bytes);
+
 	/* Process node's runtime index is really index into process
 	   pointer vector. */
 	n->runtime_index = vec_len (nm->processes);
@@ -467,21 +575,17 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
 
 	/* Node runtime is stored inside of process. */
 	rt = &p->node_runtime;
-
-#ifdef CLIB_UNIX
-	/*
-	 * Disallow writes to the bottom page of the stack, to
-	 * catch stack overflows.
-	 */
-	if (mprotect (p->stack, page_size, PROT_READ) < 0)
-	  clib_unix_warning ("process stack");
-#endif
-
       }
     else
       {
 	vec_add2_aligned (nm->nodes_by_type[n->type], rt, 1,
 			  /* align */ CLIB_CACHE_LINE_BYTES);
+	if (n->type == VLIB_NODE_TYPE_INPUT)
+	  clib_interrupt_resize (&nm->input_node_interrupts,
+				 vec_len (nm->nodes_by_type[n->type]));
+	else if (n->type == VLIB_NODE_TYPE_PRE_INPUT)
+	  clib_interrupt_resize (&nm->pre_input_node_interrupts,
+				 vec_len (nm->nodes_by_type[n->type]));
 	n->runtime_index = rt - nm->nodes_by_type[n->type];
       }
 
@@ -510,16 +614,12 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
     if (vec_len (n->runtime_data) > 0)
       clib_memcpy (rt->runtime_data, n->runtime_data,
 		   vec_len (n->runtime_data));
+    else
+      clib_memset (rt->runtime_data, 0, VLIB_NODE_RUNTIME_DATA_SIZE);
 
     vec_free (n->runtime_data);
   }
-}
-
-/* Register new packet processing node. */
-u32
-vlib_register_node (vlib_main_t * vm, vlib_node_registration_t * r)
-{
-  register_node (vm, r);
+#undef _
   return r->index;
 }
 
@@ -531,14 +631,49 @@ null_node_fn (vlib_main_t * vm,
 
   vlib_node_increment_counter (vm, node->node_index, 0, n_vectors);
   vlib_buffer_free (vm, vlib_frame_vector_args (frame), n_vectors);
-  vlib_frame_free (vm, node, frame);
+  vlib_frame_free (vm, frame);
 
   return n_vectors;
 }
 
+void
+vlib_register_all_node_march_variants (vlib_main_t *vm)
+{
+  vlib_node_main_t *nm = &vm->node_main;
+  vlib_node_fn_variant_t *v;
+  int prio = -1;
+
+  nm->node_fn_default_march_variant = ~0;
+  ASSERT (nm->variants == 0);
+  vec_add2 (nm->variants, v, 1);
+  v->desc = v->suffix = "default";
+  v->index = CLIB_MARCH_VARIANT_TYPE;
+
+#define _(s, n)                                                               \
+  vec_add2 (nm->variants, v, 1);                                              \
+  v->suffix = #s;                                                             \
+  v->index = CLIB_MARCH_VARIANT_TYPE_##s;                                     \
+  v->priority = clib_cpu_march_priority_##s ();                               \
+  v->desc = n;
+
+  foreach_march_variant;
+#undef _
+
+  nm->node_fn_march_variant_by_suffix = hash_create_string (0, sizeof (u32));
+
+  vec_foreach (v, nm->variants)
+    {
+      ASSERT (v->index == v - nm->variants);
+      hash_set (nm->node_fn_march_variant_by_suffix, v->suffix, v->index);
+      if (v->priority > prio)
+	prio = v->priority;
+    }
+}
+
 void
 vlib_register_all_static_nodes (vlib_main_t * vm)
 {
+  vlib_global_main_t *vgm = vlib_get_global_main ();
   vlib_node_registration_t *r;
 
   static char *null_node_error_strings[] = {
@@ -548,19 +683,18 @@ vlib_register_all_static_nodes (vlib_main_t * vm)
   static vlib_node_registration_t null_node_reg = {
     .function = null_node_fn,
     .vector_size = sizeof (u32),
-    .name = "null-node",
     .n_errors = 1,
     .error_strings = null_node_error_strings,
   };
 
   /* make sure that node index 0 is not used by
      real node */
-  register_node (vm, &null_node_reg);
+  vlib_register_node (vm, &null_node_reg, "null-node");
 
-  r = vm->node_main.node_registrations;
+  r = vgm->node_registrations;
   while (r)
     {
-      register_node (vm, r);
+      vlib_register_node (vm, r, "%s", r->name);
       r = r->next_registration;
     }
 }
@@ -581,9 +715,9 @@ vlib_node_get_nodes (vlib_main_t * vm, u32 max_threads, int include_stats,
 
   if (vec_len (stat_vms) == 0)
     {
-      for (i = 0; i < vec_len (vlib_mains); i++)
+      for (i = 0; i < vlib_get_n_threads (); i++)
 	{
-	  stat_vm = vlib_mains[i];
+	  stat_vm = vlib_get_main_by_index (i);
 	  if (stat_vm)
 	    vec_add1 (stat_vms, stat_vm);
 	}
@@ -635,16 +769,11 @@ vlib_node_main_init (vlib_main_t * vm)
   vlib_node_t *n;
   uword ni;
 
-  nm->frame_sizes = vec_new (vlib_frame_size_t, 1);
-#ifdef VLIB_SUPPORTS_ARBITRARY_SCALAR_SIZES
-  nm->frame_size_hash = hash_create (0, sizeof (uword));
-#endif
   nm->flags |= VLIB_NODE_MAIN_RUNTIME_STARTED;
 
   /* Generate sibling relationships */
   {
     vlib_node_t *n, *sib;
-    uword si;
 
     for (ni = 0; ni < vec_len (nm->nodes); ni++)
       {
@@ -661,23 +790,7 @@ vlib_node_main_init (vlib_main_t * vm)
 	    goto done;
 	  }
 
-        /* *INDENT-OFF* */
-	clib_bitmap_foreach (si, sib->sibling_bitmap, ({
-	      vlib_node_t * m = vec_elt (nm->nodes, si);
-
-	      /* Connect all of sibling's siblings to us. */
-	      m->sibling_bitmap = clib_bitmap_ori (m->sibling_bitmap, n->index);
-
-	      /* Connect us to all of sibling's siblings. */
-	      n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, si);
-	    }));
-        /* *INDENT-ON* */
-
-	/* Connect sibling to us. */
-	sib->sibling_bitmap = clib_bitmap_ori (sib->sibling_bitmap, n->index);
-
-	/* Connect us to sibling. */
-	n->sibling_bitmap = clib_bitmap_ori (n->sibling_bitmap, sib->index);
+	vlib_node_add_to_sibling_bitmap (vm, n, sib);
       }
   }
 
@@ -766,14 +879,13 @@ vlib_process_create (vlib_main_t * vm, char *name,
 
   memset (&r, 0, sizeof (r));
 
-  r.name = (char *) format (0, "%s", name, 0);
   r.function = f;
   r.process_log2_n_stack_bytes = log2_n_stack_bytes;
   r.type = VLIB_NODE_TYPE_PROCESS;
 
   vlib_worker_thread_barrier_sync (vm);
 
-  vlib_register_node (vm, &r);
+  vlib_register_node (vm, &r, "%s", name);
   vec_free (r.name);
 
   vlib_worker_thread_node_runtime_update ();
@@ -785,6 +897,39 @@ vlib_process_create (vlib_main_t * vm, char *name,
   return (r.index);
 }
 
+int
+vlib_node_set_march_variant (vlib_main_t *vm, u32 node_index,
+			     clib_march_variant_type_t march_variant)
+{
+  vlib_node_fn_registration_t *fnr;
+  vlib_node_fn_variant_t *v;
+  vlib_node_t *n = vlib_get_node (vm, node_index);
+
+  if (n->node_fn_registrations == 0)
+    return -1;
+
+  fnr = n->node_fn_registrations;
+  v = vec_elt_at_index (vm->node_main.variants, march_variant);
+
+  while (fnr)
+    {
+      if (fnr->march_variant == v->index)
+	{
+	  n->function = fnr->function;
+
+	  for (int i = 0; i < vlib_get_n_threads (); i++)
+	    {
+	      vlib_node_runtime_t *nrt;
+	      nrt =
+		vlib_node_get_runtime (vlib_get_main_by_index (i), n->index);
+	      nrt->function = fnr->function;
+	    }
+	  return 0;
+	}
+      fnr = fnr->next_registration;
+    }
+  return -1;
+}
 /*
  * fd.io coding-style-patch-verification: ON
  *