mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-17 01:04:19 +08:00
d2ccd7bc8a
The recent fix of acking immediately in DCTCP on CE status change has an undesirable side-effect: it also resets TCP ack timer and disables pingpong mode (interactive session). But the CE status change has nothing to do with them. This patch addresses that by using the new one-time immediate ACK flag instead of calling tcp_enter_quickack_mode(). Signed-off-by: Yuchung Cheng <ycheng@google.com> Signed-off-by: Neal Cardwell <ncardwell@google.com> Signed-off-by: Wei Wang <weiwan@google.com> Signed-off-by: Eric Dumazet <edumazet@google.com> Signed-off-by: David S. Miller <davem@davemloft.net>
321 lines
9.0 KiB
C
321 lines
9.0 KiB
C
/* DataCenter TCP (DCTCP) congestion control.
|
|
*
|
|
* http://simula.stanford.edu/~alizade/Site/DCTCP.html
|
|
*
|
|
* This is an implementation of DCTCP over Reno, an enhancement to the
|
|
* TCP congestion control algorithm designed for data centers. DCTCP
|
|
* leverages Explicit Congestion Notification (ECN) in the network to
|
|
* provide multi-bit feedback to the end hosts. DCTCP's goal is to meet
|
|
* the following three data center transport requirements:
|
|
*
|
|
* - High burst tolerance (incast due to partition/aggregate)
|
|
* - Low latency (short flows, queries)
|
|
* - High throughput (continuous data updates, large file transfers)
|
|
* with commodity shallow buffered switches
|
|
*
|
|
* The algorithm is described in detail in the following two papers:
|
|
*
|
|
* 1) Mohammad Alizadeh, Albert Greenberg, David A. Maltz, Jitendra Padhye,
|
|
* Parveen Patel, Balaji Prabhakar, Sudipta Sengupta, and Murari Sridharan:
|
|
* "Data Center TCP (DCTCP)", Data Center Networks session
|
|
* Proc. ACM SIGCOMM, New Delhi, 2010.
|
|
* http://simula.stanford.edu/~alizade/Site/DCTCP_files/dctcp-final.pdf
|
|
*
|
|
* 2) Mohammad Alizadeh, Adel Javanmard, and Balaji Prabhakar:
|
|
* "Analysis of DCTCP: Stability, Convergence, and Fairness"
|
|
* Proc. ACM SIGMETRICS, San Jose, 2011.
|
|
* http://simula.stanford.edu/~alizade/Site/DCTCP_files/dctcp_analysis-full.pdf
|
|
*
|
|
* Initial prototype from Abdul Kabbani, Masato Yasuda and Mohammad Alizadeh.
|
|
*
|
|
* Authors:
|
|
*
|
|
* Daniel Borkmann <dborkman@redhat.com>
|
|
* Florian Westphal <fw@strlen.de>
|
|
* Glenn Judd <glenn.judd@morganstanley.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
* your option) any later version.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/mm.h>
|
|
#include <net/tcp.h>
|
|
#include <linux/inet_diag.h>
|
|
|
|
#define DCTCP_MAX_ALPHA 1024U
|
|
|
|
struct dctcp {
|
|
u32 acked_bytes_ecn;
|
|
u32 acked_bytes_total;
|
|
u32 prior_snd_una;
|
|
u32 prior_rcv_nxt;
|
|
u32 dctcp_alpha;
|
|
u32 next_seq;
|
|
u32 ce_state;
|
|
u32 loss_cwnd;
|
|
};
|
|
|
|
static unsigned int dctcp_shift_g __read_mostly = 4; /* g = 1/2^4 */
|
|
module_param(dctcp_shift_g, uint, 0644);
|
|
MODULE_PARM_DESC(dctcp_shift_g, "parameter g for updating dctcp_alpha");
|
|
|
|
static unsigned int dctcp_alpha_on_init __read_mostly = DCTCP_MAX_ALPHA;
|
|
module_param(dctcp_alpha_on_init, uint, 0644);
|
|
MODULE_PARM_DESC(dctcp_alpha_on_init, "parameter for initial alpha value");
|
|
|
|
static unsigned int dctcp_clamp_alpha_on_loss __read_mostly;
|
|
module_param(dctcp_clamp_alpha_on_loss, uint, 0644);
|
|
MODULE_PARM_DESC(dctcp_clamp_alpha_on_loss,
|
|
"parameter for clamping alpha on loss");
|
|
|
|
static struct tcp_congestion_ops dctcp_reno;
|
|
|
|
static void dctcp_reset(const struct tcp_sock *tp, struct dctcp *ca)
|
|
{
|
|
ca->next_seq = tp->snd_nxt;
|
|
|
|
ca->acked_bytes_ecn = 0;
|
|
ca->acked_bytes_total = 0;
|
|
}
|
|
|
|
static void dctcp_init(struct sock *sk)
|
|
{
|
|
const struct tcp_sock *tp = tcp_sk(sk);
|
|
|
|
if ((tp->ecn_flags & TCP_ECN_OK) ||
|
|
(sk->sk_state == TCP_LISTEN ||
|
|
sk->sk_state == TCP_CLOSE)) {
|
|
struct dctcp *ca = inet_csk_ca(sk);
|
|
|
|
ca->prior_snd_una = tp->snd_una;
|
|
ca->prior_rcv_nxt = tp->rcv_nxt;
|
|
|
|
ca->dctcp_alpha = min(dctcp_alpha_on_init, DCTCP_MAX_ALPHA);
|
|
|
|
ca->loss_cwnd = 0;
|
|
ca->ce_state = 0;
|
|
|
|
dctcp_reset(tp, ca);
|
|
return;
|
|
}
|
|
|
|
/* No ECN support? Fall back to Reno. Also need to clear
|
|
* ECT from sk since it is set during 3WHS for DCTCP.
|
|
*/
|
|
inet_csk(sk)->icsk_ca_ops = &dctcp_reno;
|
|
INET_ECN_dontxmit(sk);
|
|
}
|
|
|
|
static u32 dctcp_ssthresh(struct sock *sk)
|
|
{
|
|
struct dctcp *ca = inet_csk_ca(sk);
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
|
|
|
ca->loss_cwnd = tp->snd_cwnd;
|
|
return max(tp->snd_cwnd - ((tp->snd_cwnd * ca->dctcp_alpha) >> 11U), 2U);
|
|
}
|
|
|
|
/* Minimal DCTP CE state machine:
|
|
*
|
|
* S: 0 <- last pkt was non-CE
|
|
* 1 <- last pkt was CE
|
|
*/
|
|
|
|
static void dctcp_ce_state_0_to_1(struct sock *sk)
|
|
{
|
|
struct dctcp *ca = inet_csk_ca(sk);
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
|
|
|
if (!ca->ce_state) {
|
|
/* State has changed from CE=0 to CE=1, force an immediate
|
|
* ACK to reflect the new CE state. If an ACK was delayed,
|
|
* send that first to reflect the prior CE state.
|
|
*/
|
|
if (inet_csk(sk)->icsk_ack.pending & ICSK_ACK_TIMER)
|
|
__tcp_send_ack(sk, ca->prior_rcv_nxt);
|
|
inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_NOW;
|
|
}
|
|
|
|
ca->prior_rcv_nxt = tp->rcv_nxt;
|
|
ca->ce_state = 1;
|
|
|
|
tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
|
|
}
|
|
|
|
static void dctcp_ce_state_1_to_0(struct sock *sk)
|
|
{
|
|
struct dctcp *ca = inet_csk_ca(sk);
|
|
struct tcp_sock *tp = tcp_sk(sk);
|
|
|
|
if (ca->ce_state) {
|
|
/* State has changed from CE=1 to CE=0, force an immediate
|
|
* ACK to reflect the new CE state. If an ACK was delayed,
|
|
* send that first to reflect the prior CE state.
|
|
*/
|
|
if (inet_csk(sk)->icsk_ack.pending & ICSK_ACK_TIMER)
|
|
__tcp_send_ack(sk, ca->prior_rcv_nxt);
|
|
inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_NOW;
|
|
}
|
|
|
|
ca->prior_rcv_nxt = tp->rcv_nxt;
|
|
ca->ce_state = 0;
|
|
|
|
tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
|
|
}
|
|
|
|
static void dctcp_update_alpha(struct sock *sk, u32 flags)
|
|
{
|
|
const struct tcp_sock *tp = tcp_sk(sk);
|
|
struct dctcp *ca = inet_csk_ca(sk);
|
|
u32 acked_bytes = tp->snd_una - ca->prior_snd_una;
|
|
|
|
/* If ack did not advance snd_una, count dupack as MSS size.
|
|
* If ack did update window, do not count it at all.
|
|
*/
|
|
if (acked_bytes == 0 && !(flags & CA_ACK_WIN_UPDATE))
|
|
acked_bytes = inet_csk(sk)->icsk_ack.rcv_mss;
|
|
if (acked_bytes) {
|
|
ca->acked_bytes_total += acked_bytes;
|
|
ca->prior_snd_una = tp->snd_una;
|
|
|
|
if (flags & CA_ACK_ECE)
|
|
ca->acked_bytes_ecn += acked_bytes;
|
|
}
|
|
|
|
/* Expired RTT */
|
|
if (!before(tp->snd_una, ca->next_seq)) {
|
|
u64 bytes_ecn = ca->acked_bytes_ecn;
|
|
u32 alpha = ca->dctcp_alpha;
|
|
|
|
/* alpha = (1 - g) * alpha + g * F */
|
|
|
|
alpha -= min_not_zero(alpha, alpha >> dctcp_shift_g);
|
|
if (bytes_ecn) {
|
|
/* If dctcp_shift_g == 1, a 32bit value would overflow
|
|
* after 8 Mbytes.
|
|
*/
|
|
bytes_ecn <<= (10 - dctcp_shift_g);
|
|
do_div(bytes_ecn, max(1U, ca->acked_bytes_total));
|
|
|
|
alpha = min(alpha + (u32)bytes_ecn, DCTCP_MAX_ALPHA);
|
|
}
|
|
/* dctcp_alpha can be read from dctcp_get_info() without
|
|
* synchro, so we ask compiler to not use dctcp_alpha
|
|
* as a temporary variable in prior operations.
|
|
*/
|
|
WRITE_ONCE(ca->dctcp_alpha, alpha);
|
|
dctcp_reset(tp, ca);
|
|
}
|
|
}
|
|
|
|
static void dctcp_state(struct sock *sk, u8 new_state)
|
|
{
|
|
if (dctcp_clamp_alpha_on_loss && new_state == TCP_CA_Loss) {
|
|
struct dctcp *ca = inet_csk_ca(sk);
|
|
|
|
/* If this extension is enabled, we clamp dctcp_alpha to
|
|
* max on packet loss; the motivation is that dctcp_alpha
|
|
* is an indicator to the extend of congestion and packet
|
|
* loss is an indicator of extreme congestion; setting
|
|
* this in practice turned out to be beneficial, and
|
|
* effectively assumes total congestion which reduces the
|
|
* window by half.
|
|
*/
|
|
ca->dctcp_alpha = DCTCP_MAX_ALPHA;
|
|
}
|
|
}
|
|
|
|
static void dctcp_cwnd_event(struct sock *sk, enum tcp_ca_event ev)
|
|
{
|
|
switch (ev) {
|
|
case CA_EVENT_ECN_IS_CE:
|
|
dctcp_ce_state_0_to_1(sk);
|
|
break;
|
|
case CA_EVENT_ECN_NO_CE:
|
|
dctcp_ce_state_1_to_0(sk);
|
|
break;
|
|
default:
|
|
/* Don't care for the rest. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
static size_t dctcp_get_info(struct sock *sk, u32 ext, int *attr,
|
|
union tcp_cc_info *info)
|
|
{
|
|
const struct dctcp *ca = inet_csk_ca(sk);
|
|
|
|
/* Fill it also in case of VEGASINFO due to req struct limits.
|
|
* We can still correctly retrieve it later.
|
|
*/
|
|
if (ext & (1 << (INET_DIAG_DCTCPINFO - 1)) ||
|
|
ext & (1 << (INET_DIAG_VEGASINFO - 1))) {
|
|
memset(&info->dctcp, 0, sizeof(info->dctcp));
|
|
if (inet_csk(sk)->icsk_ca_ops != &dctcp_reno) {
|
|
info->dctcp.dctcp_enabled = 1;
|
|
info->dctcp.dctcp_ce_state = (u16) ca->ce_state;
|
|
info->dctcp.dctcp_alpha = ca->dctcp_alpha;
|
|
info->dctcp.dctcp_ab_ecn = ca->acked_bytes_ecn;
|
|
info->dctcp.dctcp_ab_tot = ca->acked_bytes_total;
|
|
}
|
|
|
|
*attr = INET_DIAG_DCTCPINFO;
|
|
return sizeof(info->dctcp);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static u32 dctcp_cwnd_undo(struct sock *sk)
|
|
{
|
|
const struct dctcp *ca = inet_csk_ca(sk);
|
|
|
|
return max(tcp_sk(sk)->snd_cwnd, ca->loss_cwnd);
|
|
}
|
|
|
|
static struct tcp_congestion_ops dctcp __read_mostly = {
|
|
.init = dctcp_init,
|
|
.in_ack_event = dctcp_update_alpha,
|
|
.cwnd_event = dctcp_cwnd_event,
|
|
.ssthresh = dctcp_ssthresh,
|
|
.cong_avoid = tcp_reno_cong_avoid,
|
|
.undo_cwnd = dctcp_cwnd_undo,
|
|
.set_state = dctcp_state,
|
|
.get_info = dctcp_get_info,
|
|
.flags = TCP_CONG_NEEDS_ECN,
|
|
.owner = THIS_MODULE,
|
|
.name = "dctcp",
|
|
};
|
|
|
|
static struct tcp_congestion_ops dctcp_reno __read_mostly = {
|
|
.ssthresh = tcp_reno_ssthresh,
|
|
.cong_avoid = tcp_reno_cong_avoid,
|
|
.undo_cwnd = tcp_reno_undo_cwnd,
|
|
.get_info = dctcp_get_info,
|
|
.owner = THIS_MODULE,
|
|
.name = "dctcp-reno",
|
|
};
|
|
|
|
static int __init dctcp_register(void)
|
|
{
|
|
BUILD_BUG_ON(sizeof(struct dctcp) > ICSK_CA_PRIV_SIZE);
|
|
return tcp_register_congestion_control(&dctcp);
|
|
}
|
|
|
|
static void __exit dctcp_unregister(void)
|
|
{
|
|
tcp_unregister_congestion_control(&dctcp);
|
|
}
|
|
|
|
module_init(dctcp_register);
|
|
module_exit(dctcp_unregister);
|
|
|
|
MODULE_AUTHOR("Daniel Borkmann <dborkman@redhat.com>");
|
|
MODULE_AUTHOR("Florian Westphal <fw@strlen.de>");
|
|
MODULE_AUTHOR("Glenn Judd <glenn.judd@morganstanley.com>");
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_DESCRIPTION("DataCenter TCP (DCTCP)");
|