nat: pnat only use save_rewrite_length on output path

[vpp.git] / src / vlib / main.c

diff --git a/src/vlib/main.c b/src/vlib/main.c
index 6369f39..761d4ee 100644 (file)
--- a/src/vlib/main.c
+++ b/src/vlib/main.c
@@ -122,6 +122,8 @@ vlib_frame_alloc_to_node (vlib_main_t * vm, u32 to_node_index,
   vlib_frame_t *f;
   u32 l, n, scalar_size, vector_size;
 
+  ASSERT (vm == vlib_get_main ());
+
   to_node = vlib_get_node (vm, to_node_index);
 
   scalar_size = to_node->scalar_size;
@@ -221,6 +223,8 @@ vlib_put_frame_to_node (vlib_main_t * vm, u32 to_node_index, vlib_frame_t * f)
   if (f->n_vectors == 0)
     return;
 
+  ASSERT (vm == vlib_get_main ());
+
   vlib_validate_frame_indices (f);
 
   to_node = vlib_get_node (vm, to_node_index);
@@ -241,6 +245,7 @@ vlib_frame_free (vlib_main_t * vm, vlib_node_runtime_t * r, vlib_frame_t * f)
   vlib_node_t *node;
   vlib_frame_size_t *fs;
 
+  ASSERT (vm == vlib_get_main ());
   ASSERT (f->frame_flags & VLIB_FRAME_IS_ALLOCATED);
 
   node = vlib_get_node (vm, r->node_index);
@@ -1708,27 +1713,6 @@ vl_api_send_pending_rpc_requests (vlib_main_t * vm)
 {
 }
 
-static_always_inline u64
-dispatch_pending_interrupts (vlib_main_t * vm, vlib_node_main_t * nm,
-                            u64 cpu_time_now,
-                            vlib_node_interrupt_t * interrupts)
-{
-  vlib_node_runtime_t *n;
-
-  for (int i = 0; i < _vec_len (interrupts); i++)
-    {
-      vlib_node_interrupt_t *in;
-      in = vec_elt_at_index (interrupts, i);
-      n = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INPUT],
-                           in->node_runtime_index);
-      n->interrupt_data = in->data;
-      cpu_time_now = dispatch_node (vm, n, VLIB_NODE_TYPE_INPUT,
-                                   VLIB_NODE_STATE_INTERRUPT, /* frame */ 0,
-                                   cpu_time_now);
-    }
-  return cpu_time_now;
-}
-
 static inline void
 pcap_postmortem_reset (vlib_main_t * vm)
 {
@@ -1752,7 +1736,6 @@ vlib_main_or_worker_loop (vlib_main_t * vm, int is_main)
   f64 now;
   vlib_frame_queue_main_t *fqm;
   u32 frame_queue_check_counter = 0;
-  vlib_node_interrupt_t *empty_int_list = 0;
 
   /* Initialize pending node vector. */
   if (is_main)
@@ -1771,12 +1754,7 @@ vlib_main_or_worker_loop (vlib_main_t * vm, int is_main)
     cpu_time_now = clib_cpu_time_now ();
 
   /* Pre-allocate interupt runtime indices and lock. */
-  vec_alloc (nm->pending_local_interrupts, 32);
-  vec_alloc (nm->pending_remote_interrupts, 32);
-  vec_alloc (empty_int_list, 32);
-  vec_alloc_aligned (nm->pending_remote_interrupts_notify, 1,
-                    CLIB_CACHE_LINE_BYTES);
-  clib_spinlock_init (&nm->pending_interrupt_lock);
+  vec_alloc_aligned (nm->pending_interrupts, 1, CLIB_CACHE_LINE_BYTES);
 
   /* Pre-allocate expired nodes. */
   if (!nm->polling_threshold_vector_length)
@@ -1874,35 +1852,22 @@ vlib_main_or_worker_loop (vlib_main_t * vm, int is_main)
       if (PREDICT_TRUE (is_main && vm->queue_signal_pending == 0))
        vm->queue_signal_callback (vm);
 
-      /* handle local interruots */
-      if (_vec_len (nm->pending_local_interrupts))
+      if (__atomic_load_n (nm->pending_interrupts, __ATOMIC_ACQUIRE))
        {
-         vlib_node_interrupt_t *interrupts = nm->pending_local_interrupts;
-         nm->pending_local_interrupts = empty_int_list;
-         cpu_time_now = dispatch_pending_interrupts (vm, nm, cpu_time_now,
-                                                     interrupts);
-         empty_int_list = interrupts;
-         vec_reset_length (empty_int_list);
-       }
+         int int_num = -1;
+         *nm->pending_interrupts = 0;
 
-      /* handle remote interruots */
-      if (PREDICT_FALSE (_vec_len (nm->pending_remote_interrupts)))
-       {
-         vlib_node_interrupt_t *interrupts;
-
-         /* at this point it is known that
-          * vec_len (nm->pending_local_interrupts) is zero so we quickly swap
-          * local and remote vector under the spinlock */
-         clib_spinlock_lock (&nm->pending_interrupt_lock);
-         interrupts = nm->pending_remote_interrupts;
-         nm->pending_remote_interrupts = empty_int_list;
-         *nm->pending_remote_interrupts_notify = 0;
-         clib_spinlock_unlock (&nm->pending_interrupt_lock);
-
-         cpu_time_now = dispatch_pending_interrupts (vm, nm, cpu_time_now,
-                                                     interrupts);
-         empty_int_list = interrupts;
-         vec_reset_length (empty_int_list);
+         while ((int_num =
+                   clib_interrupt_get_next (nm->interrupts, int_num)) != -1)
+           {
+             vlib_node_runtime_t *n;
+             clib_interrupt_clear (nm->interrupts, int_num);
+             n = vec_elt_at_index (nm->nodes_by_type[VLIB_NODE_TYPE_INPUT],
+                                   int_num);
+             cpu_time_now = dispatch_node (vm, n, VLIB_NODE_TYPE_INPUT,
+                                           VLIB_NODE_STATE_INTERRUPT,
+                                           /* frame */ 0, cpu_time_now);
+           }
        }
 
       /* Input nodes may have added work to the pending vector.
@@ -2286,6 +2251,7 @@ vlib_main (vlib_main_t * volatile vm, unformat_input_t * input)
   vlib_main_loop (vm);
 
 done:
+  vlib_worker_thread_barrier_sync (vm);
   /* Call all exit functions. */
   {
     clib_error_t *sub_error;
@@ -2293,6 +2259,7 @@ done:
     if (sub_error)
       clib_error_report (sub_error);
   }
+  vlib_worker_thread_barrier_release (vm);
 
   if (error)
     clib_error_report (error);