Improves minimum RTT probing, adds packet pacing and refactors the code.

Make formatting linux conform

See merge request lukas.prause/tcp-roccet-kernel-module!1

LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 2025  Lukas Prause
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

README.md

@@ -1,35 +1,49 @@
 # TCP ROCCET :rocket: (RTT Oriented CUBIC Congestion control ExTension)
 
-TCP ROCCET is a new TCP congestion control
+TCP ROCCET is a new TCP congestion control algorithm that reduces latency by detecting queuing.
-algorithm suited for current cellular 5G NR beyond networks.
+Additionally, it is specially suited for 4G/5G cellular networks.
-It extends the kernel default congestion control CUBIC
-and improves its performance, and additionally solves
-unwanted side effects of CUBIC’s implementation.
-ROCCET uses its own Slow Start, called LAUNCH, where loss
-is not considered as a congestion event.
-The congestion avoidance phase, called ORBITER, uses 
-CUBIC's window growth function and adds, based on RTT
-and ACK rate, congestion events.
 
-NOTE: A paper for TCP ROCCET is currently under review.
+A peer-reviewed [paper on TCP ROCCET](https://opendl.ifip-tc6.org/db/conf/wons/wons2026/1571217211.pdf) was presented at the WONS 2026 conference.
-Paper draft:
-            https://arxiv.org/abs/2510.25281
 
-The oldest Linux kernel version we tested with ROCCET is 6.1.
+## Install with apt
+Add tcp-roccet-dkms to your source lists and install:
+```
+echo "deb [trusted=yes] https://apt.fury.io/timfuchs/ /" | sudo tee /etc/apt/sources.list.d/tcp-roccet.list
+sudo apt update
+sudo apt install tcp-roccet-dkms
+```
 
-## Setup
+### Loading and using the congestion control
+Note: This change is not persistent, the module will not be loaded at boot.
+```
+sudo modprobe tcp_roccet
+sudo sysctl net.ipv4.tcp_congestion_control=roccet
+```
+### Versions
 
+- latest on master branch
+    - Improved min RTT probing
+    - Packet pacing
+    - Code refactor
+
+- release-2026-06-12-v1
+    - Adds minimum RTT probing
+
+## Build from source
+
+### Setup
+Kernel headers are required:
 * Debian: `sudo apt install linux-headers-generic`
 * Fedora: `sudo dnf install kernel-devel`
 (`sudo reboot`)
 
-## Build 
+### Build 
 `make`
 
 
 ## Loading & Unloading the Module  
 **1.** Insert into Kernel: `sudo insmod tcp_roccet.ko`
-In case you get the "Invalid module Format" error, it can help reinstalling the kernel-headers.
+In case you get the "Invalid module Format" error, it can help to reinstall the kernel-headers.
 
 **2.** Use the Algorithm:
 * Either via globally loading it: `sudo sysctl net.ipv4.tcp_congestion_control=roccet`
@@ -39,12 +53,12 @@ In case you get the "Invalid module Format" error, it can help reinstalling the
 
 
 ## Debugging (Using kprobe)
-In order to debug the `tcp_roccet` congestion control algorithm, there exists a Kprobe module (`roccet_kprobe.c`). Using this it is possible to inspect events generated by the algorithm. 
+In order to debug the `tcp_roccet` congestion control algorithm, there exists a Kprobe module (`roccet_kprobe.c`). Using this, it is possible to inspect events generated by the algorithm. 
 
-In order to use the Kprobe module the following steps are necessary: 
+In order to use the Kprobe module, the following steps are necessary: 
 
 **1. Specify the event to inspect**
-For this head into the `tcp_roccet.c` source code and find the function the Kprobe should attach to. 
+For this, head into the `tcp_roccet.c` source code and find the function the Kprobe should attach to. 
 
 For Example: 
 ```
@@ -69,7 +83,7 @@ Required files for this are:
 * `tcp_roccet.c` (Optional; Need to remove corresponding entry in Makefile if missing)
 
 **3. Load Kprobe module**
-To then load the Module use 
+To then load the module use 
 `sudo insmod roccet_kprobe.ko` 
 If you are seeing the error "Unknown symbol in module" you need to first load the roccet algorithm.  
 
@@ -78,21 +92,7 @@ To see the trace output use
 `sudo cat /sys/kernel/tracing/trace_pipe`
 
 **5. Unload Kprobe module**
-To remove the module again use 
+To remove the module again, use 
 `sudo rmmod roccet_kprobe` 
 
 _See more info at_ https://docs.kernel.org/trace/kprobes.html and https://www.kernel.org/doc/Documentation/trace/kprobetrace.rst
-
-## Further Info
-* On TCP-CC Ops: 
-    * https://www.yonch.com/tech/linux-tcp-congestion-control-internals
-    * https://docs.ebpf.io/linux/program-type/BPF_PROG_TYPE_STRUCT_OPS/tcp_congestion_ops/
-
-# Setup Development Environment 
-For specific Kernel:  
-1. Download linux source (the version you want to develop for)
-2. Create Config via `make defconfig`
-3. Compile kernel via `make`
-4. Generate clangd Config via `python scripts/clang-tools/gen_compile_commands.py`
-5. Copy `compile_commands.json` to development directory  
-

tcp_roccet.c

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0-only
+// SPDX-License-Identifier: GPL-2.0
 /*
  * TCP ROCCET: An RTT-Oriented CUBIC Congestion Control
  * Extension for 5G and Beyond Networks
@@ -14,8 +14,10 @@
  * CUBIC's window growth function and adds, based on RTT
  * and ACK rate, congestion events.
  *
- * NOTE: A paper for TCP ROCCET is currently under review.
+ * A peer-reviewed paper on TCP ROCCET will be presented
- * A draft of this paper can be found here:
+ * at the WONS 2026 conference.
+ * A draft of the paper is available here:
+ *		https://arxiv.org/abs/2510.25281
  *
  *
  * Further information about CUBIC:
@@ -44,12 +46,12 @@
  */
 
 #include "tcp_roccet.h"
-#include "linux/printk.h"
 #include <linux/btf.h>
 #include <linux/btf_ids.h>
 #include <linux/math64.h>
 #include <linux/mm.h>
 #include <linux/module.h>
+#include <linux/moduleparam.h>
 #include <net/tcp.h>
 
 /* Scale factor beta calculation (max_cwnd = snd_cwnd * beta) */
@@ -62,39 +64,18 @@
  */
 #define ROCCET_ALPHA_TIMES_100 20
 
-/* The amount of seconds ROCCET stores a minRTT.
+/* min RTT probe period in seconds */
- * Enable "calculate_min_rtt" first.
+#define ROCCET_NEXT_MIN_RTT_PROBE 5000
- */
-#define ROCCET_RTT_LOOKBACK_S 10
 
 /* Parameters that are specific to the ROCCET-Algorithm */
-static int sr_rtt_upper_bound __read_mostly = 100;
+static uint sr_rtt_upper_bound __read_mostly = 100;
 static int ack_rate_diff_ss __read_mostly = 10;
-static int ack_rate_diff_ca __read_mostly = 200;
-static int calculate_min_rtt __read_mostly = 0;
-static int ignore_loss __read_mostly = 0;
-static int roccet_minRTT_interpolation_factor __read_mostly = 70;
 
-module_param(sr_rtt_upper_bound, int, 0644);
+module_param(sr_rtt_upper_bound, uint, 0644);
 MODULE_PARM_DESC(sr_rtt_upper_bound, "ROCCET's upper bound for srRTT.");
 module_param(ack_rate_diff_ss, int, 0644);
 MODULE_PARM_DESC(ack_rate_diff_ss,
-		 "ROCCET's threshold to exit slow start if ACK-rate defer by "
+		 "ROCCET's threshold to exit slow start if ACK-rate defer by given amount of segments.");
-		 "given amount of segments.");
-module_param(ack_rate_diff_ca, int, 0644);
-MODULE_PARM_DESC(ack_rate_diff_ca,
-		 "ROCCET's threshold for ack-rate and cum_cwnd, in percantage "
-		 "of the current cwnd.");
-module_param(calculate_min_rtt, int, 0644);
-MODULE_PARM_DESC(calculate_min_rtt,
-		 "Calculate min RTT if no lower RTT occurs after 10 sec.");
-module_param(ignore_loss, int, 0644);
-MODULE_PARM_DESC(ignore_loss, "Ignore loss as a congestion event.");
-module_param(roccet_minRTT_interpolation_factor, int, 0644);
-MODULE_PARM_DESC(
-	roccet_minRTT_interpolation_factor,
-	"ROCCET factor for interpolating the current RTT with the last minRTT "
-	"(minRTT = (factor * currRTT + (100-factor) * minRTT) / 100)");
 
 static int fast_convergence __read_mostly = 1;
 static int beta __read_mostly = 717; /* = 717/1024 (BICTCP_BETA_SCALE) */
@@ -114,98 +95,212 @@ MODULE_PARM_DESC(beta, "beta for multiplicative increase");
 module_param(initial_ssthresh, int, 0644);
 MODULE_PARM_DESC(initial_ssthresh, "initial value of slow start threshold");
 module_param(bic_scale, int, 0444);
-MODULE_PARM_DESC(
+MODULE_PARM_DESC(bic_scale,
-	bic_scale,
 		 "scale (scaled by 1024) value for bic function (bic_scale/1024)");
 module_param(tcp_friendliness, int, 0644);
 MODULE_PARM_DESC(tcp_friendliness, "turn on/off tcp friendliness");
 
-static inline void roccettcp_reset(struct roccettcp *ca)
+static __always_inline void roccettcp_reset(struct roccettcp *ca)
 {
-	memset(ca, 0, offsetof(struct roccettcp, curr_rtt));
+	memset(ca, 0, sizeof(struct roccettcp));
-	ca->bw_limit.sum_cwnd = 1;
+	ca->next_srrtt_check = 0;
-	ca->bw_limit.sum_acked = 1;
+	ca->curr_min_rtt = ~0U;
-	ca->bw_limit.next_check = 0;
-	ca->curr_min_rtt_timed.rtt = ~0U;
-	ca->curr_min_rtt_timed.time = ~0U;
 	ca->last_rtt = 0;
+	ca->ece_received = false;
+
+	ca->roccet_last_event_time_us = 0;
+	ca->ack_rate.last_rate = 0;
+	/* Initialize to current time to avoid overflow in ack rate calculation */
+	ca->ack_rate.last_rate_time = jiffies_to_usecs(tcp_jiffies32);
+	ca->ack_rate.curr_rate = 0;
+	ca->ack_rate.cnt = 0;
+
+    /* Start state is LAUNCH */
+    ca->state = LAUNCH;
 }
 
-static inline void update_min_rtt(struct sock *sk)
+/* Return true if ROCCET is in min RTT probing.
+ */
+static __always_inline bool is_in_min_rtt_probing(struct roccettcp *ca, u32 now)
+{
+	if (ca->probe_min_rtt_until == 0)
+		return false;
+	return before(now, ca->probe_min_rtt_until);
+}
+
+static __always_inline void update_min_rtt(struct sock *sk)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
-	u32 now = jiffies_to_usecs(tcp_jiffies32);
-
-	if (now - ca->curr_min_rtt_timed.time >
-		    ROCCET_RTT_LOOKBACK_S * USEC_PER_SEC &&
-	    calculate_min_rtt) {
-		u32 new_min_rtt = max(ca->curr_rtt, 1);
-		u32 old_min_rtt = ca->curr_min_rtt_timed.rtt;
-
-		u32 interpolated_min_rtt =
-			(new_min_rtt * roccet_minRTT_interpolation_factor +
-			 old_min_rtt *
-				 (100 - roccet_minRTT_interpolation_factor)) /
-			100;
-
-		ca->curr_min_rtt_timed.rtt = interpolated_min_rtt;
-		ca->curr_min_rtt_timed.time = now;
-	}
 
 	/* Check if new lower min RTT was found. If so, set it directly */
-	if (ca->curr_rtt < ca->curr_min_rtt_timed.rtt) {
+	if (ca->curr_rtt < ca->curr_min_rtt) {
-		ca->curr_min_rtt_timed.rtt = max(ca->curr_rtt, 1);
+		ca->curr_min_rtt = max(ca->curr_rtt, 1);
-		ca->curr_min_rtt_timed.time = now;
+		/* Probe for the min RTT in ROCCET_NEXT_MIN_RTT_PROBE seconds
+		 * if no other update occurs.
+		 */
+		ca->next_min_rtt_probe = jiffies_to_usecs(tcp_jiffies32) +
+					ROCCET_NEXT_MIN_RTT_PROBE * USEC_PER_MSEC;
 	}
 }
 
 /* Return difference between last and current ack rate.
  */
-static inline int get_ack_rate_diff(struct roccettcp *ca)
+static __always_inline s32 get_ack_rate_diff(struct roccettcp *ca)
 {
-	return ca->ack_rate.last_rate - ca->ack_rate.curr_rate;
+	if (ca->ack_rate.curr_rate < ca->ack_rate.last_rate)
+		return 0;
+	return (s32)(ca->ack_rate.curr_rate - ca->ack_rate.last_rate);
 }
 
 /* Update ack rate sampled by 100ms.
  */
-static inline void update_ack_rate(struct sock *sk)
+static __always_inline void update_ack_rate(struct sock *sk, u32 acked, u32 now)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
-	u32 now = jiffies_to_usecs(tcp_jiffies32);
+	s32 interval = USEC_PER_MSEC * 100;
-	u32 interval = USEC_PER_MSEC * 100;
 
-	if ((u32)(now - ca->ack_rate.last_rate_time) >= interval) {
+	s32 time_delta = (s32)(ca->ack_rate.last_rate_time - now);
+	const s32 idle_threshold = USEC_PER_SEC * 2;
+
+	// Check if the time has arrived in the new interval
+	if (time_delta < -interval) {
+		// Check if the connection was idle for X seconds (e.g. no ACK for X seconds)
+		if (time_delta < -idle_threshold) {
+			// Reset ack counting as if a new connection was created
+			ca->ack_rate.last_rate = 0;
+			ca->ack_rate.last_rate_time = jiffies_to_usecs(tcp_jiffies32);
+			ca->ack_rate.curr_rate = 0;
+			ca->ack_rate.cnt = 0;
+		} else {
 			ca->ack_rate.last_rate_time = now;
 			ca->ack_rate.last_rate = ca->ack_rate.curr_rate;
 			ca->ack_rate.curr_rate = ca->ack_rate.cnt;
-		ca->ack_rate.cnt = 0;
+			ca->ack_rate.cnt = acked; // start counting for the new interval
+		}
 	} else {
-		ca->ack_rate.cnt += 1;
+		ca->ack_rate.cnt += acked;
 	}
 }
 
 /* Compute srRTT.
  */
-static inline void update_srrtt(struct sock *sk)
+static __always_inline void update_srrtt(struct sock *sk)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
 
-	if (ca->curr_min_rtt_timed.rtt == 0)
+	/* Avoid integer overflow in the calculation below.
-		return;
+	 * This could occur in cases where we have not yet
-
+	 * received an RTT sample. In these cases, set the
-	/* Calculate the new rRTT (Scaled by 100).
+	 * rtt to a safe value.
-	 * 100 * ((sRTT - sRTT_min) / sRTT_min)
 	 */
-	u32 rRTT = (100 * (ca->curr_rtt - ca->curr_min_rtt_timed.rtt)) /
+	if (ca->curr_rtt < ca->curr_min_rtt) {
-		   ca->curr_min_rtt_timed.rtt;
+		ca->curr_rtt = max(ca->curr_rtt, 1);
-
+		ca->curr_min_rtt = ca->curr_rtt;
-	// (1 - alpha) * srRTT + alpha * rRTT
-	ca->curr_srRTT = ((100 - ROCCET_ALPHA_TIMES_100) * ca->curr_srRTT +
-			  ROCCET_ALPHA_TIMES_100 * rRTT) /
-			 100;
 	}
 
-__bpf_kfunc static void roccettcp_init(struct sock *sk)
+	/* Avoid division by zero */
+	if (ca->curr_min_rtt == 0) {
+		ca->curr_min_rtt = max(ca->curr_min_rtt, 1);
+		return; // skip srRTT update
+	}
+
+	/* Calculate the new rRTT (Scaled by 100).
+	 * 100 * ((sRTT - sRTT_min) / sRTT_min).
+	 *
+	 * curr_min_rtt_timed.rtt is always <= than curr_rtt,
+	 * since this is the minimum of the rtt.
+	 *
+	 * 0 is a valid value for rrtt.
+	 */
+	u32 rrtt = div_u64(100 * (u64)(ca->curr_rtt - ca->curr_min_rtt),
+			     ca->curr_min_rtt);
+
+	// (1 - alpha) * srRTT + alpha * rRTT
+	ca->curr_srrtt = ((100 - ROCCET_ALPHA_TIMES_100) * ca->curr_srrtt +
+			  ROCCET_ALPHA_TIMES_100 * rrtt) / 100;
+}
+
+/* Do a ROCCET congestion event.
+ */
+static __always_inline void roccet_congestion_event(struct sock *sk, u32 now)
+{
+	struct tcp_sock *tp = tcp_sk(sk);
+	struct roccettcp *ca = inet_csk_ca(sk);
+
+	ca->epoch_start = 0;
+	ca->roccet_last_event_time_us = now;
+	ca->cnt = 100 * tcp_snd_cwnd(tp);
+	ca->last_max_cwnd = tcp_snd_cwnd(tp);
+	tcp_snd_cwnd_set(tp, min(tp->snd_cwnd_clamp,
+				 max((tcp_snd_cwnd(tp) * beta) /
+				      BICTCP_BETA_SCALE, 2U)));
+	tp->snd_ssthresh = tcp_snd_cwnd(tp);
+}
+
+/* Do minimum RTT probing.
+ */
+static __always_inline void roccet_min_rtt_probe(struct sock *sk, u32 now)
+{
+	struct tcp_sock *tp = tcp_sk(sk);
+	struct roccettcp *ca = inet_csk_ca(sk);
+    u32 interval, probe_cwnd;
+
+    /* Do nothing if we are probing */
+    if (before(now, ca->probe_min_rtt_until) && ca->probe_min_rtt_until > 0)
+		return;
+
+    /* Start of min RTT probing*/
+    if(ca->probe_min_rtt_until == 0){
+        /* Probe 1*RTT or at least 200ms */
+        interval = max(200 * USEC_PER_MSEC, ca->curr_rtt);
+
+        /* This is to handle deep shared buffers with loss-based
+         * congestion control like CUBIC. If the the cwnd is not limited
+         * by the application but falsely detected (see ROCCET paper),
+         * we have to empty the pipe more.
+         * If the limit detection is correct this will cause no harm
+         * to the tcp flow because the cwnd is not fully utilized and
+         * we set the cwnd to its previous value after probing.
+         */
+        probe_cwnd = max(tcp_snd_cwnd(tp) / 2, TCP_INIT_CWND);
+        if (!tcp_is_cwnd_limited(sk))
+            probe_cwnd = max(tcp_snd_cwnd(tp) / 3, TCP_INIT_CWND);
+
+        ca->probe_min_rtt_until = now + interval;
+        ca->cwnd_before_min_rtt_probe = tcp_snd_cwnd(tp);
+
+        /* Half the cwnd to drain the buffer for probing.
+         * Set the ssthresh to the probing cwnd otherwise
+         * the TCP state machine is in slow start.
+         */
+        tcp_snd_cwnd_set(tp, probe_cwnd);
+        tcp_sk(sk)->snd_ssthresh = tcp_snd_cwnd(tp);
+
+        /* Reset current min RTT to allow probing for
+         * a new lower and higher minimum RTT.
+         */
+        ca->curr_min_rtt = ~0U;
+
+        /* Refill the pipe after probing.
+         * To this end we need the previous cwnd over the
+         * the probing interval.
+         */
+        ca->refill_until = ca->probe_min_rtt_until + interval;
+    }else if(before(now, ca->refill_until)){
+        /* Reset cwnd and refill the pipe. */
+        if(ca->state != RTT_PROBE_REFILL){
+            tcp_snd_cwnd_set(tp, ca->cwnd_before_min_rtt_probe);
+            tcp_sk(sk)->snd_ssthresh = tcp_snd_cwnd(tp);
+            ca->state = RTT_PROBE_REFILL;
+        }
+    }else{
+        /* End min RTT probing phase. */
+        ca->probe_min_rtt_until = 0;
+        ca->state = ORBITER;
+    }
+}
+
+static void roccettcp_init(struct sock *sk)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
 
@@ -214,19 +309,12 @@ __bpf_kfunc static void roccettcp_init(struct sock *sk)
 	if (initial_ssthresh)
 		tcp_sk(sk)->snd_ssthresh = initial_ssthresh;
 
-	/* Initial roccet paramters */
+    cmpxchg(&sk->sk_pacing_status, SK_PACING_NONE, SK_PACING_NEEDED);
-	ca->roccet_last_event_time_us = 0;
+	//WRITE_ONCE(sk->sk_pacing_rate, 0);
-	ca->curr_min_rtt = ~0U;
-	ca->ack_rate.last_rate = 0;
-	ca->ack_rate.last_rate_time = 0;
-	ca->ack_rate.curr_rate = 0;
-	ca->ack_rate.cnt = 0;
 }
 
-__bpf_kfunc static void roccettcp_cwnd_event(struct sock *sk,
+static void roccettcp_cwnd_event_tx_start(struct sock *sk)
-					     enum tcp_ca_event event)
 {
-	if (event == CA_EVENT_TX_START) {
 	struct roccettcp *ca = inet_csk_ca(sk);
 	u32 now = tcp_jiffies32;
 	s32 delta;
@@ -241,8 +329,6 @@ __bpf_kfunc static void roccettcp_cwnd_event(struct sock *sk,
 		if (after(ca->epoch_start, now))
 			ca->epoch_start = now;
 	}
-		return;
-	}
 }
 
 /* calculate the cubic root of x using a table lookup followed by one
@@ -293,7 +379,8 @@ static u32 cubic_root(u64 a)
 
 /* Compute congestion window to use.
  */
-static inline void bictcp_update(struct roccettcp *ca, u32 cwnd, u32 acked)
+static __always_inline void bictcp_update(struct roccettcp *ca, u32 cwnd,
+					  u32 acked)
 {
 	u32 delta, bic_target, max_cnt;
 	u64 offs, t;
@@ -338,7 +425,7 @@ static inline void bictcp_update(struct roccettcp *ca, u32 cwnd, u32 acked)
 	 * (so time^3 is done by using 64 bit)
 	 * and without the support of division of 64bit numbers
 	 * (so all divisions are done by using 32 bit)
-	 *  also NOTE the unit of those veriables
+	 *  also NOTE the unit of those variables
 	 *	  time  = (t - K) / 2^bictcp_HZ
 	 *	  c = bic_scale >> 10
 	 * rtt  = (srtt >> 3) / HZ
@@ -366,11 +453,10 @@ static inline void bictcp_update(struct roccettcp *ca, u32 cwnd, u32 acked)
 		bic_target = ca->bic_origin_point + delta;
 
 	/* cubic function - calc bictcp_cnt*/
-	if (bic_target > cwnd) {
+	if (bic_target > cwnd)
 		ca->cnt = cwnd / (bic_target - cwnd);
-	} else {
+	else
 		ca->cnt = 100 * cwnd; /* very small increment*/
-	}
 
 	/* The initial growth of cubic function may be too conservative
 	 * when the available bandwidth is still unknown.
@@ -403,45 +489,41 @@ tcp_friendliness:
 	ca->cnt = max(ca->cnt, 2U);
 }
 
-__bpf_kfunc static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
+static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
 				 u32 acked)
 {
 	struct tcp_sock *tp = tcp_sk(sk);
 	struct roccettcp *ca = inet_csk_ca(sk);
 
 	u32 now = jiffies_to_usecs(tcp_jiffies32);
-	u32 bw_limit_detect = 0;
+	bool evaluate_srrtt = false;
 	u32 roccet_xj;
 	u32 jitter;
-	if (ca->last_rtt > ca->curr_rtt) {
-		jitter = ca->last_rtt - ca->curr_rtt;
-	} else {
-		jitter = ca->curr_rtt - ca->last_rtt;
-	}
 
-	/* Update roccet paramters */
+    if(ca->state == LAUNCH){
-	update_ack_rate(sk);
+    /* LAUNCH: Detect an exit point for tcp slow start
-	update_min_rtt(sk);
-	update_srrtt(sk);
-
-	/* ROCCET drain.
-	 * Do not increase the cwnd for 100ms after a roccet congestion event
-	 */
-	if (now - ca->roccet_last_event_time_us <= 100 * USEC_PER_MSEC)
-		return;
-
-	/* Lift off: Detect an exit point for tcp slow start
 	 * in networks with large buffers of multiple BDP
 	 * Like in cellular networks (5G, ...).
+	 * Or exit LAUNCH if cwnd is too large for application layer
+	 * data rate (tcp cwnd validation).
 	 */
-	if (tcp_in_slow_start(tp) && ca->curr_srRTT > sr_rtt_upper_bound &&
+        if ((ca->curr_srrtt > sr_rtt_upper_bound &&
-	    get_ack_rate_diff(ca) >= ack_rate_diff_ss) {
+            get_ack_rate_diff(ca) <= ack_rate_diff_ss) ||
+            !tcp_is_cwnd_limited(sk)) {
             ca->epoch_start = 0;
 
-		/* Handle inital slow start. Here we observe the most problems */
+            /* Handle initial slow start. Here occur most bufferbloat */
             if (tp->snd_ssthresh == TCP_INFINITE_SSTHRESH) {
                 tcp_sk(sk)->snd_ssthresh = tcp_snd_cwnd(tp) / 2;
-			tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) / 2);
+                /* since this is the initial slow start,
+                * the min cwnd won't be 1, so the window
+                * can't be set to 0 by accident.
+                * Halfing the cwnd will undo the previous step
+                * of slow start. Which is fine since the pipe
+                * is already full.
+                */
+                tcp_snd_cwnd_set(tp, max(tcp_snd_cwnd(tp) / 2,
+                            TCP_INIT_CWND));
             } else {
                 tcp_sk(sk)->snd_ssthresh =
                     tcp_snd_cwnd(tp) - (tcp_snd_cwnd(tp) / 3);
@@ -452,61 +534,54 @@ __bpf_kfunc static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
             return;
         }
 
-	if (tcp_in_slow_start(tp)) {
         acked = tcp_slow_start(tp, acked);
         if (!acked)
             return;
-	}
 
-	if (ca->bw_limit.next_check == 0)
+    }else if(ca->state == ORBITER){
-		ca->bw_limit.next_check = now + 5 * ca->curr_rtt;
+    /* ORBITER: Increase the cwnd by using the CUBIC
+     * cwnd growth function, if no roccet congestion
+     * event is detechted.
+	 */
+        /* Calculate jitter */
+        if ((s32)(ca->curr_rtt - ca->last_rtt) < 0)
+            jitter = ca->last_rtt - ca->curr_rtt;
+        else
+            jitter = ca->curr_rtt - ca->last_rtt;
 
-	ca->bw_limit.sum_cwnd += tcp_snd_cwnd(tp);
+        if (ca->next_srrtt_check == 0)
-	ca->bw_limit.sum_acked += acked;
+            ca->next_srrtt_check = now + 5 * ca->curr_rtt;
 
-	if (ca->bw_limit.next_check < now) {
+        /* Check if it's time to evaluate the srRTT */
-		/* We send more data as we got acked in the last 5 RTTs */
+        if ((s32)(ca->next_srrtt_check - now) < 0) {
-		if ((ca->bw_limit.sum_cwnd * 100) / ca->bw_limit.sum_acked >=
+            evaluate_srrtt = true;
-		    ack_rate_diff_ca)
-			bw_limit_detect = 1;
 
             /* reset struct and set next end of period */
-		ca->bw_limit.sum_cwnd = 1;
+            ca->next_srrtt_check = now + 5 * ca->curr_rtt;
-
-		/* set to 1 to avoid division by zero */
-		ca->bw_limit.sum_acked = 1;
-		ca->bw_limit.next_check = now + 5 * ca->curr_rtt;
         }
 
-	/* Respects the jitter of the connection and add it on top of the upper bound
+        /* Respects the jitter of the connection and add it on top of
-	 * for the srRTT
+        * the upper bound for the srRTT.
         */
-	roccet_xj = ((jitter * 100) / ca->curr_min_rtt_timed.rtt) +
+        roccet_xj = div_u64((u64)jitter * 100, ca->curr_min_rtt) +
                 sr_rtt_upper_bound;
         if (roccet_xj < sr_rtt_upper_bound)
             roccet_xj = sr_rtt_upper_bound;
 
-	if (ca->curr_srRTT > roccet_xj && bw_limit_detect) {
+        /* The srRTT exceeds the upper bound if bufferbloat happens.
-		ca->epoch_start = 0;
+        * Here, we want to reduce the cwnd and drain the buffer.
-		ca->roccet_last_event_time_us = now;
+        */
-		ca->cnt = 100 * tcp_snd_cwnd(tp);
+        if (ca->curr_srrtt > roccet_xj && evaluate_srrtt) {
-
+            roccet_congestion_event(sk, now);
-		/* Set Wmax if cwnd is larger than the old Wmax */
-		if (tcp_snd_cwnd(tp) > ca->last_max_cwnd)
-			ca->last_max_cwnd = tcp_snd_cwnd(tp);
-
-		tcp_snd_cwnd_set(tp, min(tp->snd_cwnd_clamp,
-			max((tcp_snd_cwnd(tp) * beta) / BICTCP_BETA_SCALE, 2U)));
-		tp->snd_ssthresh = tcp_snd_cwnd(tp);
             return;
         }
 
         /* Terminates this function if cwnd is not fully utilized.
-	 * In mobile networks like 5G, this termination causes the cwnd to be frozen at
+        * In mobile networks like 5G, this termination causes the cwnd to be
-	 * an excessively high value. This is because slow start or HyStart massively
+        * frozen at an excessively high value. This is because slow start or
-	 * exceed the available bandwidth and leave the cwnd at an excessively high
+        * HyStart massively exceed the available bandwidth and leave the cwnd
-	 * value. The cwnd cannot therefore be fully utilized because it is limited by
+        * at an excessively high value. The cwnd cannot therefore be fully
-	 * the connection capacity.
+        * utilized because it is limited by the connection capacity.
         */
         if (!tcp_is_cwnd_limited(sk))
             return;
@@ -514,19 +589,65 @@ __bpf_kfunc static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
         bictcp_update(ca, tcp_snd_cwnd(tp), acked);
         tcp_cong_avoid_ai(tp, max(1, ca->cnt), acked);
     }
+}
 
-__bpf_kfunc static u32 roccettcp_recalc_ssthresh(struct sock *sk)
+static u32 roccettcp_recalc_ssthresh(struct sock *sk)
 {
 	const struct tcp_sock *tp = tcp_sk(sk);
 	struct roccettcp *ca = inet_csk_ca(sk);
+	u32 cwnd;
 
-	if (ignore_loss)
+    /* If a loss/ECN occurs in the refill pahse of min RTT probing
+     * we reduce the cwnd and abort the refill.
+     */
+    if (ca->state == RTT_PROBE_REFILL)
+        ca->state = ORBITER;
+
+    /* If ROCCET is in min RTT probing and a loss/ECN occurs,
+     * we use the cwnd before the probing interval to
+     * calculate the cwnd reduction and continue probing.
+     * After min RTT probing the cwnd is set to the reduced
+     * value. During min RTT probing it is very likely that
+     * congestion was caused by the cwnd value before min
+     * RTT probing.
+     */
+    if (ca->state == RTT_PROBE){
+        /* Handle ECN as cubic congestion event in min
+            * RTT probe.
+            */
+        ca->ece_received = false;
+
+        ca->epoch_start = 0; /* end of epoch */
+
+        /* Wmax and fast convergence */
+        if (cwnd < ca->last_max_cwnd && fast_convergence)
+            ca->last_max_cwnd =
+                (cwnd * (BICTCP_BETA_SCALE + beta)) /
+                (2 * BICTCP_BETA_SCALE);
+        else
+            ca->last_max_cwnd = cwnd;
+
+        cwnd = ca->cwnd_before_min_rtt_probe;
+        ca->cwnd_before_min_rtt_probe = max((cwnd * beta) / BICTCP_BETA_SCALE, 2U);
+        return cwnd;
+    }
+
+	/* Handle ECN as ROCCET congestion event. */
+	if (ca->ece_received) {
+		ca->ece_received = false;
+		roccet_congestion_event(sk, jiffies_to_usecs(tcp_jiffies32));
 		return tcp_snd_cwnd(tp);
+	}
 
-	/* Don't exit slow start if loss occurs. */
+	/* On loss in slow start enter congestion avoidance
+	 * without a cwnd reduction. Additional slow start
+	 * exit conditions with a cwnd reduction are handled
+	 * in roccettcp_cong_avoid.
+	 */
 	if (tcp_in_slow_start(tp))
 		return tcp_snd_cwnd(tp);
 
+	/*CUBIC congestion event*/
 	ca->epoch_start = 0; /* end of epoch */
 
 	/* Wmax and fast convergence */
@@ -540,14 +661,21 @@ __bpf_kfunc static u32 roccettcp_recalc_ssthresh(struct sock *sk)
 	return max((tcp_snd_cwnd(tp) * beta) / BICTCP_BETA_SCALE, 2U);
 }
 
-__bpf_kfunc static void roccettcp_state(struct sock *sk, u8 new_state)
+static void roccettcp_state(struct sock *sk, u8 new_state)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
-	if (new_state == TCP_CA_Loss)
+    struct tcp_sock *tp = tcp_sk(sk);
+
+	if (new_state == TCP_CA_Loss){
 		roccettcp_reset(ca);
     }
+    else if(new_state == TCP_CA_Recovery){
+        tcp_sk(sk)->snd_ssthresh = roccettcp_recalc_ssthresh(sk);
+        tcp_snd_cwnd_set(tp, tcp_sk(sk)->snd_ssthresh);
+    }
+}
 
-__bpf_kfunc static void roccettcp_acked(struct sock *sk,
+static void roccettcp_acked(struct sock *sk,
 			    const struct ack_sample *sample)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
@@ -561,11 +689,12 @@ __bpf_kfunc static void roccettcp_acked(struct sock *sk,
 		return;
 
 	u32 delay = sample->rtt_us;
+
 	if (delay == 0)
 		delay = 1;
 
 	/* first time call or link delay decreases */
-	if (ca->delay_min == 0 || ca->delay_min > delay)
+	if (ca->delay_min == 0 || (s32)(delay - ca->delay_min) < 0)
 		ca->delay_min = delay;
 
 	/* Get valid sample for roccet */
@@ -575,42 +704,124 @@ __bpf_kfunc static void roccettcp_acked(struct sock *sk,
 	}
 }
 
+static void roccet_in_ack_event(struct sock *sk, u32 flags)
+{
+	struct roccettcp *ca = inet_csk_ca(sk);
+
+	/* Handle ECE bit.
+	 * Processing of ECE events is done in roccettcp_recalc_ssthresh()
+	 */
+	if (flags & CA_ACK_ECE)
+		ca->ece_received = true;
+}
+
+__bpf_kfunc static void roccet_control(struct sock *sk, u32 ack, int flag, const struct rate_sample *rs) {
+    struct tcp_sock *tp = tcp_sk(sk);
+	struct roccettcp *ca = inet_csk_ca(sk);
+
+	u32 now = jiffies_to_usecs(tcp_jiffies32);
+    u64 rate;
+
+    /* Update roccet parameters */
+	update_ack_rate(sk, rs->acked_sacked, now);
+	update_min_rtt(sk);
+	update_srrtt(sk);
+
+    /* Update roccet state */
+    if(tcp_in_slow_start(tp)){
+        ca->state = LAUNCH;
+    }else if((s32) now - ca->roccet_last_event_time_us <= 100 * USEC_PER_MSEC){
+        ca->state = DRAIN;
+    }
+    else if(after(now, ca->next_min_rtt_probe) || ca->state == RTT_PROBE || ca->state == RTT_PROBE_REFILL){
+        if(ca->state != RTT_PROBE_REFILL)
+            ca->state = RTT_PROBE;
+        roccet_min_rtt_probe(sk, now);
+    }
+    else{
+        ca->state = ORBITER;
+    }
+
+    /* If nothing was fully acked do not increase the cwnd */
+    if (!rs->acked_sacked)
+            return;
+
+    /* Increase the cwnd.
+     * Loss recovery is handled in roccettcp_state()
+     */
+    roccettcp_cong_avoid(sk, ack, rs->acked_sacked);
+
+    /* Adjust pacing rate. The code here is similar to the
+     * pacing rate adjustemnts in tcp_input.c tcp_cong_control().
+     * In LAUNCH (slow start) we want a pacing of 200% and
+     * in ORBITER (congestion avoidance) we adjust the pacing
+     * to 100% and do not use the sysctl_tcp_pacing_ca_ratio.
+     */
+
+    /* set sk_pacing_rate to 200 % of current rate (mss * cwnd / srtt) */
+	rate = (u64)tp->mss_cache * ((USEC_PER_SEC / 100) << 3);
+
+	/* current rate is (cwnd * mss) / srtt
+	 * In Slow Start [1], set sk_pacing_rate to 200 % the current rate.
+	 * In Congestion Avoidance phase, set it to 120 % the current rate.
+	 *
+	 * [1] : Normal Slow Start condition is (tp->snd_cwnd < tp->snd_ssthresh)
+	 *	 If snd_cwnd >= (tp->snd_ssthresh / 2), we are approaching
+	 *	 end of slow start and should slow down.
+	 */
+	if (tcp_snd_cwnd(tp) < tp->snd_ssthresh / 2)
+		rate *= READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_pacing_ss_ratio);
+	else
+		/* Pacing rate of 100% (instead of ipv4.sysctl_tcp_pacing_ca_ratio) */
+        rate *= 100;
+
+	rate *= max(tcp_snd_cwnd(tp), tp->packets_out);
+
+	if (likely(tp->srtt_us))
+		do_div(rate, tp->srtt_us);
+
+	/* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate
+	 * without any lock. We want to make sure compiler wont store
+	 * intermediate values in this location.
+	 */
+	WRITE_ONCE(sk->sk_pacing_rate,
+		   min_t(u64, rate, READ_ONCE(sk->sk_max_pacing_rate)));
+}
+
 static struct tcp_congestion_ops roccet_tcp __read_mostly = {
     .init = roccettcp_init,
     .ssthresh = roccettcp_recalc_ssthresh,
-	.cong_avoid = roccettcp_cong_avoid,
     .set_state = roccettcp_state,
     .undo_cwnd = tcp_reno_undo_cwnd,
-	.cwnd_event = roccettcp_cwnd_event,
+    .cwnd_event_tx_start = roccettcp_cwnd_event_tx_start,
     .pkts_acked = roccettcp_acked,
+    .in_ack_event   = roccet_in_ack_event,
+    .cong_control	= roccet_control,
     .owner = THIS_MODULE,
     .name = "roccet",
 };
 
-BTF_KFUNCS_START(tcp_roccet_check_kfunc_ids)
-BTF_ID_FLAGS(func, roccettcp_init)
-BTF_ID_FLAGS(func, roccettcp_recalc_ssthresh)
-BTF_ID_FLAGS(func, roccettcp_cong_avoid)
-BTF_ID_FLAGS(func, roccettcp_state)
-BTF_ID_FLAGS(func, roccettcp_cwnd_event)
-BTF_ID_FLAGS(func, roccettcp_acked)
-BTF_KFUNCS_END(tcp_roccet_check_kfunc_ids)
-
-static const struct btf_kfunc_id_set tcp_roccet_kfunc_set = {
-	.owner = THIS_MODULE,
-	.set = &tcp_roccet_check_kfunc_ids,
-};
-
 static int __init roccettcp_register(void)
 {
-	int ret;
-
 	BUILD_BUG_ON(sizeof(struct roccettcp) > ICSK_CA_PRIV_SIZE);
 
+	/*
+	 * Validate parameters to avoid division by zero errors.
+	 */
+	if (beta <= 0 || beta >= BICTCP_BETA_SCALE) {
+		pr_err("roccet: beta must be between 0 and %d\n",
+		       BICTCP_BETA_SCALE);
+		return -EINVAL;
+	}
+
+	if (bic_scale <= 0) {
+		pr_err("roccet: bic_scale must be positive\n");
+		return -EINVAL;
+	}
+
 	/* Precompute a bunch of the scaling factors that are used per-packet
 	 * based on SRTT of 100ms
 	 */
-
 	beta_scale =
 		8 * (BICTCP_BETA_SCALE + beta) / 3 / (BICTCP_BETA_SCALE - beta);
 
@@ -635,10 +846,6 @@ static int __init roccettcp_register(void)
 	/* divide by bic_scale and by constant Srtt (100ms) */
 	do_div(cube_factor, bic_scale * 10);
 
-	ret = register_btf_kfunc_id_set(BPF_PROG_TYPE_STRUCT_OPS,
-					&tcp_roccet_kfunc_set);
-	if (ret < 0)
-		return ret;
 	return tcp_register_congestion_control(&roccet_tcp);
 }
 
@@ -653,4 +860,3 @@ module_exit(roccettcp_unregister);
 MODULE_AUTHOR("Lukas Prause, Tim Füchsel");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("ROCCET TCP");
-MODULE_VERSION("1.0");

tcp_roccet.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * TCP ROCCET congestion control interface
  */
@@ -6,25 +7,26 @@
 
 #include <linux/math64.h>
 
-struct AckRate {
+/* State in which roccet currently opperates */
-	u16 last_rate;	/* Last ACK-rate */
+enum roccet_state {
+  LAUNCH,
+  ORBITER,
+  RTT_PROBE,
+  RTT_PROBE_REFILL,
+  DRAIN
+};
+
+/* TCP ROCCET helper type, storing data related to ack counting */
+struct ack_rate {
+	u32 last_rate;	/* Last ACK-rate */
 	u32 last_rate_time;	/* Timestamp of the last ACK-rate */
-	u16 curr_rate; 	/* Current ACK-rate */
+	u32 curr_rate;	/* Current ACK-rate */
-	u16 cnt; 	/* Used for counting acks */
+	u32 cnt;	/* Used for counting acks */
 };
 
-struct BandwidthLimitDetect {
+/* TCP ROCCET struct based on the original BICTCP struct with
-	u32 sum_cwnd; 	/* sum of cwnd during time interval */
+ * additions specific to the ROCCET-Algorithm.
-	u32 sum_acked; 	/* sum of received acks during time interval */
+ */
-	u32 next_check; /* end/upper bound of time interval */
-};
-
-struct TimedRTT {
-	u32 time; /* Time of recoding */
-	u32 rtt;  /* Measured RTT */
-};
-
-/* Based on the BICTCP struct with additions specific for the ROCCET-Algorithm */
 struct roccettcp {
 	u32 cnt;		/* increase cwnd by 1 after ACKs */
 	u32 last_max_cwnd;	/* last maximum snd_cwnd */
@@ -32,21 +34,30 @@ struct roccettcp {
 	u32 last_time;		/* time when updated last_cwnd */
 	u32 bic_origin_point;	/* origin point of bic function */
 	u32 bic_K;		/* time to origin point from the
-				beginning of the current epoch */
+				 * beginning of the current epoch
+				 */
 	u32 delay_min;		/* min delay (usec) */
 	u32 epoch_start;	/* beginning of an epoch */
 	u32 ack_cnt;		/* number of acks */
 	u32 tcp_cwnd;		/* estimated tcp cwnd */
-	u32 curr_rtt; 		/* the minimum rtt of current round */
+	u32 curr_rtt;		/* last sample rtt of current round */
 
-	u32 roccet_last_event_time_us; 	/* The last time ROCCETv2 was triggered */
+	u32 roccet_last_event_time_us;	/* The last time ROCCET was
+					 * triggered
+					 */
+	bool ece_received;	/* Set to true if an ECE bit was received */
 	u32 curr_min_rtt;	/* The current observed minRTT */
-	struct TimedRTT curr_min_rtt_timed; /* The current observed minRTT with 
+	u32 next_min_rtt_probe; /* Next time to probe the minRTT */
-						the timestamp when it was observed */
+	u32 probe_min_rtt_until;	/* End of minRTT probing period */
-	u32 curr_srRTT; 		/* The srRTT calculated based on the latest ACK */
+	u32 refill_until;       /* End of pipe refill after minRTT probe */
-	struct AckRate ack_rate; 	/* The last and the current ACK rate */
+	u32 cwnd_before_min_rtt_probe;	/* cwnd before min RTT probeing */
-	struct BandwidthLimitDetect bw_limit;
+	u32 curr_srrtt;		/* srRTT calculated based on the latest ACK */
-	u32 last_rtt; 			/* Used for jitter calculation */
+	u32 next_srrtt_check;	/* Next check for srRTT */
+	struct ack_rate ack_rate;	/* The last and the current ACK rate */
+	u32 last_rtt;			/* sample rtt of previous round.
+					 * Used for jitter calculation
+					 */
+    enum roccet_state state; /* State in which roccet currently opperates */
 };
 
 #endif /* __TCP_ROCCET_H */

tcp_roccet_struct.h

@@ -1,52 +0,0 @@
-// Include Guard
-#ifndef TCP_ROCCET_STRUCT
-#define TCP_ROCCET_STRUCT
-
-#include <linux/math64.h>
-
-struct AckRate {
-  u16 last_rate;
-  u32 last_rate_time;
-  u16 curr_rate;
-  u16 cnt;
-};
-
-struct BandwidthLimitDetect {
-  u32 sum_cwnd;   /* sum of cwnd during time interval */
-  u32 sum_acked;  /* sum of received acks during time interval */
-  u32 next_check; /* end/upper bound of time interval */
-};
-
-struct TimedRTT {
-  u32 time;
-  u32 rtt;
-};
-
-/* BIC TCP Parameters */
-struct bictcp {
-  u32 cnt;              /* increase cwnd by 1 after ACKs */
-  u32 last_max_cwnd;    /* last maximum snd_cwnd */
-  u32 last_cwnd;        /* the last snd_cwnd */
-  u32 last_time;        /* time when updated last_cwnd */
-  u32 bic_origin_point; /* origin point of bic function */
-  u32 bic_K;            /* time to origin point
-                           from the beginning of the current epoch */
-  u32 delay_min;        /* min delay (usec) */
-  u32 epoch_start;      /* beginning of an epoch */
-  u32 ack_cnt;          /* number of acks */
-  u32 tcp_cwnd;         /* estimated tcp cwnd */
-
-  u32 curr_rtt; /* the minimum rtt of current round */
-
-  // ROCCETv2 specific
-  u32 roccet_last_event_time_us;      /* The last time ROCCETv2 was triggered */
-  u32 curr_min_rtt;                   /* The current observed minRTT */
-  struct TimedRTT curr_min_rtt_timed; /* The current observed minRTT with the
-                             timestamp when it was observed */
-  u32 curr_srRTT;          /* The srRTT calculated based on the latest ACK */
-  struct AckRate ack_rate; /* The last and the current ACK rate */
-  struct BandwidthLimitDetect bw_limit;
-  u32 last_rtt; /* Used for jitter calculation */
-};
-
-#endif /* TCP_ROCCET_STRUCT */