From 27d181962d002455cc05114e89f26aeb47c1cecd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20F=C3=BCchsel?= Date: Tue, 10 Feb 2026 14:21:08 +0100 Subject: [PATCH] Make formatting linux conform --- tcp_roccet.c | 101 ++++++++++++++++++++++++--------------------------- tcp_roccet.h | 69 ++++++++++++++++++----------------- 2 files changed, 83 insertions(+), 87 deletions(-) diff --git a/tcp_roccet.c b/tcp_roccet.c index fe64d89..892faf9 100644 --- a/tcp_roccet.c +++ b/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 @@ -10,19 +10,19 @@ * 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 + * 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 will be presented at the WONS 2026 conference. * A draft of the paper is available here: - * https://arxiv.org/abs/2510.25281 + * https://arxiv.org/abs/2510.25281 * * * Further information about CUBIC: * TCP CUBIC: Binary Increase Congestion control for TCP v2.3 * Home page: - * http://netsrv.csc.ncsu.edu/twiki/bin/view/Main/BIC + * http://netsrv.csc.ncsu.edu/twiki/bin/view/Main/BIC * This is from the implementation of CUBIC TCP in * Sangtae Ha, Injong Rhee and Lisong Xu, * "CUBIC: A New TCP-Friendly High-Speed TCP Variant" @@ -72,30 +72,26 @@ 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; +static bool calculate_min_rtt __read_mostly; +static bool ignore_loss __read_mostly; +static int roccet_min_rtt_interpolation_factor __read_mostly = 70; 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); + "ROCCET's threshold for ack-rate and cum_cwnd, in percantage of the current cwnd."); +module_param(calculate_min_rtt, bool, 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_param(ignore_loss, bool, 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)"); +module_param(roccet_min_rtt_interpolation_factor, int, 0644); +MODULE_PARM_DESC(roccet_min_rtt_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) */ @@ -115,9 +111,8 @@ 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, - "scale (scaled by 1024) value for bic function (bic_scale/1024)"); +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"); @@ -130,7 +125,7 @@ static inline void roccettcp_reset(struct roccettcp *ca) ca->curr_min_rtt_timed.rtt = ~0U; ca->curr_min_rtt_timed.time = ~0U; ca->last_rtt = 0; - ca->ece_received = 0; + ca->ece_received = false; } static inline void update_min_rtt(struct sock *sk) @@ -145,9 +140,9 @@ static inline void update_min_rtt(struct sock *sk) u32 old_min_rtt = ca->curr_min_rtt_timed.rtt; u32 interpolated_min_rtt = - (new_min_rtt * roccet_minRTT_interpolation_factor + + (new_min_rtt * roccet_min_rtt_interpolation_factor + old_min_rtt * - (100 - roccet_minRTT_interpolation_factor)) / + (100 - roccet_min_rtt_interpolation_factor)) / 100; ca->curr_min_rtt_timed.rtt = interpolated_min_rtt; @@ -198,13 +193,12 @@ static inline void update_srrtt(struct sock *sk) /* Calculate the new rRTT (Scaled by 100). * 100 * ((sRTT - sRTT_min) / sRTT_min) */ - u32 rRTT = (100 * (ca->curr_rtt - ca->curr_min_rtt_timed.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) / - 100; + 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) @@ -216,7 +210,7 @@ __bpf_kfunc static void roccettcp_init(struct sock *sk) if (initial_ssthresh) tcp_sk(sk)->snd_ssthresh = initial_ssthresh; - /* Initial roccet paramters */ + /* Initial roccet parameters */ ca->roccet_last_event_time_us = 0; ca->curr_min_rtt = ~0U; ca->ack_rate.last_rate = 0; @@ -340,7 +334,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 @@ -368,11 +362,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. @@ -415,13 +408,13 @@ __bpf_kfunc static void roccettcp_cong_avoid(struct sock *sk, u32 ack, u32 bw_limit_detect = 0; 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->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); update_min_rtt(sk); update_srrtt(sk); @@ -439,13 +432,12 @@ __bpf_kfunc static void roccettcp_cong_avoid(struct sock *sk, u32 ack, * data rate. */ - 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)) - ) { + 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 inital slow start. Here we observe the most problems */ + /* Handle initial 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; tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) / 2); @@ -493,9 +485,9 @@ __bpf_kfunc static void roccettcp_cong_avoid(struct sock *sk, u32 ack, if (roccet_xj < sr_rtt_upper_bound) roccet_xj = sr_rtt_upper_bound; - if (ca->curr_srRTT > roccet_xj && (bw_limit_detect || ca->ece_received)) { - if(ca->ece_received) - ca->ece_received = 0; + if (ca->curr_srrtt > roccet_xj && (bw_limit_detect || ca->ece_received)) { + if (ca->ece_received) + ca->ece_received = false; ca->epoch_start = 0; ca->roccet_last_event_time_us = now; ca->cnt = 100 * tcp_snd_cwnd(tp); @@ -505,7 +497,7 @@ __bpf_kfunc static void roccettcp_cong_avoid(struct sock *sk, u32 ack, 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); return; } @@ -535,7 +527,7 @@ __bpf_kfunc static u32 roccettcp_recalc_ssthresh(struct sock *sk) /* Don't exit slow start if loss occurs. */ if (tcp_in_slow_start(tp)) return tcp_snd_cwnd(tp); - + ca->epoch_start = 0; /* end of epoch */ /* Wmax and fast convergence */ @@ -552,6 +544,7 @@ __bpf_kfunc static u32 roccettcp_recalc_ssthresh(struct sock *sk) __bpf_kfunc static void roccettcp_state(struct sock *sk, u8 new_state) { struct roccettcp *ca = inet_csk_ca(sk); + if (new_state == TCP_CA_Loss) roccettcp_reset(ca); } @@ -570,6 +563,7 @@ __bpf_kfunc static void roccettcp_acked(struct sock *sk, return; u32 delay = sample->rtt_us; + if (delay == 0) delay = 1; @@ -588,12 +582,11 @@ __bpf_kfunc static void roccet_in_ack_event(struct sock *sk, u32 flags) { struct roccettcp *ca = inet_csk_ca(sk); - /* Handle ECE bit. - * Pocessing of ECE events is done in roccettcp_cong_avoid() + /* Handle ECE bit. + * Processing of ECE events is done in roccettcp_cong_avoid() */ - if (flags & CA_ACK_ECE) { - ca->ece_received = 1; - } + if (flags & CA_ACK_ECE) + ca->ece_received = true; } static struct tcp_congestion_ops roccet_tcp __read_mostly = { diff --git a/tcp_roccet.h b/tcp_roccet.h index 0e5fada..a720186 100644 --- a/tcp_roccet.h +++ b/tcp_roccet.h @@ -1,3 +1,4 @@ +/* SPDX-License-Identifier: GPL-2.0 */ /* * TCP ROCCET congestion control interface */ @@ -6,48 +7,50 @@ #include -struct AckRate { +struct ack_rate { 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 */ + u32 last_rate_time; /* Timestamp of the last ACK-rate */ + u16 curr_rate; /* Current ACK-rate */ + u16 cnt; /* Used for counting acks */ }; -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 bandwidth_limit_detect { + 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 */ +struct timed_rtt { + u32 time; /* Time of recording */ + 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 */ - 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 */ + 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 */ - u32 roccet_last_event_time_us; /* The last time ROCCET was triggered */ - u32 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 - 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 */ + 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 timed_rtt 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 ack_rate ack_rate; /* The last and the current ACK rate */ + struct bandwidth_limit_detect bw_limit; + u32 last_rtt; /* Used for jitter calculation */ }; -#endif /* __TCP_ROCCET_H */ \ No newline at end of file +#endif /* __TCP_ROCCET_H */