nuttx/net/tcp/tcp_cc.c

/****************************************************************************
 * net/tcp/tcp_cc.c
 * Handling TCP congestion control
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <debug.h>

#include "tcp/tcp.h"

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define TCP_IPV4_DEFAULT_MSS 536

/* Initial Window threshold constants */

#define IW_MAX 4380          /* Initial Window maximum */
#define IW_MAX_HALF 2190
#define IW_MAX_QUATER 1095

/* Calculate the Initial Window, also used as Restart Window
 * RFC5681 Section 3.1 specifies the default conservative values.
 */

#define CC_INIT_CWND(cwnd, mss) \
 do { \
  if ((mss) > IW_MAX_HALF) \
    { \
      (cwnd) = 2 * (mss); \
    } \
  else if ((mss) > IW_MAX_QUATER) \
    { \
      (cwnd) = 3 * (mss); \
    } \
  else \
    { \
      (cwnd) = 4 * (mss); \
    } \
 } while(0)

/* Increments a size inc and holds at max value rather than rollover. */

#define CC_CWND_INC(wnd, inc) \
 do { \
  if ((uint32_t)((wnd) + (inc)) >= (wnd)) \
    { \
      (wnd) = (uint32_t)((wnd) + (inc)); \
    } \
  else \
    { \
      (wnd) = (uint32_t)-1; \
    } \
 } while(0)

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: tcp_cc_init
 *
 * Description:
 *   Initialize the congestion control variables, cwnd, ssthresh and dupacks.
 *   The function is called on starting a new connection.
 *
 * Input Parameters:
 *   conn   - The TCP connection of interest
 *
 * Returned Value:
 *   None
 *
 * Assumptions:
 *   The normal user level code is calling the connect/accept to start a new
 *   connection.
 *
 ****************************************************************************/

void tcp_cc_init(FAR struct tcp_conn_s *conn)
{
  CC_INIT_CWND(conn->cwnd, conn->mss);

  /* RFC 5681 recommends setting ssthresh arbitrarily high and
   * gives an example of using the largest advertised receive window.
   * We've seen complications with receiving TCPs that use window
   * scaling and/or window auto-tuning where the initial advertised
   * window is very small and then grows rapidly once the connection
   * is established. To avoid these complications, we set ssthresh to
   * the largest effective cwnd (amount of in-flight data) that the
   * sender can have.
   */

  conn->ssthresh = 2 * TCP_IPV4_DEFAULT_MSS;
  conn->dupacks = 0;
}

/****************************************************************************
 * Name: tcp_cc_update
 *
 * Description:
 *   Update the congestion control variables when recieve the SYNACK/ACK
 *   packet from the peer in the connection phase.
 *
 * Input Parameters:
 *   conn   - The TCP connection of interest
 *   tcp    - The TCP header.
 *
 * Returned Value:
 *   None
 *
 * Assumptions:
 *   The network is locked.
 *
 ****************************************************************************/

void tcp_cc_update(FAR struct tcp_conn_s *conn, FAR struct tcp_hdr_s *tcp)
{
  /* After Fast retransmitted, set ssthresh to the maximum of
   * the unacked and the 2*SMSS, and enter to Fast Recovery.
   * ssthresh = max (FlightSize / 2, 2*SMSS) referring to rfc5681
   * cwnd=ssthresh + 3*SMSS  referring to rfc5681
   */

  if (conn->flags & TCP_INFT)
    {
      conn->ssthresh = MAX(conn->tx_unacked / 2, 2 * conn->mss);
      conn->cwnd = conn->ssthresh + 3 * conn->mss;

      conn->flags &= ~TCP_INFT;
      conn->flags |= TCP_INFR;
    }

  /* Update the cc parameters in the TCP_SYN_RCVD and TCP_SYN_SENT states
   * when the tcp connection is established.
   */

  else
    {
      conn->last_ackno = tcp_getsequence(tcp->ackno);
      CC_INIT_CWND(conn->cwnd, conn->mss);
      conn->max_cwnd = conn->snd_wnd;
      conn->ssthresh = MAX(conn->snd_wnd, conn->ssthresh);
    }
}

