Re: flow control and DATAGRAM

Jana Iyengar <jri.ietf@gmail.com> Mon, 29 October 2018 19:37 UTC

Return-Path: <jri.ietf@gmail.com>
X-Original-To: quic@ietfa.amsl.com
Delivered-To: quic@ietfa.amsl.com
Received: from localhost (localhost [127.0.0.1]) by ietfa.amsl.com (Postfix) with ESMTP id AB935131055 for <quic@ietfa.amsl.com>; Mon, 29 Oct 2018 12:37:52 -0700 (PDT)
X-Virus-Scanned: amavisd-new at amsl.com
X-Spam-Flag: NO
X-Spam-Score: -1.999
X-Spam-Level:
X-Spam-Status: No, score=-1.999 tagged_above=-999 required=5 tests=[BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, FREEMAIL_FROM=0.001, HTML_MESSAGE=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_PASS=-0.001] autolearn=ham autolearn_force=no
Authentication-Results: ietfa.amsl.com (amavisd-new); dkim=pass (2048-bit key) header.d=gmail.com
Received: from mail.ietf.org ([4.31.198.44]) by localhost (ietfa.amsl.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 6L3oFT8ugDFR for <quic@ietfa.amsl.com>; Mon, 29 Oct 2018 12:37:49 -0700 (PDT)
Received: from mail-lj1-x235.google.com (mail-lj1-x235.google.com [IPv6:2a00:1450:4864:20::235]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by ietfa.amsl.com (Postfix) with ESMTPS id 6F1F41276D0 for <quic@ietf.org>; Mon, 29 Oct 2018 12:37:49 -0700 (PDT)
Received: by mail-lj1-x235.google.com with SMTP id z80-v6so2947962ljb.8 for <quic@ietf.org>; Mon, 29 Oct 2018 12:37:49 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=oWnv9ziz78hANCR6tNxm6N0Eczpj9SPSzQSD/gBvKv0=; b=PuRrtKuEXvyxMhMbPl1DaE+dJUeQwFieNeRLduGmJOgjoS3YT2MWNyBGAcpCweCmd+ EwkipfsvFCvJx2kOwtJ0H03GhT4H/mEtU/mvBqpAwzvcReAsMhugjbt7ULoVE4BCfMoE KPnQt2otrxVYtZoBq9w38pDViswHkemloxBbP46aPjko6nyKruckzEzFN0Q5m7JdL/sR OJoDD92WGZHu0zr+L4o7zlJcdXUjlb24nyKsBS+G1gt9eqlymPi4uPqGN8Piw3OtKaMO UtRn2oSDwLWkP3yMiSysAyz/m9yJxShA7F98HawkRaQ0Jifl1VmKDwmHepxE/skLM6RP gfJg==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=oWnv9ziz78hANCR6tNxm6N0Eczpj9SPSzQSD/gBvKv0=; b=sF663SBQxusXS/hokLpxtoux3gjtKcLTixdz3ChXt3dYBffLA1twAzzEq7cxZ7L0IF lmxXaMYfxkfxlE07yLf1wEyri9jokesEJQj1VlphHD1ulXpB38myxdNBPHEAaEd5bqe6 Ih8Mu1zRdMSGXWEICNfj1WuQe97/ZHhaFLGJRDxDSvb9m4t3ZnI9lzcrzg8ZtjkCgtkW ATJcpvyaMVjh8UumL/ZB+/lq2u7C/T+KQm4dF3ICUqVB7BurGDr35cdI10s8QC5ZqaVV HZWJwr2XBJSwReoTIqj6fnzkOFrZdrgp58zcYm90AsmMq+112N74yrzHlklNkqEBgICr X0kA==
X-Gm-Message-State: AGRZ1gJBJcGkYG+3TutZyvcTbGH4Y7QE7mWe4HjaZNOrMXz/De1GvcAh LcdbMooJ09LUJ1D01g/EkYETi5dZnsCYWEldw1M=
X-Google-Smtp-Source: AJdET5fGTn7Nv7DkwSKnrQGre8Fo6Tnun97f+sF8+dGkB4v5qizZnQdzaUXIBjTg8PyjilzAuR8Y+F+iHuf8jB56ZE8=
X-Received: by 2002:a2e:5555:: with SMTP id j82-v6mr11468498ljb.69.1540841867384; Mon, 29 Oct 2018 12:37:47 -0700 (PDT)
MIME-Version: 1.0
References: <CABkgnnU26aYD=TybuD0FZGYtfEa6np-Sk3Jo6t7LRp0wzKh3Lg@mail.gmail.com> <CAKcm_gMDOyJC0AwOo2knN6AMxVbySjGsrLvjcC9A8UA9xcvcWw@mail.gmail.com> <19D3595B-8845-45B6-A60D-9E934DD49FAC@apple.com>
In-Reply-To: <19D3595B-8845-45B6-A60D-9E934DD49FAC@apple.com>
From: Jana Iyengar <jri.ietf@gmail.com>
Date: Mon, 29 Oct 2018 12:37:36 -0700
Message-ID: <CACpbDcfk+GXb3aL5LG0wQM87thRGO5Y4Q+9cbXf5YuW1=jWCig@mail.gmail.com>
Subject: Re: flow control and DATAGRAM
To: tpauly@apple.com
Cc: Ian Swett <ianswett@google.com>, Martin Thomson <martin.thomson@gmail.com>, QUIC WG <quic@ietf.org>
Content-Type: multipart/alternative; boundary="00000000000029209d0579633459"
Archived-At: <https://mailarchive.ietf.org/arch/msg/quic/WJC41F46I_Oa2Z4aWE1qBG3xX3I>
X-BeenThere: quic@ietf.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: Main mailing list of the IETF QUIC working group <quic.ietf.org>
List-Unsubscribe: <https://www.ietf.org/mailman/options/quic>, <mailto:quic-request@ietf.org?subject=unsubscribe>
List-Archive: <https://mailarchive.ietf.org/arch/browse/quic/>
List-Post: <mailto:quic@ietf.org>
List-Help: <mailto:quic-request@ietf.org?subject=help>
List-Subscribe: <https://www.ietf.org/mailman/listinfo/quic>, <mailto:quic-request@ietf.org?subject=subscribe>
X-List-Received-Date: Mon, 29 Oct 2018 19:37:53 -0000

Tommy,

Changing the semantics of an acknowledgment to include delivery up to the
application is a fundamental change to the QUIC machinery, and it doesn't
work. First, an ACK frame acknowledges packets, and you can't have
different semantics of an acknowledgment for different frames that are
carried in the same packet. Second, it interferes with RTT measurement, and
it conflates flow control with congestion control, which gets messy. (This
conflation is an interesting problem to consider theoretically, but not one
for us at this time IMO.)

I am wondering if applying a stream-level flow control for DATAGRAMs makes
sense instead. Meaning that you treat DATAGRAMs as a separate stream for
flow control purposes. You might benefit from having an offset in the
DATAGRAM frame for this purpose.

- jana

On Mon, Oct 29, 2018 at 8:21 AM Tommy Pauly <tpauly@apple.com>; wrote:

> Hi Martin, Ian,
>
> Yes, very good points!
>
> My tendency would be to prefer what Ian's implementation does of passing
> these DATAGRAM frames up immediately to the application. I don't think that
> the acknowledgment needs to indicate that the frame was processed by the
> application, but merely that it has been delivered to the application (that
> is, the application doesn't get to do anything with the frame that can
> influence the acknowledgment).
>
> The current draft indicates that the content of the DATAGRAM frames
> contributes to the limit used for MAX_DATA, and that if that amount is
> reached, the frames are blocked along with STREAM data. I think this works
> fine for the sender, while the receiver gets into the discussion you
> present. On the sender side, reaching MAX_DATA could mean dropping the
> DATAGRAM frames when unable to send more (and sending BLOCKED instead).
> Since the frames are unreliable, they can be dropped in this situation
> without violating the API contract.
>
> On the receiver side, I agree that queuing the DATAGRAM frames to let the
> application drive flow control in the way it does for STREAM frames adds
> complexity and diminishes the utility of the frame and ACKs. However, I can
> imagine taking a fairly simplistic approach in which the data limit is
> automatically increased upon reception of the frame (and the frame is
> immediately passed to the application). This allows the initial_max_data to
> put a cap on the amount of data in a given flight of DATAGRAMS, and allow
> the size of a flight of DATAGRAM frames to be limited by the amount of room
> left over from STREAM data that may be consuming the connection-wide flow
> control.
>
> Perhaps this approach needs a clearer name other than "flow control",
> since it has a somewhat different meaning in effect.
>
> As for ACKs, if we never discard on the receiver side, the ACK is pretty
> useful for detecting if there was network-based packet loss.
>
> Thanks,
> Tommy
>
> On Oct 29, 2018, at 5:32 AM, Ian Swett <ianswett@google.com>; wrote:
>
> Good catch Martin, I missed that in the draft as well, and I also think
> it's impossibly with the proposed design.
>
> And yes, I think Martin's proposed solution is likely the only practical
> one.  In my implementation, the frame is passed up to the application
> immediately, so technically QUIC processed it, and it's the application's
> job to decide what to do with it.
>
> On Mon, Oct 29, 2018 at 1:16 AM Martin Thomson <martin.thomson@gmail.com>;
> wrote:
>
>> Hi Tommy,
>>
>> Your slides - <
>> https://github.com/quicwg/wg-materials/blob/master/ietf103/IETF103-QUIC-Datagram.pdf
>> >
>> - say that DATAGRAM frames respect connection-level flow control.  I
>> missed that in the draft, and I don't know how they can do that in the
>> face of packet loss, especially when you don't necessarily retransmit
>> lost DATAGRAM frames.
>>
>> For that to work, you would need a bunch more machinery to make the
>> connection-level flow control sync between endpoints in the case that
>> packets are lost.  A disagreement about how much flow control is used
>> causes things to break down badly.  Ian and I discussed this point at
>> the last meeting and quickly agreed that while it might be nice to
>> have flow control for this stuff, the increase in complexity is
>> considerable and (at the time) we thought it wouldn't be worth it.
>>
>> The problem that introduces is that you could end up having too many
>> DATAGRAM frames arrive.  The receiver has to drop something at the
>> point that it can't handle them.  And we say that when you acknowledge
>> something, you processed it.  That's tricky.
>>
>> It might be easier to say that a QUIC acknowledgment for a DATAGRAM
>> frame doesn't mean that it was received and processed by an
>> application.  An endpoint might discard these frames before passing
>> them on to applications if it doesn't have space.  In other words,
>> acknowledgment of DATAGRAM means that QUIC got it, not that the
>> application got it.  Sadly, that means that the QUIC acknowledgment
>> machinery doesn't help the application that uses DATAGRAM all that
>> much.  Also, the lower bound on reliability is 0, which isn't the best
>> thing ever.
>>
>> Hard choices, I know.  I don't have a good design for maintaining
>> connection-level flow control (or any back pressure mechanism with
>> equivalent properties) that doesn't add both complexity and overhead.
>>
>> Cheers,
>> Martin
>>
>>
>