langspielplatte/tcp-roccet-kernel-module
1
1
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Adjusts sruct size and refactor of code.

Browse Source
This commit is contained in:
Lukas Prause
2026-07-20 14:57:20 +02:00
parent a6356c3297
commit b651be77b3
3 changed files with 341 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+1 -1
View File
@@ -7,7 +7,7 @@ A peer-reviewed [paper on TCP ROCCET](https://opendl.ifip-tc6.org/db/conf/wons/w
### Versions
- latest on master branch
- latest on master branch (requires kernel version 6.15 or higher)
- Improved min RTT probing
- Packet pacing
- Code refactor
tcp_roccet.c
+88 -64
View File
@@ -45,14 +45,13 @@
* this behaves the same as the original Reno.
*/
#include "tcp_roccet.h"
#include <linux/btf.h>
#include <linux/btf_ids.h>
#include "linux/limits.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
@@ -109,11 +108,13 @@ static __always_inline void roccettcp_reset(struct roccettcp *ca)
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;
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;
@@ -138,7 +139,8 @@ static __always_inline void update_min_rtt(struct sock *sk)
/* 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) +
ca->next_min_rtt_probe =
jiffies_to_usecs(tcp_jiffies32) +
ROCCET_NEXT_MIN_RTT_PROBE * USEC_PER_MSEC;
}
}
@@ -147,9 +149,9 @@ static __always_inline void update_min_rtt(struct sock *sk)
*/
static __always_inline s32 get_ack_rate_diff(struct roccettcp *ca)
{
if (ca->ack_rate.curr_rate < ca->ack_rate.last_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);
return (s32)(ca->ack_rate_curr_rate - ca->ack_rate_last_rate);
}
/* Update ack rate sampled by 100ms.
@@ -159,26 +161,34 @@ static __always_inline void update_ack_rate(struct sock *sk, u32 acked, u32 now)
struct roccettcp *ca = inet_csk_ca(sk);
s32 interval = USEC_PER_MSEC * 100;
s32 time_delta = (s32)(ca->ack_rate.last_rate_time - now);
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)
/* 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;
/* 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 = acked; // start counting for the new 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 =
acked; // start counting for the new interval
}
} else {
ca->ack_rate.cnt += acked;
// Cap the ack count to avoid overflow
ca->ack_rate_cnt = min_t(u32, ca->ack_rate_cnt + acked,
U16_MAX);
}
}
@@ -217,7 +227,8 @@ static __always_inline void update_srrtt(struct sock *sk)
// (1 - alpha) * srRTT + alpha * rRTT
ca->curr_srrtt = ((100 - ROCCET_ALPHA_TIMES_100) * ca->curr_srrtt +
ROCCET_ALPHA_TIMES_100 * rrtt) / 100;
ROCCET_ALPHA_TIMES_100 * rrtt) /
100;
}
/* Do a ROCCET congestion event.
@@ -233,11 +244,11 @@ static __always_inline void roccet_congestion_event(struct sock *sk, u32 now)
/*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)));
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.
@@ -258,7 +269,7 @@ static __always_inline void roccet_min_rtt_probe(struct sock *sk, u32 now)
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
* 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
@@ -285,7 +296,7 @@ static __always_inline void roccet_min_rtt_probe(struct sock *sk, u32 now)
ca->curr_min_rtt = ~0U;
/* Refill the pipe after probing.
* To this end we need the previous cwnd over the
* To this end we need the previous cwnd over
* the probing interval.
*/
ca->refill_until = ca->probe_min_rtt_until + interval;
@@ -492,8 +503,7 @@ tcp_friendliness:
ca->cnt = max(ca->cnt, 2U);
}
static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
u32 acked)
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);
@@ -517,9 +527,12 @@ static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
!tcp_is_cwnd_limited(sk)) {
ca->epoch_start = 0;
/* Handle initial slow start. Here occur most bufferbloat */
/* Handle initial slow start.
* Most bufferbloat occurs here
*/
if (tp->snd_ssthresh == TCP_INFINITE_SSTHRESH) {
tcp_sk(sk)->snd_ssthresh = tcp_snd_cwnd(tp) / 2;
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.
@@ -531,7 +544,8 @@ static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
TCP_INIT_CWND));
} 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));
}
@@ -558,18 +572,19 @@ static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
if (ca->next_srrtt_check == 0)
ca->next_srrtt_check = now + 5 * ca->curr_rtt;
/* Calculate if more bytes was send than reveived
/* Calculate if more bytes was send than received
* in the time interval.
*/
if (tp->snd_nxt < ca->interval_snd_seq_start){
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 (tp->snd_una < ca->interval_una_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);
received = (~0U - ca->interval_una_seq_start +
tp->snd_una);
} else {
received = (tp->snd_una - ca->interval_una_seq_start);
}
@@ -578,7 +593,9 @@ static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
* 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 );
send_more_than_acked =
send >
received + ((tcp_snd_cwnd(tp) * tp->mss_cache) / 100);
/* Check if it's time to evaluate the srRTT */
if ((s32)(ca->next_srrtt_check - now) < 0) {
@@ -603,17 +620,19 @@ static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
/* The srRTT exceeds the upper bound if bufferbloat happens.
* Here, we want to reduce the cwnd and drain the buffer.
*/
if (ca->curr_srrtt > roccet_xj && evaluate_srrtt && send_more_than_acked) {
if (ca->curr_srrtt > roccet_xj && evaluate_srrtt &&
send_more_than_acked) {
roccet_congestion_event(sk, now);
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)
return;
@@ -627,9 +646,9 @@ 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;
u32 cwnd = tcp_snd_cwnd(tp);
/* If a loss/ECN occurs in the refill pahse of min RTT probing
/* 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)
@@ -660,7 +679,9 @@ static u32 roccettcp_recalc_ssthresh(struct sock *sk)
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);
ca->cwnd_before_min_rtt_probe =
max((cwnd * beta) / BICTCP_BETA_SCALE, 2U);
return cwnd;
}
@@ -700,15 +721,13 @@ static void roccettcp_state(struct sock *sk, u8 new_state)
if (new_state == TCP_CA_Loss) {
roccettcp_reset(ca);
}
else if(new_state == TCP_CA_Recovery){
} 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)
static void roccettcp_acked(struct sock *sk, const struct ack_sample *sample)
{
struct roccettcp *ca = inet_csk_ca(sk);
@@ -747,7 +766,9 @@ static void roccet_in_ack_event(struct sock *sk, u32 flags)
ca->ece_received = true;
}
__bpf_kfunc static void roccet_control(struct sock *sk, u32 ack, int flag, const struct rate_sample *rs) {
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);
@@ -768,15 +789,15 @@ __bpf_kfunc static void roccet_control(struct sock *sk, u32 ack, int flag, const
/* 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){
} 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){
} 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{
} else {
ca->state = ORBITER;
}
@@ -790,7 +811,7 @@ __bpf_kfunc static void roccet_control(struct sock *sk, u32 ack, int flag, const
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().
* 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.
@@ -803,14 +824,17 @@ __bpf_kfunc static void roccet_control(struct sock *sk, u32 ack, int flag, const
* 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)
* [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);
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) */
/* Pacing rate of 100%
* (instead of ipv4.sysctl_tcp_pacing_ca_ratio)
*/
rate *= 100;
rate *= max(tcp_snd_cwnd(tp), tp->packets_out);
@@ -819,7 +843,7 @@ __bpf_kfunc static void roccet_control(struct sock *sk, u32 ack, int flag, const
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
* without any lock. We want to make sure compiler won't store
* intermediate values in this location.
*/
WRITE_ONCE(sk->sk_pacing_rate,
tcp_roccet.h
+11 -15
View File
@@ -7,7 +7,7 @@
#include <linux/math64.h>
/* State in which roccet currently opperates */
/* State in which roccet currently operates */
enum roccet_state {
LAUNCH,
ORBITER,
@@ -16,14 +16,6 @@ enum roccet_state {
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 */
u32 curr_rate; /* Current ACK-rate */
u32 cnt; /* Used for counting acks */
};
/* TCP ROCCET struct based on the original BICTCP struct with
* additions specific to the ROCCET-Algorithm.
*/
@@ -42,10 +34,7 @@ struct roccettcp {
u32 tcp_cwnd; /* estimated tcp cwnd */
u32 curr_rtt; /* last sample rtt of current round */
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 roccet_last_event_time_us; /* The last time ROCCET was triggered */
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 */
@@ -53,13 +42,20 @@ struct roccettcp {
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 */
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 */
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 */
};
#endif /* __TCP_ROCCET_H */