Adds ECN handling managed by ROCCET. Use of srRTT as a hard condition after receiving an ECN.

README.md

@@ -1,55 +1,35 @@
 # TCP ROCCET :rocket: (RTT Oriented CUBIC Congestion control ExTension)
 
-TCP ROCCET is a new TCP congestion control algorithm that reduces latency by detecting queuing.
-Additionally, it is specially suited for 4G/5G cellular networks.
+TCP ROCCET is a new TCP congestion control
+algorithm suited for current cellular 5G NR beyond 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.
 
-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.
+NOTE: A paper for TCP ROCCET is currently under review.
+Paper draft:
+            https://arxiv.org/abs/2510.25281
  
-A new performance report for the latest version of TCP ROCCET can be found under "doc/measurements/2026-07-21_performance-report.pdf".
+The oldest Linux kernel version we tested with ROCCET is 6.1.
 
-### Versions
+## Setup
 
-- latest on master branch (requires kernel version 7.1 or higher)
-    - Improved min RTT probing
-    - Packet pacing
-    - Code refactor
-    - Monitoring send and receive rate
-
-- release-2026-06-12-v1
-    - Adds minimum RTT probing
-    
-## Install with apt (requires kernel version 6.10 or higher)
-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
-```
-
-### 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
-```
-
-## 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 to reinstall the kernel-headers.
+In case you get the "Invalid module Format" error, it can help reinstalling the kernel-headers.
 
 **2.** Use the Algorithm:
 * Either via globally loading it: `sudo sysctl net.ipv4.tcp_congestion_control=roccet`
