Re:QUIC, a multiplexed stream transport over UDP
by simfoo on Monday June 01, 2015 @12:57PM
(#9640177)
I've said it before and I'll say it again. If Google wants others to use QUIC they will have to stop pointing at their Chromium source tree and say "there it is". Provide a standalone library that implements QUIC for the major platforms and compiles without having to install custom build environments and people/projects will start using it.
Re:QUIC, a multiplexed stream transport over UDP
by apendleton on Monday June 01, 2015 @01:04PM
(#9640250)
I don't think they really want other people to use it, at least right now. I think they want the latitude to be able to make backwards-incompatible changes and only have to worry about roll-out on their own servers and to their own client software.
Re:QUIC, a multiplexed stream transport over UDP
by billyhoffman on Monday June 01, 2015 @02:40PM
(#9641085)
Yes. This.
It's the same model as SPDY. See a problem (HTTP1/x utilizing the network poorly). Implement a proprietary protocol from just your clients talking with your web properties. Work out kinks. Standardize as HTTP/2.
I wonder what the HTTP/2 equivalent of QUIC will be.
Interesting aside. As I typed that summary above. I couldn't help but think of Microsoft and how SPDY might still exists as a private "market leading feature" if Google sold server software...
Re:QUIC, a multiplexed stream transport over UDP
by lttlrck on Monday June 01, 2015 @04:22PM
(#9641851)
There is a standalone test client & server [0] not quite a library but it looks manageable. And there is libquicc [1], though yes, it would be nice if this came from google.
Re:QUIC, a multiplexed stream transport over UDP
by DonPellegrino on Monday June 01, 2015 @02:39PM
(#9641082)
This, I'd love to give it a try, but I'm not going to touch it until there's a Makefile and a minimal documentation. Until then, it feels like an engineering experiment, not a major company-backed project.
Re:QUIC, a multiplexed stream transport over UDP
by aidenn0 on Monday June 01, 2015 @11:28AM
(#9639335)
I see FEC is mentioned; isn't most error-correction over noisy channels implemented at the link-layer? Even over e.g. wifi or cellular radios, my understanding is you typically either get the packet or not, with the internet layer rarely seeing corrupted packets.
[edit]
I read deeper in, and apparently, QUIC optionally allows sending packets in groups, with an additional packet that is the XOR of the other packets in the groups; this means that you can fill-in any single dropped packet by sending an extra packet ahead of time.
Re:QUIC, a multiplexed stream transport over UDP
by boardwaalk on Monday June 01, 2015 @12:56PM
(#9640160)
I've played with QUIC [1] and SCTP [2]. QUIC does not have good documentation and SCTP's userlevel library feels like it's intended on being used a certain way (one-to-one sockets) and is easy to use incorrectly, which makes me uneasy about the quality of its code.
I really wish there was a solid "TCP replacement" with optional reliability, optional ordering and multiplexing that I can run over real networks as user level code, among other features. But the view from the ground from what I've seen is that people either use TCP or build their own protocol that runs over UDP (I'm thinking about games specifically here).
Am I missing an option here? Maybe I should dig into libquic and really figure out how to use it and if it can do what I want.
IIRC I got frustrated with its (at least at the time) inability to send a packet while waiting on a packet to be received so I gave up and started writing my own spin on RFC 908.
Re:QUIC, a multiplexed stream transport over UDP
by corysama on Monday June 01, 2015 @01:11PM
(#9640309)
IIRC, packets on different "channels" in enet don't block each other. So, a troublesome reliable packet that needs retransmitting unusually many times won't hold up packets on other channels -reliable or not.
Edit: from the docs
> To combat this latency and reduce the ordering restrictions on packets, ENet provides multiple channels of communication over a given connection. Each channel is independently sequenced, and so the delivery status of a packet in one channel will not stall the delivery of other packets in another channel.
Re:QUIC, a multiplexed stream transport over UDP
by Scramblejams on Monday June 01, 2015 @01:24PM
(#9640447)
I was referring to their non-thread-safe (within a single ENet instance) architecture combined with the need to block if you want to pick up a packet the moment it arrives. I have to block to receive that packet, but while I'm blocking, I can't send a packet (because ENet isn't thread safe). Now, it will let you set a receive timeout, but then you just spend a lot of time spinning.
An issue there describes a hack (sending a packet to your own socket to wake up enet_host_service). Not a terrible hack and much like the "self-pipe" trick.
Re:QUIC, a multiplexed stream transport over UDP
by Scramblejams on Monday June 01, 2015 @05:34PM
(#9642321)
Yeah, it's a clever workaround. Don't think I'll go back to it though, my own protocol I've been working on has convinced me I want some of those layer violations QUIC also displays, so I can integrate encryption, authentication, handoff and other features without paying full price.
And there's also the fact that I want something that runs on the BEAM VM...
Re:QUIC, a multiplexed stream transport over UDP
by chetanahuja on Monday June 01, 2015 @10:54PM
(#9643561)
"I really wish there was a solid "TCP replacement" with optional reliability, optional ordering and multiplexing that I can run over real networks as user level code, among other features."
What's the use-case you're thinking of exactly? Why "optional" reliability and ordering? What are the cases when you'd use the reliability and when not?
Re:QUIC, a multiplexed stream transport over UDP
by boardwaalk on Tuesday June 02, 2015 @12:06PM
(#9646783)
For my own use, games. For example, multiple objects moving: The message updating the position of one taking longer than another shouldn't block the other from being handled. Also, an object being moved over time: You only care about the latest position, within reason.
There are other models of simulation that aren't as loose (lock step-style for example).
Other messages would not be unreliable/unordered. Important state changes, chat messages, etc.
I know voice and video applications can cope with lost packets as well. This is in fact what SCTP was built for.
Re:QUIC, a multiplexed stream transport over UDP
by s800 on Monday June 01, 2015 @01:23PM
(#9640434)
Mixing (doubling up) network layers like this is a bad plan. Yes, it would be a new protocol on ip, and would be less backward compatible. But if it's that important to do, then let's do it right. As long as we're probing to see if it's supported, then why not?
Re:QUIC, a multiplexed stream transport over UDP
by pthatcherg on Monday June 01, 2015 @12:36PM
(#9639979)
I know that one big deal is fewer round trips. DTLS+SCTP requires several round trips to establish a secure connection (around 4 I think). DTLS 1.3 should improve that on the DTLS side of things, but QUIC is designed from the beginning to have 0 round trips for many cases, and 1 round trip in the worst case. For high RTT scenarios, that can make a big difference.
Re:QUIC, a multiplexed stream transport over UDP
by wmf on Monday June 01, 2015 @12:26PM
(#9639890)
QUIC is supposed to be quicker than SCTP+TLS or SCTP+IPSec by using some "rampant layering violations" to combine security and transport into one layer and eliminate a lot of round trips.
Re:QUIC, a multiplexed stream transport over UDP
by wtallis on Monday June 01, 2015 @03:57PM
(#9641676)
> You are NOT getting past your Verizon/Comcast router with IP alone.
... on IPv4. On IPv6 you don't have to worry about NAT, and IPv6 usage is growing: the percentage of Google traffic conducted over IPv6 has doubled in the past year and is significantly higher on weekends, which means consumers are driving a lot of that traffic. It's now over 7% on weekends and growing by about one percentage point every 3-4 months. That seems to me like a sufficiently large pool of potential testers.
The NAT problem is really finally going away. What we need to be worrying about is dumb firewalls, but I'd bet that there will be just as many consumer routers that fail to make any of their firewall rules apply to IPv6 as there will be routers that can pass TCP over IPv6 but not arbitrary protocols.
Re:QUIC, a multiplexed stream transport over UDP
by acdha on Monday June 01, 2015 @01:35PM
(#9640555)
The catch is that most NAT devices don't support it, which is a deal-breaker for something to be deployed on the public internet, and many firewalls either don't support it or would require firmware updates / policy changes to support it.
There's a wicked chicken-and-egg problem deploying SCTP: a popular service would be a good reason to push vendors, enterprise firewall admins, etc. to support SCTP but it'd be financial suicide to build a general service which depends on it now.
Re:QUIC, a multiplexed stream transport over UDP
by Scramblejams on Monday June 01, 2015 @12:55PM
(#9640151)
I can think of a lot of things this could be good for that aren't web servers.
I didn't see it clearly treated in the documents at the linked site: is out of order packet delivery supported? I see they they use multiple streams to avoid head of line blocking, but within a stream, can packets be delivered out of order?
Re:QUIC, a multiplexed stream transport over UDP
by chetanahuja on Monday June 01, 2015 @11:00PM
(#9643585)
What would be your use-case for reliable out-of-order packet delivery? Streaming/VOIP are convincing use-cases for "slightly unreliable" in-order delivery (that is, sacrifice reliability but not order). I'd love to hear your case for the revers (sacrifice order but not reliability).
Re:QUIC, a multiplexed stream transport over UDP
by seoguru on Tuesday June 02, 2015 @03:32AM
(#9644430)
reminds me of this comment:
"Of these, quic is my favorite option for the future. It is a truly phenmenal transport, with tons of things done very, very well. However, though the dragon is ready to hatch from its egg, it must still be unearthed from the enormous Code Caverns, of the Chromium Mountains, a quest not to be taken lightly."
It's the same model as SPDY. See a problem (HTTP1/x utilizing the network poorly). Implement a proprietary protocol from just your clients talking with your web properties. Work out kinks. Standardize as HTTP/2.
I wonder what the HTTP/2 equivalent of QUIC will be.
Interesting aside. As I typed that summary above. I couldn't help but think of Microsoft and how SPDY might still exists as a private "market leading feature" if Google sold server software...
[0]http://src.chromium.org/viewvc/chrome/trunk/src/net/tools/qu... [1]https://github.com/devsisters/libquic
In all honesty, I gave up and iterated my own secure UDP protocol based on the excellent Micro Transport Protocol.
[edit]
I read deeper in, and apparently, QUIC optionally allows sending packets in groups, with an additional packet that is the XOR of the other packets in the groups; this means that you can fill-in any single dropped packet by sending an extra packet ahead of time.
I really wish there was a solid "TCP replacement" with optional reliability, optional ordering and multiplexing that I can run over real networks as user level code, among other features. But the view from the ground from what I've seen is that people either use TCP or build their own protocol that runs over UDP (I'm thinking about games specifically here).
Am I missing an option here? Maybe I should dig into libquic and really figure out how to use it and if it can do what I want.
[1] https://github.com/devsisters/libquic [2] https://code.google.com/p/sctp-refimpl/
JIC you haven't seen it, it covers some of the bases: http://enet.bespin.org/
IIRC I got frustrated with its (at least at the time) inability to send a packet while waiting on a packet to be received so I gave up and started writing my own spin on RFC 908.
Edit: from the docs
> To combat this latency and reduce the ordering restrictions on packets, ENet provides multiple channels of communication over a given connection. Each channel is independently sequenced, and so the delivery status of a packet in one channel will not stall the delivery of other packets in another channel.
I found this issue which looks related to your problem: https://github.com/lsalzman/enet/issues/23
An issue there describes a hack (sending a packet to your own socket to wake up enet_host_service). Not a terrible hack and much like the "self-pipe" trick.
And there's also the fact that I want something that runs on the BEAM VM...
What's the use-case you're thinking of exactly? Why "optional" reliability and ordering? What are the cases when you'd use the reliability and when not?
There are other models of simulation that aren't as loose (lock step-style for example).
Other messages would not be unreliable/unordered. Important state changes, chat messages, etc.
I know voice and video applications can cope with lost packets as well. This is in fact what SCTP was built for.
[edit] And implementation in userspace.
tl;dr minimizing latency, particularly in establishing a connection, is an important design objective.
[1] https://tools.ietf.org/html/rfc6951
It's also in plenty of OS kernels already, such as solaris and linux, and can be written as userspace libraries.
1: http://www.cisco.com/c/en/us/td/docs/ios/12_4t/12_4t15/htsct...
> it sits at the IP layer so all routers need to do is pass it as IP
Erm... no. The vast majority of consumer electronics are built up from NAT. You are NOT getting past your Verizon/Comcast router with IP alone.
It's getting interpreted as TCP, and then getting NATted over to something else. As far as i can tell, UDP has a similar process.
But its a major problem with SCTP and consumer routers. Have you ever tried to send an SCTP connection across your typical consumer Verizon router?
... on IPv4. On IPv6 you don't have to worry about NAT, and IPv6 usage is growing: the percentage of Google traffic conducted over IPv6 has doubled in the past year and is significantly higher on weekends, which means consumers are driving a lot of that traffic. It's now over 7% on weekends and growing by about one percentage point every 3-4 months. That seems to me like a sufficiently large pool of potential testers.
The NAT problem is really finally going away. What we need to be worrying about is dumb firewalls, but I'd bet that there will be just as many consumer routers that fail to make any of their firewall rules apply to IPv6 as there will be routers that can pass TCP over IPv6 but not arbitrary protocols.
There's a wicked chicken-and-egg problem deploying SCTP: a popular service would be a good reason to push vendors, enterprise firewall admins, etc. to support SCTP but it'd be financial suicide to build a general service which depends on it now.
I didn't see it clearly treated in the documents at the linked site: is out of order packet delivery supported? I see they they use multiple streams to avoid head of line blocking, but within a stream, can packets be delivered out of order?
[edit] See SCTP for reliable multiplexed out-of-order datagrams.
"Of these, quic is my favorite option for the future. It is a truly phenmenal transport, with tons of things done very, very well. However, though the dragon is ready to hatch from its egg, it must still be unearthed from the enormous Code Caverns, of the Chromium Mountains, a quest not to be taken lightly."
https://github.com/ipfs/go-ipfs/issues/57#issuecomment-70162...