misc: remove GNU Indent directives

[vpp.git] / src / vppinfra / timing_wheel.c

diff --git a/src/vppinfra/timing_wheel.c b/src/vppinfra/timing_wheel.c
index 4c8a2c5..830888a 100644 (file)
--- a/src/vppinfra/timing_wheel.c
+++ b/src/vppinfra/timing_wheel.c
@@ -184,8 +184,8 @@ free_elt_vector (timing_wheel_t * w, timing_wheel_elt_t * ev)
 {
   /* Poison free elements so we never use them by mistake. */
   if (CLIB_DEBUG > 0)
-    memset (ev, ~0, vec_len (ev) * sizeof (ev[0]));
-  _vec_len (ev) = 0;
+    clib_memset (ev, ~0, vec_len (ev) * sizeof (ev[0]));
+  vec_set_len (ev, 0);
   vec_add1 (w->free_elt_vectors, ev);
 }
 
@@ -239,6 +239,8 @@ timing_wheel_insert_helper (timing_wheel_t * w, u64 insert_cpu_time,
       e = insert_helper (w, level_index, rtime);
       e->user_data = user_data;
       e->cpu_time_relative_to_base = dt;
+      if (insert_cpu_time < w->cached_min_cpu_time_on_wheel)
+       w->cached_min_cpu_time_on_wheel = insert_cpu_time;
     }
   else
     {
@@ -300,23 +302,19 @@ timing_wheel_insert (timing_wheel_t * w, u64 insert_cpu_time, u32 user_data)
       /* Delete elts with given user data so that stale events don't expire. */
       vec_foreach (l, w->levels)
       {
-         /* *INDENT-OFF* */
-         clib_bitmap_foreach (wi, l->occupancy_bitmap, ({
+         clib_bitmap_foreach (wi, l->occupancy_bitmap)  {
            l->elts[wi] = delete_user_data (l->elts[wi], user_data);
            if (vec_len (l->elts[wi]) == 0)
              l->occupancy_bitmap = clib_bitmap_andnoti (l->occupancy_bitmap, wi);
-         }));
-         /* *INDENT-ON* */
+         }
       }
 
       {
        timing_wheel_overflow_elt_t *oe;
-       /* *INDENT-OFF* */
-       pool_foreach (oe, w->overflow_pool, ({
+       pool_foreach (oe, w->overflow_pool)  {
          if (oe->user_data == user_data)
            pool_put (w->overflow_pool, oe);
-       }));
-       /* *INDENT-ON* */
+       }
       }
 
       hash_unset (w->deleted_user_data_hash, user_data);
@@ -395,10 +393,8 @@ timing_wheel_next_expiring_elt_time (timing_wheel_t * w)
     if (min_dt != ~0)
       min_t = w->cpu_time_base + min_dt;
 
-    /* *INDENT-OFF* */
-    pool_foreach (oe, w->overflow_pool,
-                 ({ min_t = clib_min (min_t, oe->cpu_time); }));
-    /* *INDENT-ON* */
+    pool_foreach (oe, w->overflow_pool)
+                  { min_t = clib_min (min_t, oe->cpu_time); }
 
   done:
     return min_t;
@@ -457,7 +453,7 @@ expire_bin (timing_wheel_t * w,
 
   /* Adjust for deleted elts. */
   if (j < e_len)
-    _vec_len (expired_user_data) -= e_len - j;
+    vec_dec_len (expired_user_data, e_len - j);
 
   free_elt_vector (w, e);
 
@@ -483,32 +479,31 @@ advance_cpu_time_base (timing_wheel_t * w, u32 * expired_user_data)
   vec_foreach (l, w->levels)
   {
     uword wi;
-      /* *INDENT-OFF* */
-      clib_bitmap_foreach (wi, l->occupancy_bitmap, ({
+      clib_bitmap_foreach (wi, l->occupancy_bitmap)  {
        vec_foreach (e, l->elts[wi])
          {
            /* This should always be true since otherwise we would have already expired
-              this element. */
+              this element. Note that in the second half of this function we need
+               to take care not to place the expired elements ourselves. */
            ASSERT (e->cpu_time_relative_to_base >= delta);
            e->cpu_time_relative_to_base -= delta;
          }
-      }));
-      /* *INDENT-ON* */
+      }
   }
 
   /* See which overflow elements fit now. */
   {
     timing_wheel_overflow_elt_t *oe;
-    /* *INDENT-OFF* */
-    pool_foreach (oe, w->overflow_pool, ({
+    pool_foreach (oe, w->overflow_pool)  {
       /* It fits now into 32 bits. */
       if (0 == ((oe->cpu_time - w->cpu_time_base) >> BITS (e->cpu_time_relative_to_base)))
        {
          u64 ti = oe->cpu_time >> w->log2_clocks_per_bin;
-         if (ti < w->current_time_index)
+         if (ti <= w->current_time_index)
            {
              /* This can happen when timing wheel is not advanced for a long time
                 (for example when at a gdb breakpoint for a while). */
+              /* Note: the ti == w->current_time_index means it is also an expired timer */
              if (! elt_is_deleted (w, oe->user_data))
                vec_add1 (expired_user_data, oe->user_data);
            }
@@ -516,8 +511,7 @@ advance_cpu_time_base (timing_wheel_t * w, u32 * expired_user_data)
            timing_wheel_insert_helper (w, oe->cpu_time, oe->user_data);
          pool_put (w->overflow_pool, oe);
        }
-    }));
-    /* *INDENT-ON* */
+    }
   }
   return expired_user_data;
 }
@@ -609,7 +603,7 @@ timing_wheel_advance (timing_wheel_t * w, u64 advance_cpu_time,
     if (PREDICT_FALSE (current_ti != advance_ti))
       {
        if (w->unexpired_elts_pending_insert)
-         _vec_len (w->unexpired_elts_pending_insert) = 0;
+         vec_set_len (w->unexpired_elts_pending_insert, 0);
 
        level_index = 0;
        while (current_ti != advance_ti)
@@ -643,12 +637,10 @@ timing_wheel_advance (timing_wheel_t * w, u64 advance_cpu_time,
        break;
 
       level = vec_elt_at_index (w->levels, level_index);
-      /* *INDENT-OFF* */
-      clib_bitmap_foreach (wi, level->occupancy_bitmap, ({
+      clib_bitmap_foreach (wi, level->occupancy_bitmap)  {
         expired_user_data = expire_bin (w, level_index, wi, advance_cpu_time,
                                        expired_user_data);
-      }));
-      /* *INDENT-ON* */
+      }
     }
 
   if (PREDICT_TRUE (level_index < vec_len (w->levels)))
@@ -664,6 +656,8 @@ timing_wheel_advance (timing_wheel_t * w, u64 advance_cpu_time,
                expire_bin (w, advance_level_index, wi, advance_cpu_time,
                            expired_user_data);
 
+           /* When we jump out, we have already just expired the bin,
+              corresponding to advance_wheel_index */
            if (wi == advance_wheel_index)
              break;
 
@@ -678,10 +672,13 @@ timing_wheel_advance (timing_wheel_t * w, u64 advance_cpu_time,
     {
       timing_wheel_elt_t *e;
       vec_foreach (e, w->unexpired_elts_pending_insert) insert_elt (w, e);
-      _vec_len (w->unexpired_elts_pending_insert) = 0;
+      vec_set_len (w->unexpired_elts_pending_insert, 0);
     }
 
   /* Don't advance until necessary. */
+  /* However, if the timing_wheel_advance() hasn't been called for some time,
+     the while() loop will ensure multiple calls to advance_cpu_time_base()
+     in a row until the w->cpu_time_base is fresh enough. */
   while (PREDICT_FALSE
         (advance_time_index >= w->time_index_next_cpu_time_base_update))
     expired_user_data = advance_cpu_time_base (w, expired_user_data);
@@ -711,7 +708,7 @@ format_timing_wheel (u8 * s, va_list * va)
 {
   timing_wheel_t *w = va_arg (*va, timing_wheel_t *);
   int verbose = va_arg (*va, int);
-  uword indent = format_get_indent (s);
+  u32 indent = format_get_indent (s);
 
   s = format (s, "level 0: %.4e - %.4e secs, 2^%d - 2^%d clocks",
              (f64) (1 << w->log2_clocks_per_bin) / w->cpu_clocks_per_second,