TCP Maintenance Working Group                                  M. Mathis
Internet-Draft                                               Google, Inc
Intended status: Experimental                              July 15, 2012
Expires: January 16, 2013

    Laminar TCP and the case for refactoring TCP congestion control


   The primary state variables used by all TCP congestion control
   algorithms, cwnd and ssthresh, are heavily overloaded, carrying
   different semantics in different states.  This leads to excess
   implementation complexity and poorly defined behaviors under some
   combinations of events, such as application stalls during loss
   recovery.  We propose a new framework for TCP congestion control, and
   to recast current standard algorithms to use new state variables.
   This new framework will not generally change the behavior of any of
   the primary congestion control algorithms when they are invoked in
   isolation.  It will permit new algorithms with better behaviors in
   many corner cases, such as when two distinct primary algorithms are
   invoked concurrently.  It will also foster the creation of new
   algorithms to address some events that are poorly treated by today's
   standards.  For the vast majority of traditional algorithms the
   transformation to the new state variables is completely
   straightforward.  However, the resulting implementation is likely to
   technically be in violation of existing TCP standards, even if it is
   fully compliant with their principles and intent.

Status of this Memo

   This Internet-Draft is submitted in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."

   This Internet-Draft will expire on January 16, 2013.

Copyright Notice

Mathis                  Expires January 16, 2013                [Page 1]

Internet-Draft                 Laminar TCP                     July 2012

   Copyright (c) 2012 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   ( in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Table of Contents

   1.  Introduction . . . . . . . . . . . . . . . . . . . . . . . . .  3
   2.  Overview of the new algorithm  . . . . . . . . . . . . . . . .  3
   3.  Standards Impact . . . . . . . . . . . . . . . . . . . . . . .  4
   4.  Meta Language  . . . . . . . . . . . . . . . . . . . . . . . .  5
   5.  State variables and definitions  . . . . . . . . . . . . . . .  6
   6.  Updated Algorithms . . . . . . . . . . . . . . . . . . . . . .  6
     6.1.  Congestion avoidance . . . . . . . . . . . . . . . . . . .  7
     6.2.  Proportional Rate Reduction  . . . . . . . . . . . . . . .  8
     6.3.  Restart after idle, Congestion Window Validation and
           Pacing . . . . . . . . . . . . . . . . . . . . . . . . . .  8
     6.4.  RTO and F-RTO  . . . . . . . . . . . . . . . . . . . . . .  9
     6.5.  Undo . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
     6.6.  Control Block Interdependence  . . . . . . . . . . . . . . 10
     6.7.  New Reno . . . . . . . . . . . . . . . . . . . . . . . . . 10
   7.  Example Pseudocode . . . . . . . . . . . . . . . . . . . . . . 11
   8.  Compatibility with existing implementations  . . . . . . . . . 12
   9.  Security Considerations  . . . . . . . . . . . . . . . . . . . 13
   10. IANA Considerations  . . . . . . . . . . . . . . . . . . . . . 14
   11. References . . . . . . . . . . . . . . . . . . . . . . . . . . 14
   Author's Address . . . . . . . . . . . . . . . . . . . . . . . . . 15

Mathis                  Expires January 16, 2013                [Page 2]

Internet-Draft                 Laminar TCP                     July 2012

1.  Introduction

   The primary state variables used by all TCP congestion control
   algorithms, cwnd and ssthresh, are heavily overloaded, carrying
   different semantics in different states.  Multiple algorithms sharing
   the same state variables lead to excess complexity, conflicting
   correctness constraints, and makes it unreasonably difficult to
   implement, test and evaluate new algorithms.

   We are proposing a new framework for TCP congestion control that
   separate transmission scheduling, which determines precisely when
   data is sent, from pure congestion control, which determines the
   amount of data to be sent in each RTT.  This separation is
   implemented with new state variables and greatly simplifies the
   interactions between the two subsystems.  It permits vast range of
   new algorithms that are not feasible with the current

   This note describes the new framework and presents a preliminary
   mapping between current standards and new algorithms based on the new
   state variables.  At this point the new algorithms are not fully
   specified, and many have still unconstrained design choices.  In most
   cases, our goal is to precisely mimic today's standard TCP, at least
   as far as well defined primary behaviors.  In general, it is a non-
   goal to mimic behaviors in poorly defined corner cases, or other
   cases where standard behaviors are viewed as being problematic.

   It is called Laminar because one of its design goals is to eliminate
   unnecessary turbulence introduced by TCP itself.

2.  Overview of the new algorithm

   The new framework separates transmission scheduling, which determines
   precisely when data is sent, from pure Congestion Control, which
   determines the total amount of data sent in any given RTT.

   The default algorithm for transmission scheduling is a strict
   implementation of Van Jacobsons' packet conservation principle
   [Jacobson88].  Data arriving at the receiver cause ACKs which in turn
   cause the sender to transmit an equivalent quantity of data back into
   the network.  The primary state variable is implicit in the quantity
   of data and ACKs circulating in the network.  This state observed
   through an improved "total_pipe" estimator, which is based on "pipe"
   as described in RFC 3517 [RFC3517] but also includes the quantity of
   data reported by the current ACK and pending transmissions that have
   passed congestion control but are waiting for other events such as

Mathis                  Expires January 16, 2013                [Page 3]

Internet-Draft                 Laminar TCP                     July 2012

   A new state variable, CCwin, is the primary congestion control state
   variable.  It is updated only by the congestion control algorithms,
   which are concerned with detecting and regulating the overall level
   of congestion along the path.  CCwin is TCP's best estimate for an
   appropriate average window size.  In general, it rises when the
   network seem to be underfilled and is reduced in the presence of
   congestion signals, such as loss, ECN marks or increased delay.
   Although CCwin resembles cwnd, cwnd is overloaded and used by
   multiple algorithms (such as burst suppression) with different and
   sometimes conflicting goals.

   Any time total_pipe is different from CCwin the transmission
   scheduling algorithm slightly adjusts the number of segments sent in
   response to each ACK.  Slow start and Proportional Rate Reduction
   [PRRid] are both embedded in the transmission scheduling algorithm.

   If CCwin is larger than total_pipe, the default algorithm to grow
   total_pipe is for each ACK to trigger one segment of additional data.
   This is essentially an implicit slowstart, but it is gated by the
   difference between CCwin and total_pipe, rather than the difference
   between cwnd and ssthresh.  In the future, additional algorithms such
   as pacing, might be used to raise total_pipe.

   During Fast Retransmit, the congestion control algorithm, such as
   CUBIC, generally reduces CCwin in a single step.  Proportional Rate
   Reduction [PRRid] is used to gradually reduce total_pipe to agree
   with CCwin.  PRR was based on Laminar principles, so its
   specification has many parallels to this document.

   Connection startup is accomplished as follows: CCwin is set to
   MAX_WIN (akin to ssthresh), and IW segments are transmitted.  The
   ACKs from these segments trigger additional data transmissions, and
   slowstart proceeds as it does today.  The very first congestion event
   is a special case because there is not a prior value for CCwin.  By
   default and on the first congestion event only, CCwin would be set
   from total_pipe, and then standard congestion control is invoked.

   The primary advantage of the Laminar framework is that by
   partitioning congestion control and transmission scheduling into
   separate subsystems, each is subject to simpler design constraints,
   making it far easier to develop many new algorithms that are not
   feasible with the current organization of the code.

3.  Standards Impact

   Since we are proposing to refactor existing standards into new state
   variables, all of the current congestion control standards documents

Mathis                  Expires January 16, 2013                [Page 4]

Internet-Draft                 Laminar TCP                     July 2012

   will potentially need to be reviewed.  Although there are roughly 60
   RFCs that mention cwnd or ssthresh, most only need self evident
   reinterpretation.  Others, such as MIBs, warrant a sentence or two
   clarifying how to map CCwin and total_pipe onto existing
   specifications that use cwnd and ssthresh.  There are however several
   RFCs that explicitly address the interplay between cwnd and ssthresh
   in today's TCP, including RFC 5681 [RFC5681], RFC 5682 [RFC5682], RFC
   4015 [RFC4015], and RFC 6582 [RFC6582].  These need to be reviewed
   more carefully.  In most cases the algorithms can easily be restated
   under the Laminar framework.  Others, such as Congestion Window
   Validation [RFC2861], potentially require redesign.

   This document does not propose to change the TCP friendly paradigm
   [RFC2914].  By default all updated algorithms using these new state
   variables would have behaviors similar to the current TCP
   implementations, however over the longer term the intent is to permit
   new algorithms that are not feasible today.  For example, since CCwin
   does not directly affect transmissions during recovery, it is
   straightforward to permit recovery ACKs to raise CCwin even while PRR
   is reducing total_pipe.  This facilitates so called "fluid model"
   algorithms which further decouple congestion control from the details
   of the TCP the protocol.

   But even without these advanced algorithms, we do anticipate some
   second order effects.  For example while testing PRR it was observed
   that suppressing bursts by slightly delaying transmissions can
   improve average performance, even though in a strict sense the new
   algorithm is less aggressive than the old [IMC11PRR].

4.  Meta Language

   We use the following terms when describing algorithms and their

   Standard - The current state of the art, including both formal
   standards and widely deployed algorithms that have come into standard
   use, even though they may not be formally specified.  [Although PRR
   does not yet technically meet these criteria, we include it here].

   default - The simplest or most straightforward algorithm that fits
   within the Laminar framework.  For example implicit slowstart
   whenever total_pipe is less than CCwin.  This term does not make a
   statment about the relative aggressiveness or any other properties of
   the algorithm except that it is a reasonable choice and
   straightforward to implement.

   conformant - An algorithm that can produce the same packet trace as a

Mathis                  Expires January 16, 2013                [Page 5]

Internet-Draft                 Laminar TCP                     July 2012

   TCP implementation that strictly conforms to the current standards.

   mimic - An algorithm constructed to be conformant to standards.

   opportunity - An algorithm that can do something better than the
   standard algorithm, typically better behavior in a corner cases that
   is either not well specified or where the standard behavior is viewed
   as being less than ideal.

   more/less aggressive - Any algorithm that sends segments earlier/
   later than another (typically conformant) algorithm under identical
   sequences of events.  Note that this is an evaluation of the packet
   level behavior, and does not reflect any higher order effects.

   Observed performance - A statement about algorithm performance based
   on a measurement study or other observations based on a significant
   sample of authentic Internet paths. e.g. an algorithm might have
   observed data rate that is different than another (typically
   conformant) algorithm.

   application stall - The application is failing to keep up with TCP:
   either the sender is running out of data to send, or the receiver is
   not reading it fast enough.  When there is an application stall,
   congestion control does not regulate data transmission and some of
   the protocol events are triggered by application reads or writes, as

5.  State variables and definitions

   CCwin - The primary congestion control state variable.

   DeliveredData - The total number of bytes that the current ACK
   indicates have been delivered to the receiver.  (See [PRRid] for more

   total_pipe - The total quantity of circulating data and ACKs.  In
   addition to RFC 3517 pipe, it includes DeliveredData for the current
   ack, plus any data held for delayed transmission, for example to
   permit a later TSO transmission.

   sendcnt - The quantity of data to be sent in response to the current
   ACK or other event.

6.  Updated Algorithms

   A survey of standard, common and proposed algorithms, and how they

Mathis                  Expires January 16, 2013                [Page 6]

Internet-Draft                 Laminar TCP                     July 2012

   might be reimplemented under the Laminar framework.

6.1.  Congestion avoidance

   Under the Laminar framework the loss recovery mechanism does not, by
   default, interfere with the primary congestion control algorithms.
   The CCwin state variable is updated only by the algorithms that
   decide how much data to send on successive round trips.  For example
   standard Reno AIMD congestion control [RFC5681] can be implemented by
   raising CCwin by one segment every CCwin worth of ACKs (once per RTT)
   and halving it on every loss or ECN signal (e.g.  CCwin = CCwin/2).
   During recovery the transmission scheduling part of the Laminar
   framework makes the necessary adjustments to bring total_pipe to
   agree with CCwin, without tampering with CCwin.

   This separation between computing CCwin and transmission scheduling
   will enable new classes of congestion control algorithms, such as
   fluid models that adjust CCwin on every ACK, even during recovery.
   This is safe because raising CCwin does not directly trigger any
   transmissions, it just steers the transmission scheduling closer to
   the end of recovery.  Fluid models have a number of advantages, such
   as simpler closed form mathematical representations, and are
   intrinsically more tolerant to reordering since non-recovery
   disordered states don't inhibit window growth.

   Investigating alternative algorithms and their impact is out of scope
   for this document.  It is important to note that while our goal here
   is not to alter the TCP friendly paradigm, Laminar does not include
   any implicit or explicit mechanism to prevent a Tragedy of the
   Commons.  However, see the comments in Section 9.

   The initial slowstart does not use CCwin, except that CCwin starts at
   the largest possible value.  It is the transmission scheduling
   algorithms that are responsible for performing the slowstart.  On the
   first loss it is necessary to compute a reasonable CCwin from
   total_pipe.  Ideally, we might save total_pipe at the time each
   segment is scheduled for transmission, and use the saved value
   associated with the lost segment to prime CCwin.  However, this
   approach requires extra state attached to every segment in the
   retransmit queue.  A simpler approach is to have a mathematical model
   the slowstart, and to prime CCwin from total_pipe at the time the
   loss is detected, but scaled down by the effective slowstart
   multiplier (e.g. 1.5 or 2).  In either case, once CCwin is primed
   from total_pipe, it is typically appropriate to invoke the reduction
   on loss function, to reduce it again per the congestion control

   Nearly all congestion control algorithms need to have some mechanism

Mathis                  Expires January 16, 2013                [Page 7]

Internet-Draft                 Laminar TCP                     July 2012

   to prevent CCwin from growing while it is not regulating
   transmissions e.g. during prolonged application stalls.

6.2.  Proportional Rate Reduction

   Since PRR [PRRid] was designed with Laminar principles in mind,
   updating it is a straightforward variable substitution.  CCwin
   replaces ssthresh, and RecoverFS is initialized from total_pipe at
   the beginning of recovery.  Thus PRR provides a gradual window
   reduction from the prior total_pipe down to the new CCwin.

   There is one important difference from the current standards: CCwin
   is computed solely on the basis of the prior value of CCwin.  Compare
   this to RFC 5681 which specifies that the congestion control function
   is computed on the basis of the FlightSize (e.g.
   ssthresh=FlightSize/2 ) This change from prior standard completely
   alters how application stalls interact with congestion control.

   Consider what happens if there is an application stall for most of
   the RTT just before a Fast Retransmit: Under Laminar it is likely
   that CCwin will be set to a value that is larger than total_pipe, and
   subject to available application data PRR will go directly to
   slowstart mode, to raise total_pipe up to CCwin.  Note that the final
   CCwin value does not depend on the duration of the application stall.

   With standard TCP, any application stall reduces the final value of
   cwnd at the end of recovery.  In some sense application stalls during
   recovery are treated as though they are additional losses, and have a
   detrimental effect on the connection data rate that lasts far longer
   than the stall itself.

   If there are no application stalls, the standard and Laminar variants
   of the PRR algorithm should have identical behaviors.  Although it is
   tempting to characterize Laminar as being more aggressive than the
   standards, it would be more apropos to characterize the standard as
   being excessively timid under certain combinations of overlapping
   events that are not well represented by benchmarks or models.

6.3.  Restart after idle, Congestion Window Validation and Pacing

   Decoupling congestion control from transmission scheduling permits us
   to develop new algorithms to raise total_pipe to CCwin after an
   application stall or other events.  Although it was stated earlier
   that the default transmission scheduling algorithm for raising
   total_pipe is an implicit slowstart, there is opportunity for better

   We imagine a class of hybrid transmission scheduling algorithms that

Mathis                  Expires January 16, 2013                [Page 8]

Internet-Draft                 Laminar TCP                     July 2012

   use a combination of pacing and slowstart to reestablish TCP's self
   clock.  (See [Visweswaraiah99].)  For example, whenever total_pipe is
   significantly below CCwin, RTT and CCwin can be used to directly
   compute a pacing rate.  We suspect that pacing at the previous full
   rate will prove to be somewhat brittle, sometimes causing excessive
   loss and yielding erratic results.  It is more likely that a hybrid
   strategy will work better and be better for the network, for example
   by pacing at some fraction (1/2 or 1/4) of the prior rate until
   total_pipe reaches some fraction of CCwin (e.g.  CCwin/2) and then
   using conventional slowstart to bring total_pipe the rest of the way
   up to CCwin.

   This is far less aggressive than standard TCP without cwnd validation
   [RFC2861] or when the application stall was less than one RTO, since
   standards permit TCP to send a full cwnd size burst in these
   situations.  It is potentially more aggressive than conventional
   slowstart invoked by cwnd validation when the application stall is
   longer than several RTOs.  Both standard behaviors in these
   situations have always been viewed as problematic, because interface
   rate bursts are clearly too aggressive and a full slowstart is
   clearly too conservative.  Mimicking either is a non-goal, when there
   is ample opportunity to find a better compromise.

   Although strictly speaking any new transmission scheduling algorithms
   are independent of the Laminar framework, they are expected to have
   substantially better behavior in many common environments and as such
   strongly motivate the effort required to refactor TCP implementations
   and standards.

6.4.  RTO and F-RTO

   We are not proposing any changes to the RTO timer or the F-RTO
   [RFC5682] algorithm used to detect spurious retransmissions.  Once it
   is determined that segments were lost, CCwin is updated to a new
   value as determined by the congestion control function, and Laminar
   implicit slowstart is used to clock out (re)transmissions.  Once all
   holes are filled, a hybrid paced transmissions can be used to
   reestablish TCPs self clock at the new data rate.  This can be the
   same hybrid pacing algorithm as is used to recover the self clock
   after application stalls.

   Note that as long as there is non-contiguous data at the receiver the
   retransmission algorithms require timely SACK information to make
   proper decisions about which segments to send.  Pacing during loss
   recovery is not recommended without further investigation.

Mathis                  Expires January 16, 2013                [Page 9]

Internet-Draft                 Laminar TCP                     July 2012

6.5.  Undo

   Since CCwin is not used to implement transmission scheduling, undo is
   trivial.  CCwin can just be set back to its prior value and the
   transmission scheduling algorithm will transmit more (or less) data
   as needed.  It is useful to note that the discussion about ssthresh
   in [RFC4015] also applies to CCwin in TCP Laminar.  Some people might
   find it useful to think of CCwin as being equivalent to

   There is an opportunity to do substantially better than current
   algorithms.  Undo can be implemented by saving the arithmetic
   difference between the current and prior value of CCwin, and then
   adding this delta back into CCwin when all retransmissions are deemed
   to be spurious.  If the congestion avoidance algorithm is linear (or
   can be linearized), and is mathematically transportable across undo,
   it is possible to design a congestion control algorithm that is
   completely immune to reordering in the sense that the overall
   evolution of CCwin is not affected by low level reordering, even if
   it is pervasive.  This is an area for future research.

6.6.  Control Block Interdependence

   Under the Laminar framework, congestion control state can be easily
   shared between connections [RFC2140].  An ensemble of connections can
   each maintain their own total_pipe (partial_pipe?) which in aggregate
   tracks a single common CCwin.  A master transmission scheduler
   allocates permission to send (sndcnt) to each of the constituent
   connection on the basis of the difference between the CCwin and the
   aggregate total_pipe, and a fairness or capacity allocation policy
   that balances the flows.  Note that ACKs on one connection in an
   ensemble might be used to clock transmissions on another connection,
   and that following a loss, the window reductions can be allocated to
   flows other than the one experiencing the loss.

6.7.  New Reno

   The key to making Laminar function well without SACK is having good
   estimators for DeliveredData and total_pipe.  By definition every
   duplicate ACK indicates that one segment has arrived at the receiver
   and total_pipe has fallen by one.  On any ACK that advances snd.una,
   total pipe can be updated from snd.nxt-snd.una, and DeliveredData is
   the change in snd.una, minus the sum of the estimated DeliveredData
   of the preceding duplicate ACKs.  As with SACK the total
   DeliveredData must agree with the overall forward progress over time.

Mathis                  Expires January 16, 2013               [Page 10]

Internet-Draft                 Laminar TCP                     July 2012

7.  Example Pseudocode

   On startup:

     CCwin = MAX_WIN
     sndBank = IW

   On every ACK:

     DeliveredData = delta(snd.una) + delta(SACKd)
     pipe = (RFC 3517 pipe algorithm)
     total_pipe = pipe+DeliveredData+sndBank
     sndcnt = DeliveredData    // Default # transmissions

     if new_recovery():
        if CCwin == MAX_WIN:
           CCwin = total_pipe/2 // First time only
        CCwin = CCwin/2         // Reno congestion control
        prr_delivered = 0       // Total bytes delivered during recov
        prr_out = 0             // Total bytes sent during recovery
        RecoverFS = total_pipe  //

     if !in_recovery() && !application_limited():
        CCwin += (MSS/CCwin)
     prr_delivered += DeliveredData  // noop if not in recovery

Mathis                  Expires January 16, 2013               [Page 11]

Internet-Draft                 Laminar TCP                     July 2012

     if total_pipe > CCwin:
        // Proportional Rate Reduction
        sndcnt = CEIL(prr_delivered * CCwin / RecoverFS) - prr_out

     else if total_pipe < CCwin:
        if in_recovery():
           // PRR Slow Start Reduction Bound
           limit = MAX(prr_delivered - prr_out, DeliveredData) + SMSS
           sndcnt = MIN(CCwin - total_pipe, limit)
           // slow start with appropriate byte counting
           inc = MIN(DeliveredData, 2*MSS)
           sndcnt = DeliveredData + inc

     // cue the transmission machinery
     sndBank += sndcnt
     limit = maxBank()
     if sndBank > limit:
        sndBank = limit

   For any data transmission or retransmission:

     while sndBank && tso_ok():
        len = sendsomething()
        sndBank -= len
        prr_out += len  // noop if not in recovery

8.  Compatibility with existing implementations

   On a segment by segment basis, the above algorithm is [believed to
   be] fully conformant with or less aggressive than standards under all

   However this condition is not sufficient to guarantee that observed
   performance can't be better than standards.  Consider an application
   that keeps TCP in bulk mode nearly all of the time, but has
   occasional pauses that last some fraction of one RTT.  A fully
   conforment TCP would be permitted to "catch up" by sending a partial
   window burst at full interface rate.  On some networks, such bursts
   might be very disruptive, causing otherwise unnecessary packet losses
   and corresponding cwnd reductions.

Mathis                  Expires January 16, 2013               [Page 12]

Internet-Draft                 Laminar TCP                     July 2012

   In Laminar the default algorithm would be slowstart.  Other
   algorithms that might cause the same bursts would be permitted,
   although are not described here.  A better algorithm would be to pace
   the data at (some fraction of) the prior rate.  Neither pacing nor
   slowstart is likely to cause unnecessary losses, and as was observed
   while testing PRR, being less aggressive at the segment level has the
   potential to increase the observed performance[IMC11PRR].  In this
   scenario Laminar with pacing has the potential to outperform both of
   the behaviors described by standards.

9.  Security Considerations

   The Laminar framework does not change the risk profile for TCP (or
   other transport protocols) themselves.

   However, the complexity of current algorithms as embodied in today's
   code present a substantial barrier to people wishing to cheat "TCP
   friendliness".  It is a fairly well known and easily rediscovered
   result that custom tweaks to make TCP more aggressive in one
   environment generally make it fragile and perform less well across
   the extreme diversity of the Internet.  This negative outcome is a
   substantial intrinsic barrier to wide deployment of rogue congestion
   control algorithms.

   A direct consequence of the changes proposed in this note, decoupling
   congestion control from other algorithms, is likely to reduce the
   barrier to rogue algorithms.  However this separation and the ability
   to introduce new congestion control algorithms is a key part of the
   motivation for this work.

   It is also important to note that web browsers have already largely
   defeated TCP's ability to regulate congestion by opening many
   concurrent connections.  When a Web page contains content served from
   multiple domains (the norm these days) all modern browsers open
   between 35 and 60 connections (see: ).  This is the Web
   community's deliberate workaround for TCP's perceived poor
   performance and inability make full use of certain types of consumer
   grade networks.  As a consequence the transport layer has already
   lost a substantial portion of its ability to regulate congestion.  It
   was not anticipated that the tragedy of the commons in Internet
   congestion would be driven by competition between applications and
   not between TCP implementations.

   In the short term, we can continue to try to use standards and peer
   pressure to moderate the rise in overall congestion levels, however
   the only real solution is to develop mechanisms in the Internet

Mathis                  Expires January 16, 2013               [Page 13]

Internet-Draft                 Laminar TCP                     July 2012

   itself to apply some sort of backpressure to overly aggressive
   applications and transport protocols.  We need to redouble efforts by
   the ConEx WG and others to develop mechanisms to inform policy with
   information about congestion and it's causes.  Otherwise we have a
   looming tragedy of the commons, in which TCP has only a minor role.

   Implementers that change Laminar from counting bytes to segments have
   to be cautious about the effects of ACK splitting attacks[Savage99],
   where the receiver acknowledges partial segments for the purpose of
   confusing the sender's congestion accounting.

10.  IANA Considerations

   This document makes no request of IANA.

   Note to RFC Editor: this section may be removed on publication as an

11.  References

              Jacobson, V., "Congestion Avoidance and Control",
              SIGCOMM 18(4), August 1988.

   [RFC2140]  Touch, J., "TCP Control Block Interdependence", RFC 2140,
              April 1997.

   [RFC2861]  Handley, M., Padhye, J., and S. Floyd, "TCP Congestion
              Window Validation", RFC 2861, June 2000.

   [RFC2914]  Floyd, S., "Congestion Control Principles", BCP 41,
              RFC 2914, September 2000.

   [RFC3517]  Blanton, E., Allman, M., Fall, K., and L. Wang, "A
              Conservative Selective Acknowledgment (SACK)-based Loss
              Recovery Algorithm for TCP", RFC 3517, April 2003.

   [RFC4015]  Ludwig, R. and A. Gurtov, "The Eifel Response Algorithm
              for TCP", RFC 4015, February 2005.

   [RFC5681]  Allman, M., Paxson, V., and E. Blanton, "TCP Congestion
              Control", RFC 5681, September 2009.

   [RFC5682]  Sarolahti, P., Kojo, M., Yamamoto, K., and M. Hata,
              "Forward RTO-Recovery (F-RTO): An Algorithm for Detecting
              Spurious Retransmission Timeouts with TCP", RFC 5682,

Mathis                  Expires January 16, 2013               [Page 14]

Internet-Draft                 Laminar TCP                     July 2012

              September 2009.

   [RFC6582]  Henderson, T., Floyd, S., Gurtov, A., and Y. Nishida, "The
              NewReno Modification to TCP's Fast Recovery Algorithm",
              RFC 6582, April 2012.

   [PRRid]    Mathis, M., Dukkipati, N., and Y. Cheng, "Proportional
              Rate Reduction for TCP",
              draft-mathis-tcpm-proportional-rate-reduction-01 (work in
              progress), July 2011.

              Mathis, M., Dukkipati, N., Cheng, Y., and M. Ghobadi,
              "Proportional Rate Reduction for TCP", Proceedings of the
              2011 ACM SIGCOMM conference on Internet measurement
              conference , 2011.

              Savage, S., Cardwell, N., Wetherall, D., and T. Anderson,
              "TCP congestion control with a misbehaving receiver",
              SIGCOMM Comput. Commun. Rev. 29(5), October  1999.

              Visweswaraiah, V., "Improving Restart of Idle TCP
              Connections", Tech Report USC TR 97-661, November 1997.

Author's Address

   Matt Mathis
   Google, Inc
   1600 Amphitheater Parkway
   Mountain View, California  93117


Mathis                  Expires January 16, 2013               [Page 15]