WIP: windowed filtered rework+comments (TO BE MERGED)

Author: haproxyFred

include/haproxy/window_filter.h

@@ -1,95 +1,102 @@
 #ifndef _HAPROXY_WINDOW_FILTER_H
 #define _HAPROXY_WINDOW_FILTER_H
 
-/* Window filter sample */
+/* Kathleen Nichols' algorithm to track the maximum value of a data type during
+ * a fixed time interval. This algorithm makes usage of three samples to track
+ * the best, second best and third best values with 1st >= 2nd >= 3rd as
+ * invariant.
+ *
+ * This code is used in Linux kernel in linux/win_minmax.c to track both
+ * minimal and maximum values.
+ *
+ * Here the code has been adapted to track 64bits values and only their
+ * maximum.
+ *
+ * Note that these windowed filters are used by BBR to filter the maximum
+ * estimated bandwidth with counters as time values. A length has been
+ * added to simulate the fixed time interval with counter which are
+ * monotonically increasing.
+ */
+
+/* Windowed filter sample */
 struct wf_smp {
 	uint64_t v;
 	uint32_t t;
 };
 
-/* Window filter */
+/* Windowed filter */
 struct wf {
 	size_t len;
 	struct wf_smp smp[3];
 };
 
-static inline void wf_init(struct wf *wf, size_t len)
-{
-	wf->len = len;
-	memset(wf->smp, 0xff, sizeof(wf->smp));
-}
-
-static inline void wf_reset(struct wf *wf, uint64_t v, uint32_t t)
+/* Reset all the <wf> windowed filter samples with <v> and <t> as value and
+ * time value respectively.
+ */
+static inline uint64_t wf_reset(struct wf *wf, uint64_t v, uint32_t t)
 {
 	struct wf_smp smp = { .v = v, .t = t };
 
 	wf->smp[2] = wf->smp[1] = wf->smp[0] = smp;
+
+	return wf->smp[0].v;
+}
+
+/* Initialize <wf> windowed filter to track maximum values, with <len> as
+ * length and <v> and <t> as value and time value respectively.
+ */
+static inline void wf_init(struct wf *wf, size_t len, uint64_t v, uint32_t t)
+{
+	wf->len = len;
+	wf_reset(wf, v, t);
 }
 
-/* Updates best estimates with |v| sample value, and expires and updates best
- * estimates as necessary.
- * Similar to minmax_subwin_update() linux kernel function (see lib/win_minmax.c
- * function).
+/* Similar to minmax_running_max() Linux kernel function to update the best
+ * estimation of <wf> windowed filted with <v> and <t> as value and time value
+ * respectively
  */
-static inline void wf_update(struct wf *wf, uint64_t v, uint32_t t)
+static inline uint64_t wf_max_update(struct wf *wf, uint64_t v, uint32_t t)
 {
+	uint64_t delta_t;
+	struct wf_smp smp = { .v = v, .t = t };
+
 	/* Reset all estimates if they have not yet been initialized, if new
 	   sample is a new best, or if the newest recorded estimate is too
 	   old. */
-	if (wf->smp[0].v == UINT64_MAX || v > wf->smp[0].v || t - wf->smp[2].t > wf->len) {
-		wf_reset(wf, v, t);
-		return;
-	}
+	if (unlikely(v > wf->smp[0].v) || unlikely(t - wf->smp[2].t > wf->len))
+		return wf_reset(wf, v, t);
 
-	if (v > wf->smp[1].v) {
-		wf->smp[1].v = v;
-		wf->smp[1].t = t;
-		wf->smp[2] = wf->smp[1];
-	} else if (v > wf->smp[2].v) {
-		wf->smp[2].v = v;
-		wf->smp[2].t = t;
-	}
+	if (unlikely(v > wf->smp[1].v))
+		wf->smp[2] = wf->smp[1] = smp;
+	else if (unlikely(v > wf->smp[2].v))
+		wf->smp[2] = smp;
 
-	/* Expire and update smp as necessary. */
-	if (t - wf->smp[0].t > wf->len) {
-		/* The best estimate hasn't been updated for an entire window, so
-		   promote second and third best smp. */
+	delta_t = t - wf->smp[0].t;
+	/* From here, similar to minmax_subwin_update() from Linux kernel. */
+	if (unlikely(delta_t > wf->len)) {
 		wf->smp[0] = wf->smp[1];
 		wf->smp[1] = wf->smp[2];
 		wf->smp[2].v = v;
 		wf->smp[2].t = t;
 
-		/* Need to iterate one more time.  Check if the new best estimate
-		   is outside the window as well, since it may also have been
-		   recorded a long time ago.  Don't need to iterate once more
-		   since we cover that case at the beginning of the method. */
-		if (t - wf->smp[0].t > wf->len) {
+		if (unlikely(t - wf->smp[0].t > wf->len)) {
 			wf->smp[0] = wf->smp[1];
 			wf->smp[1] = wf->smp[2];
 		}
-		return;
-	}
-
-	if (wf->smp[1].v == wf->smp[0].v && t - wf->smp[1].t > wf->len >> 2) {
-		/* A quarter of the window has passed without a better sample, so
-		   the second-best estimate is taken from the second quarter of
-		   the window. */
+	} else if (unlikely(wf->smp[1].v == wf->smp[0].v) && delta_t > wf->len / 4) {
 		wf->smp[2].v = v;
 		wf->smp[2].t = t;
 		wf->smp[1] = wf->smp[2];
-		return;
-	}
-
-	if (wf->smp[2].v == wf->smp[1].v && t - wf->smp[2].t > wf->len >> 1) {
-		/* We've passed a half of the window without a better estimate, so
-		   take a third-best estimate from the second half of the
-		   window. */
+	} else if (unlikely(wf->smp[2].v == wf->smp[1].v) && delta_t > wf->len / 2) {
 		wf->smp[2].v = v;
 		wf->smp[2].t = t;
 	}
+
+	return wf->smp[0].v;
 }
 
-static inline uint64_t wf_get_best(struct wf *wf)
+/* Return <wf> windowed filter best maximum estimation. */
+static inline uint64_t wf_get_max(struct wf *wf)
 {
 	return wf->smp[0].v;
 }