@@ -59,12 +39,12 @@ In case you get the "Invalid module Format" error, it can help to reinstall 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: 
 ```
@@ -89,7 +69,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.  
 
@@ -98,7 +78,21 @@ 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
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * TCP ROCCET: An RTT-Oriented CUBIC Congestion Control
  * Extension for 5G and Beyond Networks
@@ -14,8 +14,7 @@
  * CUBIC's window growth function and adds, based on RTT
  * and ACK rate, congestion events.
  *
- * A peer-reviewed paper on TCP ROCCET will be presented
- * at the WONS 2026 conference.
+ * A peer-reviewed paper on TCP ROCCET will be presented at the WONS 2026 conference.
  * A draft of the paper is available here:
  * 		https://arxiv.org/abs/2510.25281
  *
@@ -45,13 +44,14 @@
  * this behaves the same as the original Reno.
  */
 
-#include "linux/limits.h"
+#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>
-#include "tcp_roccet.h"
 
 /* Scale factor beta calculation (max_cwnd = snd_cwnd * beta) */
 #define BICTCP_BETA_SCALE 1024
@@ -63,18 +63,39 @@
  */
 #define ROCCET_ALPHA_TIMES_100 20
 
-/* min RTT probe period in seconds */
-#define ROCCET_NEXT_MIN_RTT_PROBE 5000
+/* The amount of seconds ROCCET stores a minRTT.
+ * Enable "calculate_min_rtt" first.
+ */
+#define ROCCET_RTT_LOOKBACK_S 10
 
 /* Parameters that are specific to the ROCCET-Algorithm */
-static uint sr_rtt_upper_bound __read_mostly = 100;
+static int 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, uint, 0644);
+module_param(sr_rtt_upper_bound, int, 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 given amount of segments.");
+		 "ROCCET's threshold to exit slow start if ACK-rate defer by "
+		 "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) */
@@ -94,227 +115,99 @@ 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(bic_scale,
+MODULE_PARM_DESC(
+	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 __always_inline void roccettcp_reset(struct roccettcp *ca)
+static inline void roccettcp_reset(struct roccettcp *ca)
 {
-	memset(ca, 0, sizeof(struct roccettcp));
-	ca->next_srrtt_check = 0;
-	ca->curr_min_rtt = ~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 an
-	 * overflow in the 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;
+	memset(ca, 0, offsetof(struct roccettcp, curr_rtt));
+	ca->bw_limit.sum_cwnd = 1;
+	ca->bw_limit.sum_acked = 1;
+	ca->bw_limit.next_check = 0;
+	ca->curr_min_rtt_timed.rtt = ~0U;
+	ca->curr_min_rtt_timed.time = ~0U;
+	ca->ece_srrtt = 0;
+	ca->ece_cwnd = 2;
 }
 
-/* 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)
+static 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) {
-		ca->curr_min_rtt = max(ca->curr_rtt, 1);
-		/* 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;
+	if (ca->curr_rtt < ca->curr_min_rtt_timed.rtt) {
+		ca->curr_min_rtt_timed.rtt = max(ca->curr_rtt, 1);
+		ca->curr_min_rtt_timed.time = now;
 	}
 }
 
 /* Return difference between last and current ack rate.
  */
-static __always_inline s32 get_ack_rate_diff(struct roccettcp *ca)
+static inline int get_ack_rate_diff(struct roccettcp *ca)
 {
-	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);
+	return ca->ack_rate.last_rate - ca->ack_rate.curr_rate;
 }
 
 /* Update ack rate sampled by 100ms.
  */
-static __always_inline void update_ack_rate(struct sock *sk, u32 acked, u32 now)
+static inline void update_ack_rate(struct sock *sk)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
-	s32 interval = USEC_PER_MSEC * 100;
+	u32 now = jiffies_to_usecs(tcp_jiffies32);
+	u32 interval = USEC_PER_MSEC * 100;
 
-	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;
+	if ((u32)(now - ca->ack_rate.last_rate_time) >= interval) {
+		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;
 	} 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 =
-				acked; // start counting for the new interval
-		}
-	} else {
-		// Cap the ack count to avoid overflow
-		ca->ack_rate_cnt = min_t(u32, ca->ack_rate_cnt + acked,
-					 U16_MAX);
+		ca->ack_rate.cnt += 1;
 	}
 }
 
 /* Compute srRTT.
  */
-static __always_inline void update_srrtt(struct sock *sk)
+static inline void update_srrtt(struct sock *sk)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
 
-	/* Avoid integer overflow in the calculation below.
-	 * This could occur in cases where we have not yet
-	 * received an RTT sample. In these cases, set the
-	 * rtt to a safe value.
-	 */
-	if (ca->curr_rtt < ca->curr_min_rtt) {
-		ca->curr_rtt = max(ca->curr_rtt, 1);
-		ca->curr_min_rtt = ca->curr_rtt;
-	}
-
-	/* Avoid division by zero */
-	if (ca->curr_min_rtt == 0) {
-		ca->curr_min_rtt = max(ca->curr_min_rtt, 1);
-		return; // skip srRTT update
-	}
+	if (ca->curr_min_rtt_timed.rtt == 0)
+		return;
 
 	/* 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.
+	 * 100 * ((sRTT - sRTT_min) / sRTT_min)
 	 */
-	u32 rrtt = div_u64(100 * (u64)(ca->curr_rtt - ca->curr_min_rtt),
-			   ca->curr_min_rtt);
+	u32 rRTT = (100 * (ca->curr_rtt - ca->curr_min_rtt_timed.rtt)) /
+		   ca->curr_min_rtt_timed.rtt;
 
 	// (1 - alpha) * srRTT + alpha * rRTT
-	ca->curr_srrtt = ((100 - ROCCET_ALPHA_TIMES_100) * ca->curr_srrtt +
-			  ROCCET_ALPHA_TIMES_100 * 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);
-	/*Set W_max only if the current cwnd is larger */
-	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);
-}
-
-/* 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 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 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)
+__bpf_kfunc static void roccettcp_init(struct sock *sk)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
 
@@ -323,12 +216,19 @@ static void roccettcp_init(struct sock *sk)
 	if (initial_ssthresh)
 		tcp_sk(sk)->snd_ssthresh = initial_ssthresh;
 
-	cmpxchg(&sk->sk_pacing_status, SK_PACING_NONE, SK_PACING_NEEDED);
-	//WRITE_ONCE(sk->sk_pacing_rate, 0);
+	/* Initial roccet paramters */
+	ca->roccet_last_event_time_us = 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;
 }
 
-static void roccettcp_cwnd_event_tx_start(struct sock *sk)
+__bpf_kfunc static void roccettcp_cwnd_event(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;
@@ -343,6 +243,8 @@ static void roccettcp_cwnd_event_tx_start(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
@@ -393,8 +295,7 @@ static u32 cubic_root(u64 a)
 
 /* Compute congestion window to use.
  */
-static __always_inline void bictcp_update(struct roccettcp *ca, u32 cwnd,
-					  u32 acked)
+static inline void bictcp_update(struct roccettcp *ca, u32 cwnd, u32 acked)
 {
 	u32 delta, bic_target, max_cnt;
 	u64 offs, t;
@@ -439,7 +340,7 @@ static __always_inline void bictcp_update(struct roccettcp *ca, u32 cwnd,
 	 * (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 variables
+	 *  also NOTE the unit of those veriables
 	 *	  time  = (t - K) / 2^bictcp_HZ
 	 *	  c = bic_scale >> 10
 	 * rtt  = (srtt >> 3) / HZ
@@ -467,10 +368,11 @@ static __always_inline void bictcp_update(struct roccettcp *ca, u32 cwnd,
 		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.
@@ -503,49 +405,62 @@ tcp_friendliness:
 	ca->cnt = max(ca->cnt, 2U);
 }
 
-static void roccettcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
+__bpf_kfunc 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);
-	bool evaluate_srrtt = false;
-	bool send_more_than_acked = false;
+	u32 bw_limit_detect = 0;
 	u32 roccet_xj;
 	u32 jitter;
-	u32 send, received;
+	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 */
+	update_ack_rate(sk);
+	update_min_rtt(sk);
+	update_srrtt(sk);
+
+	/* Reset ECE handling if we already have more bandwidth
+	 * than we received the last ECE.
+	 */
+	if(ca->ece_srrtt > 0){
+		if(tcp_snd_cwnd(tp) >= ca->ece_cwnd){
+			ca->ece_srrtt = 0;
+		}
+	}
+
+	/* 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;
 
-	if (ca->state == LAUNCH) {
 	/* LAUNCH: 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).
+	 * data rate.
 	 */
-		if ((ca->curr_srrtt > sr_rtt_upper_bound &&
-		     get_ack_rate_diff(ca) <= ack_rate_diff_ss) ||
-		    !tcp_is_cwnd_limited(sk)) {
+
+	if ((tcp_in_slow_start(tp) && ca->curr_srRTT > sr_rtt_upper_bound &&
+	    get_ack_rate_diff(ca) >= ack_rate_diff_ss) ||
+		(!tcp_is_cwnd_limited(sk) && tcp_in_slow_start(tp))
+		) {
 		ca->epoch_start = 0;
 
-			/* Handle initial slow start.
-			 * Most bufferbloat occurs here
-			 */
+		/* Handle inital slow start. Here we observe the most problems */
 		if (tp->snd_ssthresh == TCP_INFINITE_SSTHRESH) {
-				tcp_sk(sk)->snd_ssthresh = 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));
+			tcp_sk(sk)->snd_ssthresh = tcp_snd_cwnd(tp) / 2;
+			tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) / 2);
 		} else {
 			tcp_sk(sk)->snd_ssthresh =
-					tcp_snd_cwnd(tp) -
-					(tcp_snd_cwnd(tp) / 3);
+				tcp_snd_cwnd(tp) - (tcp_snd_cwnd(tp) / 3);
 			tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) -
 						     (tcp_snd_cwnd(tp) / 3));
 		}
@@ -553,154 +468,87 @@ static void roccettcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
 		return;
 	}
 
+	if (tcp_in_slow_start(tp)) {
 		acked = tcp_slow_start(tp, acked);
 		if (!acked)
 			return;
-
-	} else if (ca->state == ORBITER) {
-		/* 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;
-
-		if (ca->next_srrtt_check == 0)
-			ca->next_srrtt_check = now + 5 * ca->curr_rtt;
-
-		/* Calculate if more bytes was send than received
-		 * in the time interval.
-		 */
-		if (before(tp->snd_nxt, ca->interval_snd_seq_start)) {
-			/* We had a wrap around in seq no counter */
-			send = (~0U - ca->interval_snd_seq_start + tp->snd_nxt);
-		} else {
-			send = (tp->snd_nxt - ca->interval_snd_seq_start);
-		}
-		if (before(tp->snd_una, ca->interval_una_seq_start)) {
-			/* We had a wrap around in seq no counter */
-			received = (~0U - ca->interval_una_seq_start +
-				    tp->snd_una);
-		} else {
-			received = (tp->snd_una - ca->interval_una_seq_start);
 	}
 
-		/* Here we use a guard space of 1% of the current cwnd.
-		 * We do this to avoid a false positive evaluation due
-		 * to delays caused by jitter or scheduling.
-		 */
-		send_more_than_acked =
-			send >
-			received + ((tcp_snd_cwnd(tp) * tp->mss_cache) / 100);
+	if (ca->bw_limit.next_check == 0)
+		ca->bw_limit.next_check = now + 5 * ca->curr_rtt;
 
-		/* Check if it's time to evaluate the srRTT */
-		if ((s32)(ca->next_srrtt_check - now) < 0) {
-			evaluate_srrtt = true;
+	ca->bw_limit.sum_cwnd += tcp_snd_cwnd(tp);
+	ca->bw_limit.sum_acked += acked;
+
+	if (ca->bw_limit.next_check < now) {
+		/* We send more data as we got acked in the last 5 RTTs */
+		if ((ca->bw_limit.sum_cwnd * 100) / ca->bw_limit.sum_acked >=
+		    ack_rate_diff_ca)
+			bw_limit_detect = 1;
 
 		/* reset struct and set next end of period */
-			ca->next_srrtt_check = now + 5 * ca->curr_rtt;
+		ca->bw_limit.sum_cwnd = 1;
 
-			/* Reset Rate calculation */
-			ca->interval_snd_seq_start = tp->snd_nxt;
-			ca->interval_una_seq_start = tp->snd_una;
+		/* 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 for the srRTT.
+	/* Respects the jitter of the connection and add it on top of the upper bound
+	 * for the srRTT
 	 */
-		roccet_xj = div_u64((u64)jitter * 100, ca->curr_min_rtt) +
+	roccet_xj = ((jitter * 100) / ca->curr_min_rtt_timed.rtt) +
 		    sr_rtt_upper_bound;
 	if (roccet_xj < sr_rtt_upper_bound)
 		roccet_xj = sr_rtt_upper_bound;
 
-		/* The srRTT exceeds the upper bound if bufferbloat happens.
-		 * Here, we want to reduce the cwnd and drain the buffer.
+	/* This is true if we recently received an ECE bit. 
+	 * Therefore we should respect the srRTT at this piont.
 	 */
-		if (ca->curr_srrtt > roccet_xj && evaluate_srrtt &&
-		    send_more_than_acked) {
-			roccet_congestion_event(sk, now);
+	if(ca->ece_srrtt < roccet_xj && ca->ece_srrtt > 0)
+		roccet_xj = ca->ece_srrtt;
+
+	if (ca->curr_srRTT > roccet_xj && (bw_limit_detect || ca->ece_srrtt > 0)) {
+		ca->epoch_start = 0;
+		ca->roccet_last_event_time_us = now;
+		ca->cnt = 100 * tcp_snd_cwnd(tp);
+
+		/* 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 an excessively high value. This is
-		 * because slow start or HyStart massively exceed the available
-		 * bandwidth and leave the cwnd at an excessively high value.
-		 * The cwnd cannot therefore be fully utilized because it is
-		 * limited by the connection capacity.
+	 * In mobile networks like 5G, this termination causes the cwnd to be frozen at
+	 * an excessively high value. This is because slow start or HyStart massively
+	 * exceed the available bandwidth and leave the cwnd at an excessively high
+	 * value. The cwnd cannot therefore be fully utilized because it is limited by
+	 * the connection capacity.
 	 */
-		if (!tcp_is_cwnd_limited(sk) || send_more_than_acked)
+	if (!tcp_is_cwnd_limited(sk))
 		return;
 
 	bictcp_update(ca, tcp_snd_cwnd(tp), acked);
 	tcp_cong_avoid_ai(tp, max(1, ca->cnt), acked);
-	}
 }
 
-static u32 roccettcp_recalc_ssthresh(struct sock *sk)
+__bpf_kfunc 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 = tcp_snd_cwnd(tp);
 
-	/* If a loss/ECN occurs in the refill phase 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));
+	if (ignore_loss)
 		return tcp_snd_cwnd(tp);
-	}
 
-	/* 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.
-	 */
+	/* Don't exit slow start if loss occurs. */
 	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 */
@@ -714,20 +562,15 @@ static u32 roccettcp_recalc_ssthresh(struct sock *sk)
 	return max((tcp_snd_cwnd(tp) * beta) / BICTCP_BETA_SCALE, 2U);
 }
 
-static void roccettcp_state(struct sock *sk, u8 new_state)
+__bpf_kfunc static void roccettcp_state(struct sock *sk, u8 new_state)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
-	struct tcp_sock *tp = tcp_sk(sk);
-
-	if (new_state == TCP_CA_Loss) {
+	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);
-	}
 }
 
-static void roccettcp_acked(struct sock *sk, const struct ack_sample *sample)
+__bpf_kfunc static void roccettcp_acked(struct sock *sk,
+					const struct ack_sample *sample)
 {
 	struct roccettcp *ca = inet_csk_ca(sk);
 
@@ -740,12 +583,11 @@ static void roccettcp_acked(struct sock *sk, const struct ack_sample *sample)
 		return;
 
 	u32 delay = sample->rtt_us;
-
 	if (delay == 0)
 		delay = 1;
 
 	/* first time call or link delay decreases */
-	if (ca->delay_min == 0 || (s32)(delay - ca->delay_min) < 0)
+	if (ca->delay_min == 0 || ca->delay_min > delay)
 		ca->delay_min = delay;
 
 	/* Get valid sample for roccet */
@@ -755,135 +597,57 @@ static void roccettcp_acked(struct sock *sk, const struct ack_sample *sample)
 	}
 }
 
-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;
-}
-
-static void roccet_control(struct sock *sk, u32 ack, int flag,
-				       const struct rate_sample *rs)
+__bpf_kfunc static void roccet_in_ack_event(struct sock *sk, u32 flags)
 {
 	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);
-
-	/* Set values for send and receive rate */
-	if (ca->interval_snd_seq_start == 0) {
-		ca->interval_snd_seq_start = tp->snd_nxt;
-		ca->interval_una_seq_start = tp->snd_una;
+	/* Handle ECE bit. 
+	 * Pocessing of ECE events is done in roccettcp_cong_avoid()
+	 */
+	if (flags & CA_ACK_ECE) {
+		ca->ece_srrtt = ca->curr_srRTT;
+		ca->ece_cwnd = tcp_snd_cwnd(tp);
 	}
-
-	/* 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 adjustments 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 cond 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 won't 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_tx_start = roccettcp_cwnd_event_tx_start,
+	.cwnd_event = roccettcp_cwnd_event,
 	.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);
 
@@ -908,6 +672,10 @@ 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);
 }
 
@@ -922,3 +690,4 @@ 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,4 +1,3 @@
-/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * TCP ROCCET congestion control interface
  */
@@ -7,18 +6,25 @@
 
 #include <linux/math64.h>
 
-/* State in which roccet currently operates */
-enum roccet_state {
-	LAUNCH,
-	ORBITER,
-	RTT_PROBE,
-	RTT_PROBE_REFILL,
-	DRAIN
+struct AckRate {
+	u16 last_rate;	/* Last ACK-rate */
+	u32 last_rate_time; /* Timestamp of the last ACK-rate */
+	u16 curr_rate; 	/* Current ACK-rate */
+	u16 cnt; 	/* Used for counting acks */
 };
 
-/* TCP ROCCET struct based on the original BICTCP struct with
- * additions specific to the ROCCET-Algorithm.
- */
+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; /* 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 */
@@ -26,36 +32,23 @@ 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;	/* last sample rtt of current round */
+	u32 curr_rtt; 		/* the minimum rtt of current round */
 
 	u32 roccet_last_event_time_us; 	/* The last time ROCCET was triggered */
+	u32 ece_cwnd; 	/* The cwnd when a ECE bit was received */
+	u32 ece_srrtt; 	/* The srRTT whent the ECE was received */
 	u32 curr_min_rtt; 		/* The current observed minRTT */
-	u32 next_min_rtt_probe;	/* Next time to probe the minRTT */
-	u32 probe_min_rtt_until;	/* End of minRTT probing period */
-	u32 refill_until;	/* End of pipe refill after minRTT probe */
-	u32 cwnd_before_min_rtt_probe;	/* cwnd before min RTT probeing */
-	u32 curr_srrtt;	/* srRTT calculated based on the latest ACK */
-	u32 next_srrtt_check;	/* Next check for srRTT */
-	u32 last_rtt;	/* sample rtt of previous round.
-			 * Used for jitter calculation
-			 */
-
-	u32 interval_snd_seq_start;
-	u32 interval_una_seq_start;
-
-	u32 ack_rate_last_rate_time;	/* Timestamp of the last ACK-rate */
-	u16 ack_rate_last_rate;	/* Last ACK-rate */
-	u16 ack_rate_curr_rate;	/* Current ACK-rate */
-	u16 ack_rate_cnt;	/* Used for counting acks */
-
-	bool ece_received;	/* Set to true if an ECE bit was received */
-	enum roccet_state state; /* State in which roccet currently operates */
+	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_H */