CoDel AQM discussions
 help / color / mirror / Atom feed
From: Jonathan Morton <chromatix99@gmail.com>
To: David Lang <david@lang.hm>
Cc: moeller0 <moeller0@gmx.de>,
	cake@lists.bufferbloat.net, codel@lists.bufferbloat.net
Subject: Re: [Codel] [Cake] Proposing COBALT
Date: Fri, 20 May 2016 20:31:35 +0300	[thread overview]
Message-ID: <42DB8BB8-AF01-4236-A2A0-3245C4880399@gmail.com> (raw)
In-Reply-To: <alpine.DEB.2.02.1605200902070.2282@nftneq.ynat.uz>


> On 20 May, 2016, at 19:03, David Lang <david@lang.hm> wrote:
> 
> On Fri, 20 May 2016, Jonathan Morton wrote:
> 
>>>> If the relative load from the flow decreases, BLUE’s action will begin to leave the subqueue empty when serviced, causing BLUE’s drop probability to fall off gradually, potentially until it reaches zero.  At this point the subqueue is naturally reset and will react normally to subsequent traffic using it.
>>> But if we reach a queue length of codel’s target (for some small amount of time), would that not be the best point in time to hand back to codel? Otherwise we push the queue to zero only to have codel come in and let it grow back to target (well approximately).
>> 
>> No, because at that moment we can only assume that it is the heavy pressure of BLUE that is keeping the queue under control.  Again, this is an aspect of Codel’s behaviour which should not be duplicated in its alternate, because it depends on assumptions which have been demonstrated not to hold.
>> 
>> BLUE doesn’t even start backing off until it sees the queue empty, so for the simple and common case of an isochronous flow (or a steady flood limited by some upstream capacity), BLUE will rapidly increase its drop rate until the queue stops being continuously full.  In all likelihood the queue will now slowly and steadily drain until it is empty.  But the load is still there, so if BLUE stopped dropping entirely at that point, the queue would almost instantly be full again and it would have to ramp up from scratch.
>> 
>> Instead, BLUE backs off slightly and waits to see if the queue *remains* empty during its timeout.  If so, it backs off some more.  As long as the queue is still serviced while BLUE’s drop probability is nonzero, it will back down all the way to zero *if* the traffic has really gone away or become responsive enough for Codel to deal with.
>> 
>> Hence BLUE will hand control back to Codel only when it is sure its extra effort is not required.
> 
> How about testing having BLUE back off not when the queue is empty, but when the queue is down to the codel target.
> 
> If it's efforts are still needed, it will ramp back up, but waiting for the queue to go all the way to zero repeatedly, with codel still running, seems like a pessimistic way to go that will over-penalize a flow that eventually corrects itself.

I can think of three cases where BLUE might trigger on a flow which is, in fact, responsive.

1) The true RTT is *much* longer than the estimated RTT - this could reasonably happen if the estimated RTT is “regional” grade but the flow is going over a satellite link or two.  Since the queue limit is auto-tuned (in Cake) with the estimated RTT in mind, it’s possible for a TCP in slow-start to bounce off the end of that queue if it has a very long RTT, even though Codel is frantically signalling to it over ECN.  The damage here is limited to a few, widely-spaced dropped packets which are easily retransmitted, with no RTOs, and a somewhat excessive (temporary) reduction in the congestion window.

2) Something downstream is munging the ECN bits and erasing Codel’s signal.  This should be a rare situation in practice, but effectively leaves BLUE in sole charge of managing the queue length via packet drops.  It should be adequate at that job.

3) The flow is managed by DCTCP rather than a normal TCP.  DCTCP’s response to ECN signalling is much softer than standard, and I suspect Codel will be unable to control it, because it doesn’t behave the way DCTCP expects (which is something more akin to a specially configured RED).  However, DCTCP is (supposed to be) responsive to packet drops to the standard extent, so as in case 2, BLUE will take sole charge.

I don’t really see how leaving Codel “primed” to take over from BLUE helps in any of these situations.  However, Codel’s additional action superimposed on BLUE might result in a stable state emerging, rather than the queue length oscillating between “empty” and “full”.  This is best achieved by having BLUE’s down-trigger *below* that of Codel.

 - Jonathan Morton


  reply	other threads:[~2016-05-20 17:31 UTC|newest]

Thread overview: 45+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2016-05-20 10:04 [Codel] " Jonathan Morton
2016-05-20 11:37 ` [Codel] [Cake] " moeller0
2016-05-20 12:18   ` Jonathan Morton
2016-05-20 13:22     ` moeller0
2016-05-20 14:36       ` Jonathan Morton
2016-05-20 16:03         ` David Lang
2016-05-20 17:31           ` Jonathan Morton [this message]
     [not found]         ` <CALnBQ5mNgHgFoTcvLxppv2P9XODc4D-4NObKyqbZJ0PccVkwiA@mail.gmail.com>
2016-05-20 16:43           ` Jonathan Morton
2016-05-23 18:30             ` Jonathan Morton
2016-05-24 13:47               ` Jeff Weeks
2016-05-24 14:07                 ` Jonathan Morton
2016-05-24 15:52                   ` Dave Täht
2016-05-24 15:56                     ` Jonathan Morton
2016-05-24 16:02                       ` Dave Taht
2016-05-26 12:33                     ` Jonathan Morton
2016-06-03 19:09                       ` Noah Causin
2016-06-03 19:34                         ` Jonathan Morton
2016-06-04  1:01                           ` Andrew McGregor
2016-06-04  6:23                             ` Jonathan Morton
2016-06-04 13:55                             ` Jonathan Morton
2016-06-04 14:01                               ` moeller0
2016-06-04 14:16                                 ` Jonathan Morton
2016-06-04 15:03                                   ` moeller0
2016-06-04 17:10                               ` Noah Causin
2016-06-04 17:49                                 ` Eric Dumazet
2016-06-04 19:55                                   ` Jonathan Morton
2016-06-04 20:56                                     ` Eric Dumazet
2016-06-27  3:56                                     ` Jonathan Morton
2016-06-27  7:59                                       ` moeller0
2016-05-20 13:41     ` David Lang
2016-05-20 13:46       ` moeller0
2016-05-20 14:04         ` David Lang
2016-05-20 14:42           ` Kathleen Nichols
2016-05-20 15:11             ` Jonathan Morton
2016-05-20 15:12           ` Jonathan Morton
2016-05-20 16:05             ` David Lang
2016-05-20 17:06               ` Jonathan Morton
2016-05-20 16:20             ` Rick Jones
2016-05-20 16:35               ` Jonathan Morton
2016-05-20 17:01                 ` Rick Jones
2016-05-20 17:07                   ` Jonathan Morton
2016-05-20 17:21                     ` Rick Jones
2016-05-20 17:26                     ` David Lang
2016-05-20 17:33                       ` Jonathan Morton
2016-05-20 14:09       ` Jonathan Morton

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

  List information: https://lists.bufferbloat.net/postorius/lists/codel.lists.bufferbloat.net/

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=42DB8BB8-AF01-4236-A2A0-3245C4880399@gmail.com \
    --to=chromatix99@gmail.com \
    --cc=cake@lists.bufferbloat.net \
    --cc=codel@lists.bufferbloat.net \
    --cc=david@lang.hm \
    --cc=moeller0@gmx.de \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox