aboutsummaryrefslogtreecommitdiff
path: root/sys/sys/tim_filter.h
diff options
context:
space:
mode:
authorRandall Stewart <rrs@FreeBSD.org>2019-09-24 18:18:11 +0000
committerRandall Stewart <rrs@FreeBSD.org>2019-09-24 18:18:11 +0000
commit35c7bb340788f0ce9347b7066619d8afb31e2123 (patch)
tree86d8e5b0cf3413e884c83015ec43bfc66f071641 /sys/sys/tim_filter.h
parent749597dc1d21dce46fb94bfbe34cdb20ec1d9ab3 (diff)
downloadsrc-35c7bb340788f0ce9347b7066619d8afb31e2123.tar.gz
src-35c7bb340788f0ce9347b7066619d8afb31e2123.zip
This commit adds BBR (Bottleneck Bandwidth and RTT) congestion control. This
is a completely separate TCP stack (tcp_bbr.ko) that will be built only if you add the make options WITH_EXTRA_TCP_STACKS=1 and also include the option TCPHPTS. You can also include the RATELIMIT option if you have a NIC interface that supports hardware pacing, BBR understands how to use such a feature. Note that this commit also adds in a general purpose time-filter which allows you to have a min-filter or max-filter. A filter allows you to have a low (or high) value for some period of time and degrade slowly to another value has time passes. You can find out the details of BBR by looking at the original paper at: https://queue.acm.org/detail.cfm?id=3022184 or consult many other web resources you can find on the web referenced by "BBR congestion control". It should be noted that BBRv1 (which this is) does tend to unfairness in cases of small buffered paths, and it will usually get less bandwidth in the case of large BDP paths(when competing with new-reno or cubic flows). BBR is still an active research area and we do plan on implementing V2 of BBR to see if it is an improvement over V1. Sponsored by: Netflix Inc. Differential Revision: https://reviews.freebsd.org/D21582
Notes
Notes: svn path=/head/; revision=352657
Diffstat (limited to 'sys/sys/tim_filter.h')
-rw-r--r--sys/sys/tim_filter.h134
1 files changed, 134 insertions, 0 deletions
diff --git a/sys/sys/tim_filter.h b/sys/sys/tim_filter.h
new file mode 100644
index 000000000000..a131a5d251b1
--- /dev/null
+++ b/sys/sys/tim_filter.h
@@ -0,0 +1,134 @@
+#ifndef __tim_filter_h__
+#define __tim_filter_h__
+/*-
+ * Copyright (c) 2016-9 Netflix, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+/*
+ * Author: Randall Stewart <rrs@netflix.com>
+ */
+
+#include <sys/types.h>
+#include <machine/param.h>
+/*
+ * Do not change the size unless you know what you are
+ * doing, the current size of 5 is designed around
+ * the cache-line size for an amd64 processor. Other processors
+ * may need other sizes.
+ */
+#define NUM_FILTER_ENTRIES 3
+
+struct filter_entry {
+ uint64_t value; /* Value */
+ uint32_t time_up; /* Time updated */
+} __packed ;
+
+struct filter_entry_small {
+ uint32_t value; /* Value */
+ uint32_t time_up; /* Time updated */
+};
+
+struct time_filter {
+ uint32_t cur_time_limit;
+ struct filter_entry entries[NUM_FILTER_ENTRIES];
+#ifdef _KERNEL
+} __aligned(CACHE_LINE_SIZE);
+#else
+};
+#endif
+struct time_filter_small {
+ uint32_t cur_time_limit;
+ struct filter_entry_small entries[NUM_FILTER_ENTRIES];
+};
+
+/*
+ * To conserve on space there is a code duplication here (this
+ * is where polymophism would be nice in the kernel). Everything
+ * is duplicated to have a filter with a value of uint32_t instead
+ * of a uint64_t. This saves 20 bytes and the structure size
+ * drops to 44 from 64. The bad part about this is you end
+ * up with two sets of functions. The xxx_small() access
+ * the uint32_t value's where the xxx() the uint64_t values.
+ * This forces the user to keep straight which type of structure
+ * they allocated and which call they need to make. crossing
+ * over calls will create either invalid memory references or
+ * very bad results :)
+ */
+
+#define FILTER_TYPE_MIN 1
+#define FILTER_TYPE_MAX 2
+
+#ifdef _KERNEL
+int setup_time_filter(struct time_filter *tf, int fil_type, uint32_t time_len);
+void reset_time(struct time_filter *tf, uint32_t time_len);
+void forward_filter_clock(struct time_filter *tf, uint32_t ticks_forward);
+void tick_filter_clock(struct time_filter *tf, uint32_t now);
+uint32_t apply_filter_min(struct time_filter *tf, uint64_t value, uint32_t now);
+uint32_t apply_filter_max(struct time_filter *tf, uint64_t value, uint32_t now);
+void filter_reduce_by(struct time_filter *tf, uint64_t reduce_by, uint32_t now);
+void filter_increase_by(struct time_filter *tf, uint64_t incr_by, uint32_t now);
+static uint64_t inline
+get_filter_value(struct time_filter *tf)
+{
+ return(tf->entries[0].value);
+}
+
+static uint32_t inline
+get_cur_timelim(struct time_filter *tf)
+{
+ return(tf->cur_time_limit);
+}
+
+
+int setup_time_filter_small(struct time_filter_small *tf,
+ int fil_type, uint32_t time_len);
+void reset_time_small(struct time_filter_small *tf, uint32_t time_len);
+void forward_filter_clock_small(struct time_filter_small *tf,
+ uint32_t ticks_forward);
+void tick_filter_clock_small(struct time_filter_small *tf, uint32_t now);
+uint32_t apply_filter_min_small(struct time_filter_small *tf,
+ uint32_t value, uint32_t now);
+uint32_t apply_filter_max_small(struct time_filter_small *tf,
+ uint32_t value, uint32_t now);
+void filter_reduce_by_small(struct time_filter_small *tf,
+ uint32_t reduce_by, uint32_t now);
+void filter_increase_by_small(struct time_filter_small *tf,
+ uint32_t incr_by, uint32_t now);
+static uint64_t inline
+get_filter_value_small(struct time_filter_small *tf)
+{
+ return(tf->entries[0].value);
+}
+
+static uint32_t inline
+get_cur_timelim_small(struct time_filter_small *tf)
+{
+ return(tf->cur_time_limit);
+}
+
+
+#endif
+#endif