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

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

Browse Source
This commit is contained in:
Lukas Prause
2026-07-13 16:20:23 +02:00
parent 52cb1fe1f1
commit 35aa714256
3 changed files with 348 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+5
View File
@@ -21,6 +21,11 @@ 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
tcp_roccet.c
+324 -148
View File
@@ -68,10 +68,10 @@
#define ROCCET_NEXT_MIN_RTT_PROBE 5000
/* 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;
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,
@@ -107,6 +107,16 @@ static __always_inline void roccettcp_reset(struct roccettcp *ca)
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 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;
}
/* Return true if ROCCET is in min RTT probing.
@@ -135,11 +145,11 @@ static __always_inline void update_min_rtt(struct sock *sk)
/* Return difference between last and current ack rate.
*/
static __always_inline int get_ack_rate_diff(struct roccettcp *ca)
static __always_inline s32 get_ack_rate_diff(struct roccettcp *ca)
{
if (ca->ack_rate.curr_rate < ca->ack_rate.last_rate)
return 0;
return 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.
@@ -147,13 +157,26 @@ static __always_inline int get_ack_rate_diff(struct roccettcp *ca)
static __always_inline void update_ack_rate(struct sock *sk, u32 acked, u32 now)
{
struct roccettcp *ca = inet_csk_ca(sk);
u32 interval = USEC_PER_MSEC * 100;
s32 interval = USEC_PER_MSEC * 100;
if (after(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 = acked; // start counting for the new 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 = acked; // start counting for the new interval
}
} else {
ca->ack_rate.cnt += acked;
}
@@ -189,8 +212,8 @@ static __always_inline void update_srrtt(struct sock *sk)
*
* 0 is a valid value for rrtt.
*/
u32 rrtt = (100 * (ca->curr_rtt - ca->curr_min_rtt)) /
ca->curr_min_rtt;
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 +
@@ -209,11 +232,74 @@ static __always_inline void roccet_congestion_event(struct sock *sk, u32 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)));
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);
@@ -223,33 +309,25 @@ static void roccettcp_init(struct sock *sk)
if (initial_ssthresh)
tcp_sk(sk)->snd_ssthresh = initial_ssthresh;
/* Initial roccet parameters */
ca->roccet_last_event_time_us = 0;
ca->ack_rate.last_rate = 0;
ca->ack_rate.last_rate_time = 0;
ca->ack_rate.curr_rate = 0;
ca->ack_rate.cnt = 0;
cmpxchg(&sk->sk_pacing_status, SK_PACING_NONE, SK_PACING_NEEDED);
//WRITE_ONCE(sk->sk_pacing_rate, 0);
}
static void roccettcp_cwnd_event(struct sock *sk,
enum tcp_ca_event event)
static void roccettcp_cwnd_event_tx_start(struct sock *sk)
{
if (event == CA_EVENT_TX_START) {
struct roccettcp *ca = inet_csk_ca(sk);
u32 now = tcp_jiffies32;
s32 delta;
struct roccettcp *ca = inet_csk_ca(sk);
u32 now = tcp_jiffies32;
s32 delta;
delta = now - tcp_sk(sk)->lsndtime;
delta = now - tcp_sk(sk)->lsndtime;
/* We were application limited (idle) for a while.
* Shift epoch_start to keep cwnd growth to cubic curve.
*/
if (ca->epoch_start && delta > 0) {
ca->epoch_start += delta;
if (after(ca->epoch_start, now))
ca->epoch_start = now;
}
return;
/* We were application limited (idle) for a while.
* Shift epoch_start to keep cwnd growth to cubic curve.
*/
if (ca->epoch_start && delta > 0) {
ca->epoch_start += delta;
if (after(ca->epoch_start, now))
ca->epoch_start = now;
}
}
@@ -412,7 +490,7 @@ tcp_friendliness:
}
static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
u32 acked)
u32 acked)
{
struct tcp_sock *tp = tcp_sk(sk);
struct roccettcp *ca = inet_csk_ca(sk);
@@ -422,120 +500,137 @@ static void roccettcp_cong_avoid(struct sock *sk, u32 ack,
u32 roccet_xj;
u32 jitter;
if (after(ca->last_rtt, ca->curr_rtt))
jitter = ca->last_rtt - ca->curr_rtt;
else
jitter = ca->curr_rtt - ca->last_rtt;
/* Update roccet parameters */
update_ack_rate(sk, acked, now);
update_min_rtt(sk);
update_srrtt(sk);
/* do not increase the cwnd if in RTT probe */
if (is_in_min_rtt_probing(ca, now))
return;
/* Probe for min RTT if the last min RTT update is
* ROCCET_NEXT_MIN_RTT_PROBE seconds ago.
*/
if (after(now, ca->next_min_rtt_probe)){
ca->probe_min_rtt_until = now + min(200, 2 * ca->curr_rtt) * USEC_PER_MSEC;
ca->cwnd_before_min_rtt_probe = tcp_snd_cwnd(tp);
tcp_snd_cwnd_set(tp, max(tcp_snd_cwnd(tp) / 2, TCP_INIT_CWND));
ca->curr_min_rtt = ~0U;
return;
}
/* ROCCET drain.
* Do not increase the cwnd for 100ms after a roccet congestion event
* because the buffer is still not drained.
*/
if (now - ca->roccet_last_event_time_us <= 100 * USEC_PER_MSEC)
return;
/* LAUNCH: Detect an exit point for tcp slow start
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).
*/
if ((ca->curr_srrtt > sr_rtt_upper_bound &&
get_ack_rate_diff(ca) <= ack_rate_diff_ss) ||
!tcp_is_cwnd_limited(sk)) {
ca->epoch_start = 0;
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. Here occur most bufferbloat */
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));
} else {
tcp_sk(sk)->snd_ssthresh =
tcp_snd_cwnd(tp) - (tcp_snd_cwnd(tp) / 3);
tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) -
(tcp_snd_cwnd(tp) / 3));
}
ca->roccet_last_event_time_us = now;
return;
}
/* 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;
/* 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.
*/
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);
tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) -
(tcp_snd_cwnd(tp) / 3));
}
ca->roccet_last_event_time_us = now;
return;
}
acked = tcp_slow_start(tp, acked);
if (!acked)
return;
if (tcp_in_slow_start(tp)) {
acked = tcp_slow_start(tp, acked);
if (!acked)
return;
}
if (ca->next_srrtt_check == 0)
ca->next_srrtt_check = now + 5 * ca->curr_rtt;
/* Check if it's time to evaluate the srRTT */
if (after(now, ca->next_srrtt_check)) {
evaluate_srrtt = true;
/* reset struct and set next end of period */
ca->next_srrtt_check = now + 5 * ca->curr_rtt;
}
/* Respects the jitter of the connection and add it on top of
* the upper bound for the srRTT.
}else if(ca->state == ORBITER){
/* ORBITER: Increase the cwnd by using the CUBIC
* cwnd growth function, if no roccet congestion
* event is detechted.
*/
roccet_xj = ((jitter * 100) / ca->curr_min_rtt) +
sr_rtt_upper_bound;
if (roccet_xj < sr_rtt_upper_bound)
roccet_xj = sr_rtt_upper_bound;
/* 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;
/* 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) {
roccet_congestion_event(sk, now);
return;
}
if (ca->next_srrtt_check == 0)
ca->next_srrtt_check = now + 5 * ca->curr_rtt;
/* 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.
*/
if (!tcp_is_cwnd_limited(sk))
return;
/* Check if it's time to evaluate the srRTT */
if ((s32)(ca->next_srrtt_check - now) < 0) {
evaluate_srrtt = true;
bictcp_update(ca, tcp_snd_cwnd(tp), acked);
tcp_cong_avoid_ai(tp, max(1, ca->cnt), acked);
/* reset struct and set next end of period */
ca->next_srrtt_check = now + 5 * ca->curr_rtt;
}
/* 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) +
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.
*/
if (ca->curr_srrtt > roccet_xj && evaluate_srrtt) {
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.
*/
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)
{
const struct tcp_sock *tp = tcp_sk(sk);
struct roccettcp *ca = inet_csk_ca(sk);
u32 cwnd;
/* 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) {
@@ -545,11 +640,14 @@ static u32 roccettcp_recalc_ssthresh(struct sock *sk)
}
/* On loss in slow start enter congestion avoidance
* without a cwnd reduction.
* 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 */
@@ -566,13 +664,19 @@ static u32 roccettcp_recalc_ssthresh(struct sock *sk)
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)
const struct ack_sample *sample)
{
struct roccettcp *ca = inet_csk_ca(sk);
@@ -590,7 +694,7 @@ static void roccettcp_acked(struct sock *sk,
delay = 1;
/* first time call or link delay decreases */
if (ca->delay_min == 0 || after(ca->delay_min, delay))
if (ca->delay_min == 0 || (s32)(delay - ca->delay_min) < 0)
ca->delay_min = delay;
/* Get valid sample for roccet */
@@ -611,17 +715,90 @@ 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) {
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,
.pkts_acked = roccettcp_acked,
.in_ack_event = roccet_in_ack_event,
.owner = THIS_MODULE,
.name = "roccet",
.init = roccettcp_init,
.ssthresh = roccettcp_recalc_ssthresh,
.set_state = roccettcp_state,
.undo_cwnd = tcp_reno_undo_cwnd,
.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",
};
static int __init roccettcp_register(void)
@@ -645,7 +822,6 @@ static int __init roccettcp_register(void)
/* 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);
tcp_roccet.h
+19 -5
View File
@@ -7,6 +7,16 @@
#include <linux/math64.h>
/* State in which roccet currently opperates */
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 */
@@ -14,8 +24,8 @@ struct ack_rate {
u32 cnt; /* Used for counting acks */
};
/* Based on the BICTCP struct with additions specific
* for the ROCCET-Algorithm
/* TCP ROCCET struct based on the original BICTCP struct with
* additions specific to the ROCCET-Algorithm.
*/
struct roccettcp {
u32 cnt; /* increase cwnd by 1 after ACKs */
@@ -30,7 +40,7 @@ struct roccettcp {
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 ROCCET was
* triggered
@@ -39,11 +49,15 @@ struct roccettcp {
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 cwnd_before_min_rtt_probe; /* cwnd before min RTT probeing */
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 */
struct ack_rate ack_rate; /* The last and the current ACK rate */
u32 last_rtt; /* Used for jitter calculation */
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 */