Google, Microsoft Cheat On Slow-Start — Should You? 123
kdawson writes "Software developer and blogger Ben Strong did a little exploring to find out how Google achieves its admirably fast load times. What he discovered is that Google, and to a much greater extent Microsoft, are cheating on the 'slow-start' requirement of RFC-3390. His research indicates that discussion of this practice on the Net is at an early, and somewhat theoretical, stage. Strong concludes with this question: 'What should I do in my app (and what should you do in yours)? Join the arms race or sit on the sidelines and let Google have all the page-load glory?'"
I do. (Score:5, Funny)
Without cheating, I wouldn't get the first post.
Re: (Score:2, Funny)
Is this possibly the first ever on-topic "first!" post?
Re: (Score:3, Informative)
Re: (Score:3, Informative)
No Cheating is the Third Rule (Score:5, Insightful)
The Third rule of network design, for a moral being, is to consider the moral, ethical, and legal consequences of any atypical changes you make to your behavior.
Why the Third rule?
Because the first rule is to figure out what on earth is going on--not just in theory, but in fact. Code for the OSI model is ugly, perhaps by necessity (it has to be very fast), but it's code that is very, very easy to get wrong. It involves a lot of interacting pieces working on different levels of abstraction with other players that you don't have code control over.
The second rule is to realize when the first rule means that you shouldn't touch the stuff. Google and Microsoft have the engineering competence to mess with it--MSFT even should be messing with it, in terms of looking for ways to improve their behavior in a community-friendly way. Because they write the code that handles a huge portion of connections, and let's face it, TCP/IP just isn't designed for lots of things: AJAX or broadband, for example.
The third rule is to consider the moral and ethical and legal consequences of changes.
Only after at least these three steps should someone make changes that involve connections that go beyond the computers they control.
Re: (Score:3, Informative)
Because the first rule is to figure out what on earth is going on--not just in theory, but in fact. Code for the OSI model is ugly, perhaps by necessity (it has to be very fast), but it's code that is very, very easy to get wrong. It involves a lot of interacting pieces working on different levels of abstraction with other players that you don't have code control over.
TCP/IP predates the OSI model and conflicts with it in some areas; discussion of the complexities of code targeting OSI isn't directly applic
Re: (Score:3, Insightful)
Re: (Score:1)
And if your ad isn't making noise and getting in the way, it won't get noticed. Go kill yourself.
Re: (Score:1)
Good plan.
Misread the RFC (Score:5, Informative)
RFC 3390 uses the "MUST" terminology exactly one place: when describing behavior after a packet is lost during the syn/synack. It doesn't use the phrase "MUST NOT" anywhere.
In every other respect slow-start is recommended but optional. Google is in no way breaching the standard by not using it.
Re:Misread the RFC (Score:5, Informative)
RFC 3390 uses the "MUST" terminology exactly one place: when describing behavior after a packet is lost during the syn/synack. It doesn't use the phrase "MUST NOT" anywhere.
In every other respect slow-start is recommended but optional. Google is in no way breaching the standard by not using it.
I just logged in to say exactly the same thing. Not implementing an optional variant is not cheating. Nothing to see, move along.
Re:Misread the RFC (Score:5, Insightful)
No, this was just kdawson trying to fill his FUD quota for the day. He's a little behind.
Re:Misread the RFC (Score:5, Insightful)
Yes, and for a post complaining about cheating I am mildly annoyed that he himself cheated his way around my "filter all posts made by editor kdawson" setting by submitting his story as a normal user and then getting another editor to post it.
Re:Misread the RFC (Score:4, Insightful)
He probably knows he's being filtered by more and more people.
Re: (Score:1, Funny)
Re: (Score:2, Funny)
Ah. I was a bit surprised to see this is a kdawson story for exactly that reason. Thanks.
Where's my bigger hammer?
Re:Misread the RFC (Score:4, Interesting)
Re: (Score:2)
Maybe he cheated his way back in as well? ;)
Re:Misread the RFC (Score:5, Informative)
Not sure why you got modded informative since the original poster and your "me-too" are both wrong . RFC 3390 is an extension to RFC2581. RFC 3390 says you MAY use an IW of up to 4 segments. If you don't use this option, you fall under RFC2581 which says the IW MUST be less than or equal to 2 segments.
http://www.rfc-editor.org/rfc/rfc3390.txt [rfc-editor.org]
http://www.rfc-editor.org/rfc/rfc2581.txt [rfc-editor.org]
Re: (Score:2)
Then how the average server admin can take advantage of this? ;)
Re: (Score:2)
Then how the average server admin can take advantage of this? ;)
This.
Good god, screw the standards. If it's good enough for microgoogle, we should be doing it too. The only thing we have to lose is visitors to our own damn sites, right? So how can I tune my kernel / apache to firehose the TCP window? xD
Re: (Score:2, Informative)
RFC 3390 defines the upper bound for the initial window to be min (4*MSS, max (2*MSS, 4380 bytes)), so it doesn't need to use "MUST NOT" to forbid larger initial window sizes.
Re:Misread the RFC (Score:5, Insightful)
IETF uses the capitalized MUST/MUST NOT terminology for a reason. It's used anywhere an implementer could reasonably do something else but for some reason isn't allowed to. Where it isn't present, it isn't required. If the authors omitted that terminology even after referencing RFC 2119 in a standards track modification to such a widely used protocol, they did so because the entire modification is optional.
Re: (Score:3, Informative)
Indeed the modification is optional. It explicitly says so in the RFC. However, without the modification an even smaller initial window is set by the previous definition, which comes with all the MUSTs and MUST NOTs you can throw at an implementer.
Re: (Score:2)
Reference please? I'm afraid I'm not up on the sequence of TCP RFCs so I don't know where to find the "previous definition."
Re: (Score:3, Informative)
Do you always have other people do your homework?
From RFC3390 (that's the one we're discussing):
"This document obsoletes [RFC2414] and updates [RFC2581] and specifies
an increase in the permitted upper bound for TCP's initial window
from one or two segment(s) to between two and four segments."
I'd start with the one which RFC3390 updates.
Re: (Score:3, Informative)
Learn how to use Google man!
http://www.rfc-editor.org/rfc/rfc3390.txt [rfc-editor.org] [rfc-editor.org]
http://www.rfc-editor.org/rfc/rfc2581.txt [rfc-editor.org] [rfc-editor.org]
Re: (Score:3, Insightful)
What, are you stupid?
"Document A doesn't say what you claim."
"Yeah, but there's a previous document which does."
"What previous document is that?"
"Hur, learn to use google dude."
Re: (Score:2)
Learn how to use Google man!
Maybe they tried, but their router rejected the connection from Google because it was sending too many packets in the initial window.
Re: (Score:1, Insightful)
This is complete nonsense.
The sign of a good RFC writer is not littering a document with MUST *** termonology. After a certain threshold it gets really old and implementors begin to ignore you.
If there is a magic defined in an RFC or an algorithm used in a certain way more often than not it will
Re: (Score:2)
This increased initial window is optional: a TCP MAY start with a larger initial window. However, we expect that most general-purpose TCP implementations would choose to use the larger initial congestion window given in equation (1) above.
Re: (Score:3, Informative)
Yes, that means you're free to use the (smaller) limit from the older RFC or the new (larger) one from RFC3390. The authors expect most implementations to use the new one, which would allow Google to send 3 packets without waiting for ACKs. Google sends up to 9.
Re: (Score:1, Informative)
From the RFC.
This document obsoletes [RFC2414] and updates [RFC2581] and specifies
an increase in the permitted upper bound for TCP's initial window
from one or two segment(s) to between two and four segments.
So it was officially increased in 2002.
Maybe back then an initial window 2 - 4 segments seemed reasonable.
Maybe the official standard is due for an update.
For some reason I am not indignant about this news.
Re:Misread the RFC (Score:4, Insightful)
Kay, so I've poked through the RFCs a bit...
TCP first defined in RFC 793. No slow start; implementations generally send segments up to the window size negotiated in SYN exchange which is generally the smaller of the speakers' two buffers.
Slow start first referenced in RFC 1122 (Internet host requirements) as: ''Recent work by Jacobson [ACM SIGCOMM-88] on Internet congestion and TCP retransmission stability has produced a transmission algorithm combining "slow start" with "congestion avoidance". A TCP MUST implement this algorithm.''
At this point in the process there does not appear to be an RFC specifying TCP slow start making this statement in a document that is not itself about TCP per se very dubious.
A decade later, RFC 2001 says: "Modern implementations of TCP contain four intertwined algorithms that have never been fully documented as Internet standards: slow start, congestion avoidance, fast retransmit, and fast recovery." The word "must" is subsequently used in connection with congestion avoidance but is not used in connection with slow start.
RFC2414 then revisits the question of TCP's initial window size selection referencing RFC 2001 but again declines to state that TCP "must" start with a small window.
RFC 2581 finally sets an unambiguous slow start requirement: The slow start and congestion avoidance algorithms MUST be used by a TCP sender [...] IW, the initial value of cwnd, MUST be less than or equal to 2*SMSS bytes and MUST NOT be more than 2 segments.
However, even as it does so, it goes on to comment that, "We note that a non-standard, experimental TCP extension allows that a TCP MAY use a larger initial window [...] We do NOT allow this change as part of the standard defined by this document. However, we include discussion [...] in the remainder of this document as a guideline for those experimenting with the change, rather than conforming to the present standards for TCP congestion control."
In other words, even though out of the box TCPs MUST implement slow start, it's understood that other behaviors are in use and are expected to continue.
Finally, RFC 3390 allows the out-of-the-box behavior of TCP to use a larger initial window than 2581.
Conclusion: Google still isn't cheating.
Re: (Score:2)
Had you just quoted a standards document says "Here's how it's supposed to be done and now we'll offer some suggestions for all of you who decide not to do it this way" I'm not so sure I'd be quick accuse you of being the source of any cognitive dissonance.
Re: (Score:3, Interesting)
We do NOT allow this change as part of the standard defined by this document.
Seems fairly unambiguous to me.
People have been gaming slow-start for yonks; I remember when you could ACK flood a server to increase your download speed. Server admins hated it because it slowed the site down for everyone else.
Re: (Score:2)
Are you sure that the experimental extension being referred to in RFC2581 is not the one that was later formalized as RFC 3390, whose
larger limits are still being violated apparently by Microsoft and Google and several others.
Also, the RFC 2581 standard noted that "a NON-STANDARD EXPERIMENTAL TCP extension allows...bigger"
Experimentation might be permissible, but vast-scale operational use of the non-standard extension by Google & Microsoft cannot
be described as expermentation, and therefore is clearly
Re: (Score:2)
It could still be described as experimental: Seeking if it works on large scale operation and across any kind of devices. So not cheating, if they have intend to drop it, or if it's good suggest in a subsequent RFC for widespread implementation.
My personal general rule of thumb is: It's not cheating if it A) Works, B) Does not have any significant negative impact
and my another rule of thumb is: It's a must have if A) lowers cost of operation, B) net benefit greatly outweights negatives
of course my general r
Re: (Score:3, Funny)
IOW, RTFRFC.
Re: (Score:1)
Re: (Score:2)
Heck, why is slow-start even still around then?
Now that, my friend, is a VERY good question.
Re: (Score:1)
So then I guess everybody should just skip slow-start then? If Google and Microsoft can and are having tremendous results, why shouldn't everybody? Heck, why is slow-start even still around then? Should be tossed to the wayside like a Colecovision if its optional and gets in the way of your performance...
Slow start probably should be skipped for most well tuned websites. Most HTTP connections are short lived enough to never ramp up to the available bandwidth or saturate queues so why use an algorithm designed to keep queues small while trying to efficiently use bandwidth.
I think the slow start concept would still be useful for bulk transfer services.. If you are serving a couple of gig ISO images then you probably don't care about a bit of round trip time latency if it means you don't clobber router queues
Re: (Score:2)
Re: (Score:2)
As people keep saying, you *may* use this optional standard.. as a replacement for an older standard where startup is *even slower*.
Odd how that goes.
Re: (Score:3, Informative)
Indeed, Google already published a paper describing their approach:
https://www.google.com/url?sa=t&source=web&cd=1&ved=0CA8QFjAA&url=http%3A%2F%2Fcode.google.com%2Fspeed%2Farticles%2Ftcp_initcwnd_paper.pdf&ei=xUciTKhpmOiUB_HL8bAP&usg=AFQjCNET-zahhIxtRlXe28xn_8QSXXLx6A&sig2=0mlyaOW1btaj7hUjlL1Opw [google.com]
Re: (Score:2)
It actually is already a step further then that, they have a draft RFC:
http://tools.ietf.org/html/draft-ietf-tcpm-initcwnd-00 [ietf.org]
I would have got first post... (Score:1, Funny)
lol kdawson (Score:5, Interesting)
So kdawson couldn't post this FUD himself? He needed Soulskill to do it for him?
Re: (Score:2)
Re:lol kdawson (Score:4, Interesting)
So kdawson couldn't post this FUD himself? He needed Soulskill to do it for him?
Considering that people cannot be objective about their own posts, I applaud kdawson for *not* posting this. Letting it go through someone else's editorial review is the right thing to do.
Re: (Score:1)
Editorial review? Your uid is small enough that you should know better. Maybe you're just super subtle.
Re: (Score:2)
I know it sometimes doesn't seem that way, but slashdot does have standards. The editors have written policies on how they do what they do, and they try to follow them. While slashdot editors often fail to live up to the standards that they strive for -- they tend to publish duplicate stories, press releases, trolls, advertisements, and blatant spelling errors -- they do tend to avoid the more egregious violations. The mistakes are more along the lines of sloppiness than malice. Presumably that's why we
TFA is really interesting! (Score:4, Interesting)
Before writing a post like this... (Score:2)
Before writing a post like this, you might want to wait a few minutes for the inevitable corrections to the inevitably wrong Slashdot story comes in. A good 50% of the stories on this site are misleading, and probably 25% of those are blatant lies.
Here's a pro-tip: if it says kdawson either as the editor *or* the submitter, it's complete bullshit. I don't think he's ever gotten a story entirely right in this whole career.
Somebody call the waaaaambulance (Score:3, Insightful)
When the competition starts crying you know someone is doing something right. Is it just me or has there been a lot of crying lately
Re: (Score:2, Insightful)
To understand the relevance of this: The slow-start protocol/algorithm is meant to avoid a situation where many packets are put on the wire which will never be received due to congestion somewhere along the path. Such packets create unnecessary network load (they're transported all the way to the choke point and then they're discarded, so they have to be retransmitted.) The referenced RFC is from 2002, so one might argue that there isn't a problem if the burst of packets remains small. After all, there are
Seems to me... (Score:3, Insightful)
I don't think it matters whether Google "cheats" or not. I and they both want me to get the data as quickly as possible. Strict adherence to the guidelines doesn't matter to either of us and doesn't affect anyone else.
Re: (Score:2)
This.
In the real world, expect almost everyone to prioritize "what works best" over "what the standard says" except insofar as satisfying B is necessary to achieve A.
Tragedy of the Commons (Score:2)
You do realize that if servers on the Internet start ignoring Internet standards (RFCs) as a matter of usual
practice that there is a very good chance the net will, if not grind to a halt, develop instability, the probability
of unreliability, poor performance, isolated unreachable islands etc.
This is a clear case of the tragedy of the commons. Only the general adherence to RFCs and effective
shunning mechanisms have prevented the tragedy from occurring so far.
Re: (Score:2, Interesting)
Strict adherence to the guidelines doesn't matter to either of us and doesn't affect anyone else.
The Goal of slow start is to achieve minimal loss and fairness with all flows.
Fairness does effect other people. Not using slow start is much more aggressive and can stop on other people's data flows, particularly when a shared WAN is involved, even flows that might be much more important than your casual Google search.
But this may be a bigger concern for large ISPs that oversubscribe by having hundre
Re:Seems to me... (Score:4, Insightful)
It's going to be OK, provided it's only a small amount of traffic involved. But if everyone starts sending a lot of traffic like this... boom!
In a sense Google are just saying that their search results are high priority traffic, and they've optimised it like that. Which is probably fair enough.
But if you did that to anything that creates huge numbers of connections very rapidly and then sends a lot of data, perhaps using it for peer-peer networks, the network would start to suffer collapse.
Re: (Score:2)
Well, not really. They created a draft RFC which says, we can all do this. Because Google has a lot of visitors on their sites and they tested, monitored and analyzed this and wrote a paper about it.
It being, that current connections have enough bandwidth to justify making an other change to the standard. Instead of the old initial window of 3 or 4 (which has been raised before from 1 or 2) they propose to make it 9 or 10.
One of the reasons they say is, because current browsers (read: that is not IE6 or IE7
Editors shouldn't be allowed to post stories. (Score:5, Insightful)
I intentionally removed kdawson and timothy from the front page on slashdot just so I wouldn't have to see their ignorant, retarded, not a fucking clue posts ...
Did they realize that no one read their tripe anymore now they have to have someone else approve it for them?
kdawson and timothy are idiots, please give me a way to automatically not see anything that has to do with those two morons. Please.
kdawson is cheating to get around the effort I put on not seeing his crap, MS and Google on the other hand are following the RFC just fine ... if anyone involved in the posting of this story had a clue about what it said or did any sort of actual research than I wouldn't have to rant about it ...
Re: (Score:2)
No, our gripe really is with kdawson.
Re: (Score:1, Funny)
"please give me a way to automatically not see anything that has to do with those two morons. Please" Duct tape over eyes?
Wow, I'm impressed. (Score:2)
Re: (Score:2)
"Ad hominem attack..."
"8 digit registered LUSER ID..."
If you're going to do all the work for me, there's no point in arguing. I'll just apologise for pricking your ego and leave it there.
This is well known to a small community (Score:5, Insightful)
That's been known in the TCP community for decades.
I looked at this back in my RFC 896 [faqs.org] days, when TCP was in initial development and I was working on congestion. I introduced the "congestion window" concept and put it in a TCP implementation (3COM's UNET, which predated Berkeley BSD). The question was, what should be the initial size of the congestion window? If it's small, you get "slow start"; if it's large, the sender can blast a big chunk of data at the receiver at start, up to the amount of buffering the receiver is advertising.
I decided back then to start with a big congestion window, because starting with a small one would slow down traffic even when bandwidth was available. One of the big performance issues back then was the time required to FTP a directory across a LAN, where TCP connections were being set up and torn down at a high rate. So startup time mattered. The decision to go with a smaller initial congestion window size came years later, from others. This reflected trends in router design. I wanted routers to have "fair queuing", so that sending lots of packets from one source didn't gain the sender any bandwidth over sending few packets. But routers gained speed faster than RAM costs dropped, and so faster routers couldn't have enough RAM for fair queuing. Today, your "last mile" CISCO router might have fair queuing [nil.com]. Some DOCSIS cable modem termination units have it. [cascaderange.org] But many routers are running Random Early Drop, which is a simple but mediocre approach. (The backbone routers barely queue at all; if they can't forward something fast, they drop it. Network design tries to keep the congestion near the edges, where it can be dealt with.)
Remember, every dropped packet has to be retransmitted. (Too much of that leads to congestion collapse, a term I coined in 1984. That's what the "Nagle algorithm" is about.) In a world with packet-dropping routers, "slow start" makes sense. So that was put into TCP in the late 1980s (by which time I was out of networking.)
However, the RFC-documented slow start algorithm is rather conservative. RFC 2001 says to start at one maximum segment size. Microsoft's implementations in Win95 and later start at two maximum segment sizes [microsoft.com]. In RFC 3390, from 2002, the limit was raised to 3 or 4 maximum segment sizes. (We used to worry about delaying keystroke echo too much because big FTP packets were tying up the 9600 baud lines too long. We're past that.)
But Google is sending at least 8 segments at start, and Microsoft was observed to be sending 43. Sending 43 packets blind is definitely overdoing it.
I wonder whether they're doing this blindly, or if there's more smarts behind the scenes. If their TCP implementation kept a cache of recent final congestion window sizes by IP address, they could legitimately start off the next connection with the value from the last one. So, having discovered a path that's not dropping big bursts of packets, they could legitimately start fast. If they're just doing it the dumb way, starting fast every time, that's going to choke some part of the net under heavy load.
Re:This is well known to a small community (Score:5, Funny)
Are you a wizard?
Re:This is well known to a small community (Score:5, Funny)
Are you a wizard?
No; his UID is too high. Now fetch me a sandwich, son.
Re: (Score:2)
I can fetch it, but I will NOT make one for you.
Re: (Score:1)
Re:This is well known to a small community (Score:5, Informative)
Are you a wizard?
No, he's John Nagle.
Re:This is well known to a small community (Score:5, Insightful)
Yes, that's my understanding as well---the point of slow start is to go easy on the output queues of whichever routers experience congestion, so if congestion happens only on the last mile a hypothetical bad slow-start tradeoff does indeed only affect that one household (not necessarily only that one user), but if it happens deeper within the Internet it's everyone's problem contrary to what some other posters on this thread have been saying.
WFQ is nice but WFQ currently seems to be too complicated to implement in an ASIC, so Cisco only does it by default on some <2Mbit/s interfaces. Another WFQ question is, on what inputs do you do the queue hash? For default Cisco it's on TCP flow, which helps for this discussion, but I will bet you (albeit a totally uninformed bet) that CMTS will do WFQ per household putting all the flows of one household into the same bucket, since their goal is to share the channel among customers, not to improve the user experience of individual households---they expect people inside the house to yell at each other to use the internet ``more gently'' which is pathetic. In this way, WFQ won't protect a household's skype sessions from being blasted by MS fast-start the way Cisco default WFQ would.
If anything, cable plants may actually make TCP-algorithm-related congestion worse because I heard a rumor they try to conserve space on their upstream channel by batching TCP ACK's, which introduces jitter, meaning the windowsize needs to be larger, and makes TCP's downstream more ``microbursty'' than it needs to be. If they are going to batch upstream on purpose, maybe they should timestamp upstream packets in the customer device and delay them in the CMTS to simulate a fixed-delay link---they could do this TS+delay per-flow rather than per-customer if they do not want to batch all kinds of packets (ex maybe let DNS ones through instantly).
RED is not too complicated to implement in ASIC, but (a) I think many routers, including DSLAM's, actually seem to be running *FIFO* which is much worse than RED even, because it can cause synchronization when there are many TCP flows---all the flows start and stop at once. (b) RED is not that good because it has parameters that need to be tuned according to approximately how many TCP flows there are. I think BLUE is much better in this respect, and is also simple enough to implement in ASIC, but AFAIK nobody has.
I think much of the conservatism on TCP implementers' part can be blamed on router vendors failing to step up and implement decades-old research on practical ASIC-implementable queueing algorithms. I've the impression that even the latest edge stuff focuses on having deep, stupid (FIFO) queues (Arista?) or minimizing jitter (Nexus?). Cisco has actually taken RED *off* the menu for post-6500 platforms: 3550 had it on the uplink ports, but 3560 has ``weighted tail drop'' which AFAICT is just fancy FIFO. I'd love to be proved wrong by someone who knows more, but I think they are actually moving backwards rather than stepping up and implementing BLUE [thefengs.com].
and I like very much your point that cacheing window sizes per /32 is the right way to solve this rather than haggling about the appropriate default, especially in the modern world of megasites and load balancers where a clever site could appear to share this cached knowledge quite widely. but IMSHO routing equipment vendors need to be stepping up to the TCP game, too.
Re: (Score:2)
Respect ...
Re: (Score:3, Insightful)
I wonder whether they're doing this blindly, or if there's more smarts behind the scenes. If their TCP implementation kept a cache of recent final congestion window sizes by IP address, they could legitimately start off the next connection with the value from the last one. So, having discovered a path that's not dropping big bursts of packets, they could legitimately start fast. If they're just doing it the dumb way, starting fast every time, that's going to choke some part of the net under heavy load.
That strikes me as still-kinda-eigthies-thinking. I guess the question is what your assumption for an unknown segment of network is: If you assume that all parts of the net are congested most of the time, then you'll want to do a fast start up only on those segments that you know can handle it (doesn't have to be an individual IP - If my ISP buffers alright and you can reach it alright then it doesn't matter how many folks are sitting downstream from them - it becomes their problem.) If, on the other hand,
Re: (Score:2)
These days I'd wager that the vast (VAST!) majority of packets are part of ongoing streams - streaming Netflix over the net, torrenting the collected porn of the 80ies, that kind of thing.
True. However, many of those streams are bandwidth-adaptive and heavily buffered.
Re: (Score:2)
Wouldn't it also be necessary to cache the _rate_ of transmission so you don't overflow some intermediate queue? Eg imagine your sever is on gigE, feeding into a 1 Mbps uplink, and then a loooong pipe to the client who is on the other side of the world. In this case you might want to have an initial cwnd of a few dozen packet
New era of networks (Score:2, Interesting)
Slow start and congestion avoidance were designed in the time of unreliable networks. Shouldn't the TCP/IP protocol be rediscussed in the age of fiber networks?
Re: (Score:2)
Congestion, route changes, blackholes, etc. also makes for unreliable networks. I don't think we want to change it. This is just a discussion about making slow start start with a larger window.
Web App (Score:2)
Well, this guy discovered something but wasted time he should have been working on his web app ;)
What about TCP congestive backoff and recover? (Score:2)
Has anyone taken a look at whether Google, Microsoft, et al are similarly pushing on the TCP congestion backoff and recovery mechanisms?
Standardization, the right way... (Score:2, Insightful)
First, implement it, and show that it works in practice.
Later, standardize the proven best practices.
Google, ur doin' it rite! :D
Re: (Score:2)
Their is also a draft here:
http://tools.ietf.org/html/draft-ietf-tcpm-initcwnd-00 [ietf.org]
The testing and analyzing is here:
http://code.google.com/speed/articles/tcp_initcwnd_paper.pdf [google.com]
Someone tell Linus it'll make his laptop go faster (Score:2)
Re: (Score:2)
If you type
man ip
You will see that you can set the initial congestion window on a given route using
ip route change initcwnd NUMBER
*Where NUMBER=The maximum initial congestion window (cwnd) size in MSS of a TCP connection. I believe applications may also choose socket options although most of the time it's left to the OS. So go ahead and set it to 10 or whatever.
Re: (Score:2)
Yes, 10 has been recommend as the new initial window:
http://tools.ietf.org/html/draft-hkchu-tcpm-initcwnd-01 [ietf.org]
Re: (Score:2)
I think you meant:
ip route change default via $GW dev eth0 initcwnd 10
Where $GW is your default gateway.
Results may vary (Score:2)
I'm not getting the blinding fast response time shown in the article at all :(
Google looks up my country via geo-location and feeds me a localised version (tested via the curl method in the article). This takes 0.9 seconds for me. If I directly specify google.co.uk or some other variation, I get a more reasonable 0.3 seconds. But never 85ms. Is the author sitting on a really awesome connection at work? ;)
Any "real world" complaints? (Score:2)
I understand the theoretical problem with breaking the spec, but since it actually took this guy a packet sniffer to detect the violation, it would seem that, in practice, most (all?) clients out there are perfectly capable of processing this non-standard response. If so, then I don't see a problem, since it really is a de facto standard - and those appear all the time. The best thing they could do then is publish a new RFC to make it part of the spec, and move on.
RFC 5681 (Score:2, Informative)
I suppose now would be a good time to point out that RFC 5681 [ietf.org] is the most current specification of the standard for TCP congestion control. Would it be asking too much for people to stay current on the RFC series before they start cracking off about standards compliance?
I'm sorry... (Score:1)
When did RFCs official standards at which you could "cheat"?
Consider this "cheating" Google and Microsoft's comments.
Re: (Score:1)
There are other protocols such as SCTP intended to address shortcommings of TCP... Yet after all these years nobody seems to care that they even exist. If TCP were as bad as your remarks suggest I would have expected more takers on the alternatives?
You comment TCP is so broken and backwards yet I don't know and you do
Re: (Score:2)
HTTP only supports one active stream over TCP or SSL/TLS, SPDY is a proposal to allow HTTP over TCP or SSL/TLS to support multiple streams:
http://www.chromium.org/spdy/spdy-whitepaper [chromium.org]
I'm guessing only multiple HTTP streams over SSL/TLS will be very backward compatibility with the existing internet.
Thus soon, https (thus SSL/TLS) with the SPDY extension may even be faster to load your webpage than normal HTTP.