/****************************************************************************
 * Name: tcp_cc_recv_ack
 *
 * Description:
 *   Update congestion control variables
 *
 * Input Parameters:
 *   conn   - The TCP connection of interest
 *   tcp    - The TCP header.
 *
 * Returned Value:
 *   None
 *
 * Assumptions:
 *   The network is locked.
 *
 ****************************************************************************/

void tcp_cc_recv_ack(FAR struct tcp_conn_s *conn, FAR struct tcp_hdr_s *tcp)
{
  uint32_t ackno = tcp_getsequence(tcp->ackno);

  /* Its only a duplicate ack if:
   * 1) It doesn't ACK new data
   * 2) There is outstanding unacknowledged data (retransmission
   *    timer running)
   * 3) The ACK is == biggest ACK sequence number so far (last_ackno)
   *
   * If it passes all conditions, should process as a dupack:
   * a) dupacks < 3: do nothing
   * b) dupacks == 3: fast retransmit
   * c) dupacks > 3: increase cwnd
   *
   * If ackno is between last_ackno and snd_seq, should reset dupack counter.
   */

  /* Clause 1 */

  if (TCP_SEQ_LTE(ackno, conn->last_ackno))
    {
      /* Clause 2 and Clause 3 */

      if (conn->timer >= 0 &&
          conn->last_ackno == ackno)
        {
          if (++conn->dupacks > TCP_FAST_RETRANSMISSION_THRESH)
            {
              /* Inflate the congestion window */

              CC_CWND_INC(conn->cwnd, conn->mss);
            }

          if (conn->dupacks >= TCP_FAST_RETRANSMISSION_THRESH)
            {
              /* Do fast retransmit, but it is delayed in
               * psock_send_eventhandler. Set the TCP_INFT flag.
               */

              conn->flags |= TCP_INFT;
              conn->fr_recover = tcp_getsequence(conn->sndseq);
            }
        }
    }
  else if (TCP_SEQ_GT(ackno, conn->last_ackno) &&
           TCP_SEQ_LTE(ackno, tcp_getsequence(conn->sndseq)))
    {
      /* We come here when the ACK acknowledges new data. */

      uint32_t acked = TCP_SEQ_SUB(ackno, conn->last_ackno);

      /* Reset dupacks and update last_ackno. */

      conn->dupacks = 0;
      conn->last_ackno = ackno;

      /* When the ackno covers more than the fr_recover, exit the
       * fast recovery. Then, reset the "IN Fast Recovery" flags.
       * Also reset the congestion window to the slow start threshold.
       * If not, cwnd should be increased by mss. RFC6582.
       */

      if (conn->flags & TCP_INFR)
        {
          if (ackno - 1 > conn->fr_recover)
            {
              /* Reset the fast retransmit variables. */

              conn->flags &= ~TCP_INFR;
              conn->cwnd = conn->ssthresh;
            }
          else
            {
              CC_CWND_INC(conn->cwnd, conn->mss);
              return;
            }
        }

      /* Update the congestion control variables (cwnd and ssthresh). */

      if (conn->tcpstateflags >= TCP_ESTABLISHED)
        {
          uint32_t increase;

          if (conn->cwnd < conn->ssthresh)
            {
              /* slow start (RFC 5681):
               * Grow cwnd exponentially by maxseg(smss) per ACK.
               */

              increase = acked > 0 ? MIN(acked, conn->mss) : conn->mss;

              CC_CWND_INC(conn->cwnd, increase);
              ninfo("update slow start cwnd to %u\n", conn->cwnd);
            }
          else
            {
              /* cong avoid (RFC 5681):
               * Grow cwnd linearly by approximately maxseg per RTT using
               * maxseg^2 / cwnd per ACK as the increment.
               * If cwnd > maxseg^2, fix the cwnd increment at 1 byte to
               * avoid capping cwnd.
               */

              increase = MAX((conn->mss * conn->mss / conn->cwnd), 1);

              CC_CWND_INC(conn->cwnd, increase);
              conn->cwnd = MIN(conn->cwnd, conn->max_cwnd);
              ninfo("update congestion avoidance cwnd to %u\n", conn->cwnd);
            }
        }
    }
}