Provide counter_ratecheck(), a MP-friendly substitution to ppsratecheck().

When rated event happens at a very quick rate, the ppsratecheck() is not
only racy, but also becomes a performance bottleneck.

Together with:	rrs, jtl

diff --git a/share/man/man9/counter.9 b/share/man/man9/counter.9
index 1ea1bdc343564470d4c46c238cafa90eb719f563..234e41436df856b2d9233a02db7eb608d07cfc46 100644 (file)
--- a/share/man/man9/counter.9
+++ b/share/man/man9/counter.9
@@ -25,7 +25,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd March 14, 2016
+.Dd December 8, 2016
 .Dt COUNTER 9
 .Os
 .Sh NAME
@@ -51,6 +51,8 @@
 .Fn counter_u64_fetch "counter_u64_t c"
 .Ft void
 .Fn counter_u64_zero "counter_u64_t c"
+.Ft int64_t
+.Fn counter_ratecheck "struct counter_rate *cr" "int64_t limit"
 .In sys/sysctl.h
 .Fn SYSCTL_COUNTER_U64 parent nbr name access ptr descr
 .Fn SYSCTL_ADD_COUNTER_U64 ctx parent nbr name access ptr descr
@@ -128,6 +130,18 @@ value for any moment.
 Clear the counter
 .Fa c
 and set it to zero.
+.It Fn counter_ratecheck cr limit
+The function is a multiprocessor-friendly version of
+.Fn ppsratecheck ,
+which uses
+.Nm
+internally.
+Returns non-negative value if the rate isn't yet reached during the current
+second, and a negative value otherwise.
+If the limit was reached on previous second, but was just reset back to zero,
+then
+.Fn counter_ratecheck
+returns number of events since previous reset.
 .It Fn SYSCTL_COUNTER_U64 parent nbr name access ptr descr
 Declare a static
 .Xr sysctl

diff --git a/sys/kern/subr_counter.c b/sys/kern/subr_counter.c
index 5149f2d2a37d872e81b2a1cc0901e376358a2931..f27a46ab94fddadd24e32410f41de3145869bc9b 100644 (file)
--- a/sys/kern/subr_counter.c
+++ b/sys/kern/subr_counter.c
@@ -119,3 +119,57 @@ sysctl_handle_counter_u64_array(SYSCTL_HANDLER_ARGS)
  
        return (0);
 }
+
+/*
+ * MP-friendly version of ppsratecheck().
+ *
+ * Returns non-negative if we are in the rate, negative otherwise.
+ *  0 - rate limit not reached.
+ * -1 - rate limit reached.
+ * >0 - rate limit was reached before, and was just reset. The return value
+ *      is number of events since last reset.
+ */
+int64_t
+counter_ratecheck(struct counter_rate *cr, int64_t limit)
+{
+       int64_t val;
+       int now;
+
+       val = cr->cr_over;
+       now = ticks;
+
+       if (now - cr->cr_ticks >= hz) {
+               /*
+                * Time to clear the structure, we are in the next second.
+                * First try unlocked read, and then proceed with atomic.
+                */
+               if ((cr->cr_lock == 0) &&
+                   atomic_cmpset_int(&cr->cr_lock, 0, 1)) {
+                       /*
+                        * Check if other thread has just went through the
+                        * reset sequence before us.
+                        */
+                       if (now - cr->cr_ticks >= hz) {
+                               val = counter_u64_fetch(cr->cr_rate);
+                               counter_u64_zero(cr->cr_rate);
+                               cr->cr_over = 0;
+                               cr->cr_ticks = now;
+                       }
+                       atomic_store_rel_int(&cr->cr_lock, 0);
+               } else
+                       /*
+                        * We failed to lock, in this case other thread may
+                        * be running counter_u64_zero(), so it is not safe
+                        * to do an update, we skip it.
+                        */
+                       return (val);
+       }
+
+       counter_u64_add(cr->cr_rate, 1);
+       if (cr->cr_over != 0)
+               return (-1);
+       if (counter_u64_fetch(cr->cr_rate) > limit)
+               val = cr->cr_over = -1;
+
+       return (val);
+}

diff --git a/sys/sys/counter.h b/sys/sys/counter.h
index 2ce7134176f2625251c3e40e0a20b81b1b8d8399..5046d41d5f3abf524ddb96a18675c5161423ec9f 100644 (file)
--- a/sys/sys/counter.h
+++ b/sys/sys/counter.h
@@ -59,5 +59,18 @@ uint64_t     counter_u64_fetch(counter_u64_t);
        for (int i = 0; i < (n); i++)                           \
                counter_u64_zero((a)[i]);                       \
 } while (0)
+
+/*
+ * counter(9) based rate checking.
+ */
+struct counter_rate {
+       counter_u64_t   cr_rate;        /* Events since last second */
+       volatile int    cr_lock;        /* Lock to clean the struct */
+       int             cr_ticks;       /* Ticks on last clean */
+       int             cr_over;        /* Over limit since cr_ticks? */
+};
+
+int64_t        counter_ratecheck(struct counter_rate *, int64_t);
+
 #endif /* _KERNEL */
 #endif /* ! __SYS_COUNTER_H__ */