![Arnaldo Carvalho de Melo](/assets/img/avatar_default.png)
This changeset basically moves tcp_sk()->{ca_ops,ca_state,etc} to inet_csk(), minimal renaming/moving done in this changeset to ease review. Most of it is just changes of struct tcp_sock * to struct sock * parameters. With this we move to a state closer to two interesting goals: 1. Generalisation of net/ipv4/tcp_diag.c, becoming inet_diag.c, being used for any INET transport protocol that has struct inet_hashinfo and are derived from struct inet_connection_sock. Keeps the userspace API, that will just not display DCCP sockets, while newer versions of tools can support DCCP. 2. INET generic transport pluggable Congestion Avoidance infrastructure, using the current TCP CA infrastructure with DCCP. Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com> Signed-off-by: David S. Miller <davem@davemloft.net>
189 lines
4.7 KiB
C
189 lines
4.7 KiB
C
/*
|
|
* TCP HYBLA
|
|
*
|
|
* TCP-HYBLA Congestion control algorithm, based on:
|
|
* C.Caini, R.Firrincieli, "TCP-Hybla: A TCP Enhancement
|
|
* for Heterogeneous Networks",
|
|
* International Journal on satellite Communications,
|
|
* September 2004
|
|
* Daniele Lacamera
|
|
* root at danielinux.net
|
|
*/
|
|
|
|
#include <linux/config.h>
|
|
#include <linux/module.h>
|
|
#include <net/tcp.h>
|
|
|
|
/* Tcp Hybla structure. */
|
|
struct hybla {
|
|
u8 hybla_en;
|
|
u32 snd_cwnd_cents; /* Keeps increment values when it is <1, <<7 */
|
|
u32 rho; /* Rho parameter, integer part */
|
|
u32 rho2; /* Rho * Rho, integer part */
|
|
u32 rho_3ls; /* Rho parameter, <<3 */
|
|
u32 rho2_7ls; /* Rho^2, <<7 */
|
|
u32 minrtt; /* Minimum smoothed round trip time value seen */
|
|
};
|
|
|
|
/* Hybla reference round trip time (default= 1/40 sec = 25 ms),
|
|
expressed in jiffies */
|
|
static int rtt0 = 25;
|
|
module_param(rtt0, int, 0644);
|
|
MODULE_PARM_DESC(rtt0, "reference rout trip time (ms)");
|
|
|
|
|
|
/* This is called to refresh values for hybla parameters */
|
|
static inline void hybla_recalc_param (struct sock *sk)
|
|
{
|
|
struct hybla *ca = inet_csk_ca(sk);
|
|
|
|
ca->rho_3ls = max_t(u32, tcp_sk(sk)->srtt / msecs_to_jiffies(rtt0), 8);
|
|
ca->rho = ca->rho_3ls >> 3;
|
|
ca->rho2_7ls = (ca->rho_3ls * ca->rho_3ls) << 1;
|
|
ca->rho2 = ca->rho2_7ls >>7;
|
|
}
|
|
|
|
static void hybla_init(struct sock *sk)
|
|
{
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
|
struct hybla *ca = inet_csk_ca(sk);
|
|
|
|
ca->rho = 0;
|
|
ca->rho2 = 0;
|
|
ca->rho_3ls = 0;
|
|
ca->rho2_7ls = 0;
|
|
ca->snd_cwnd_cents = 0;
|
|
ca->hybla_en = 1;
|
|
tp->snd_cwnd = 2;
|
|
tp->snd_cwnd_clamp = 65535;
|
|
|
|
/* 1st Rho measurement based on initial srtt */
|
|
hybla_recalc_param(sk);
|
|
|
|
/* set minimum rtt as this is the 1st ever seen */
|
|
ca->minrtt = tp->srtt;
|
|
tp->snd_cwnd = ca->rho;
|
|
}
|
|
|
|
static void hybla_state(struct sock *sk, u8 ca_state)
|
|
{
|
|
struct hybla *ca = inet_csk_ca(sk);
|
|
ca->hybla_en = (ca_state == TCP_CA_Open);
|
|
}
|
|
|
|
static inline u32 hybla_fraction(u32 odds)
|
|
{
|
|
static const u32 fractions[] = {
|
|
128, 139, 152, 165, 181, 197, 215, 234,
|
|
};
|
|
|
|
return (odds < ARRAY_SIZE(fractions)) ? fractions[odds] : 128;
|
|
}
|
|
|
|
/* TCP Hybla main routine.
|
|
* This is the algorithm behavior:
|
|
* o Recalc Hybla parameters if min_rtt has changed
|
|
* o Give cwnd a new value based on the model proposed
|
|
* o remember increments <1
|
|
*/
|
|
static void hybla_cong_avoid(struct sock *sk, u32 ack, u32 rtt,
|
|
u32 in_flight, int flag)
|
|
{
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
|
struct hybla *ca = inet_csk_ca(sk);
|
|
u32 increment, odd, rho_fractions;
|
|
int is_slowstart = 0;
|
|
|
|
/* Recalculate rho only if this srtt is the lowest */
|
|
if (tp->srtt < ca->minrtt){
|
|
hybla_recalc_param(sk);
|
|
ca->minrtt = tp->srtt;
|
|
}
|
|
|
|
if (!ca->hybla_en)
|
|
return tcp_reno_cong_avoid(sk, ack, rtt, in_flight, flag);
|
|
|
|
if (in_flight < tp->snd_cwnd)
|
|
return;
|
|
|
|
if (ca->rho == 0)
|
|
hybla_recalc_param(sk);
|
|
|
|
rho_fractions = ca->rho_3ls - (ca->rho << 3);
|
|
|
|
if (tp->snd_cwnd < tp->snd_ssthresh) {
|
|
/*
|
|
* slow start
|
|
* INC = 2^RHO - 1
|
|
* This is done by splitting the rho parameter
|
|
* into 2 parts: an integer part and a fraction part.
|
|
* Inrement<<7 is estimated by doing:
|
|
* [2^(int+fract)]<<7
|
|
* that is equal to:
|
|
* (2^int) * [(2^fract) <<7]
|
|
* 2^int is straightly computed as 1<<int,
|
|
* while we will use hybla_slowstart_fraction_increment() to
|
|
* calculate 2^fract in a <<7 value.
|
|
*/
|
|
is_slowstart = 1;
|
|
increment = ((1 << ca->rho) * hybla_fraction(rho_fractions))
|
|
- 128;
|
|
} else {
|
|
/*
|
|
* congestion avoidance
|
|
* INC = RHO^2 / W
|
|
* as long as increment is estimated as (rho<<7)/window
|
|
* it already is <<7 and we can easily count its fractions.
|
|
*/
|
|
increment = ca->rho2_7ls / tp->snd_cwnd;
|
|
if (increment < 128)
|
|
tp->snd_cwnd_cnt++;
|
|
}
|
|
|
|
odd = increment % 128;
|
|
tp->snd_cwnd += increment >> 7;
|
|
ca->snd_cwnd_cents += odd;
|
|
|
|
/* check when fractions goes >=128 and increase cwnd by 1. */
|
|
while(ca->snd_cwnd_cents >= 128) {
|
|
tp->snd_cwnd++;
|
|
ca->snd_cwnd_cents -= 128;
|
|
tp->snd_cwnd_cnt = 0;
|
|
}
|
|
|
|
/* clamp down slowstart cwnd to ssthresh value. */
|
|
if (is_slowstart)
|
|
tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);
|
|
|
|
tp->snd_cwnd = min_t(u32, tp->snd_cwnd, tp->snd_cwnd_clamp);
|
|
}
|
|
|
|
static struct tcp_congestion_ops tcp_hybla = {
|
|
.init = hybla_init,
|
|
.ssthresh = tcp_reno_ssthresh,
|
|
.min_cwnd = tcp_reno_min_cwnd,
|
|
.cong_avoid = hybla_cong_avoid,
|
|
.set_state = hybla_state,
|
|
|
|
.owner = THIS_MODULE,
|
|
.name = "hybla"
|
|
};
|
|
|
|
static int __init hybla_register(void)
|
|
{
|
|
BUG_ON(sizeof(struct hybla) > ICSK_CA_PRIV_SIZE);
|
|
return tcp_register_congestion_control(&tcp_hybla);
|
|
}
|
|
|
|
static void __exit hybla_unregister(void)
|
|
{
|
|
tcp_unregister_congestion_control(&tcp_hybla);
|
|
}
|
|
|
|
module_init(hybla_register);
|
|
module_exit(hybla_unregister);
|
|
|
|
MODULE_AUTHOR("Daniele Lacamera");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("TCP Hybla");
|