Forgot your password?
typodupeerror
The Internet Google Microsoft Technology

Google, Microsoft Cheat On Slow-Start — Should You? 123

Posted by Soulskill
from the reply-hazy-ask-again dept.
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?'"
This discussion has been archived. No new comments can be posted.

Google, Microsoft Cheat On Slow-Start — Should You?

Comments Filter:
  • I do. (Score:5, Funny)

    by cgomezr (1074699) on Friday November 26, 2010 @02:52PM (#34351692)

    Without cheating, I wouldn't get the first post.

    • Re: (Score:2, Funny)

      by Tridus (79566)

      Is this possibly the first ever on-topic "first!" post?

    • by Oxford_Comma_Lover (1679530) on Friday November 26, 2010 @03:38PM (#34351990)

      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)

        by pthisis (27352)

        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)

        by teridon (139550)
        Isn't it time /. got a "-1 Reply Abuse" mod? The parent reply has nothing to do with the GP. It's on topic, and maybe it deserves the "Insightful" mod -- but it's replying to the top post just to appear at the top of the page. STOP THE MADNESS!
  • Misread the RFC (Score:5, Informative)

    by Spazmania (174582) on Friday November 26, 2010 @02:54PM (#34351708) Homepage

    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)

      by H0p313ss (811249) on Friday November 26, 2010 @03:02PM (#34351764)

      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: (Score:2, Informative)

      by Anonymous Coward

      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)

        by Spazmania (174582) on Friday November 26, 2010 @03:17PM (#34351872) Homepage

        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)

          by Anonymous Coward

          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.

          • by Spazmania (174582)

            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)

              by Anonymous Coward

              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)

              by fluffy99 (870997)

              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)

                by Spazmania (174582)

                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."

              • by gringer (252588)

                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)

          by Anonymous Coward

          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

          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

      • 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)

          by Anonymous Coward

          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)

      by Anonymous Coward

      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)

        by Spazmania (174582) on Friday November 26, 2010 @04:30PM (#34352452) Homepage

        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.

        • 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

          • by Skal Tura (595728)

            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)

      by halivar (535827)

      IOW, RTFRFC.

    • 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...
      • by Spazmania (174582)

        Heck, why is slow-start even still around then?

        Now that, my friend, is a VERY good question.

      • by samson13 (1311981)

        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

    • by msauve (701917)
      Even simpler. The very first line of the abstract says "This document specifies an optional standard..." The whole thing is a "MAY."
      • 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.

  • by Anonymous Coward
    ...if it wasn't for slow start. Damn you, cwnd!
  • lol kdawson (Score:5, Interesting)

    by Lunix Nutcase (1092239) on Friday November 26, 2010 @02:56PM (#34351728)

    So kdawson couldn't post this FUD himself? He needed Soulskill to do it for him?

    • by canajin56 (660655)
      Obviously, his answer to the question of "should you cheat, too?" is "yes", and he started by cheating his way around my preferences that exclude all kdawson articles ;)
    • Re:lol kdawson (Score:4, Interesting)

      by Morty (32057) on Friday November 26, 2010 @04:51PM (#34352676) Journal

      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.

      • Editorial review? Your uid is small enough that you should know better. Maybe you're just super subtle.

        • by Morty (32057)

          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

  • by courteaudotbiz (1191083) on Friday November 26, 2010 @03:00PM (#34351756) Homepage
    Great, yet simple research! It's funny to see how the web servers are acting exactly as their own mother company in real life:
    • Google: Trying to be the first, tries to make a standard with some promising trick;
    • Microsoft: Bypassing all rules to be the first;
    • All the others: pretty average (I'd have expected Facebook to be more innovative on this side. Wait when they discover that this trick exists...)
    • 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.

  • by js3 (319268) on Friday November 26, 2010 @03:03PM (#34351766)

    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)

      by Anonymous Coward

      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)

    by 91degrees (207121) on Friday November 26, 2010 @03:13PM (#34351842) Journal
    This is reliable. It is comaptible with the spec (otherwise it wouldn't be reliable), and it's faster.

    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.
    • 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.

      • 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)

      by mysidia (191772)

      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)

      by WolfWithoutAClause (162946) on Friday November 26, 2010 @03:55PM (#34352132) Homepage

      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.

      • by Lennie (16154)

        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

  • by BitZtream (692029) on Friday November 26, 2010 @03:16PM (#34351864)

    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:1, Funny)

      by Anonymous Coward

      "please give me a way to automatically not see anything that has to do with those two morons. Please" Duct tape over eyes?

  • by Animats (122034) on Friday November 26, 2010 @03:36PM (#34351978) Homepage

    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.

    • by Jay Tarbox (48535) on Friday November 26, 2010 @04:09PM (#34352250) Homepage Journal

      Are you a wizard?

    • by carton (105671) on Friday November 26, 2010 @04:44PM (#34352602)

      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.

    • Respect ...

    • Re: (Score:3, Insightful)

      by Iron Condor (964856)

      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,

      • by Animats (122034)

        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.

    • 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.

      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)

    by Anonymous Coward

    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?

    • by Lennie (16154)

      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.

  • by hey (83763)

    Well, this guy discovered something but wasted time he should have been working on his web app ;)

  • Has anyone taken a look at whether Google, Microsoft, et al are similarly pushing on the TCP congestion backoff and recovery mechanisms?

  • First, implement it, and show that it works in practice.

    Later, standardize the proven best practices.

    Google, ur doin' it rite! :D

  • Please, I'd like to use this on our web servers too... :-P
    • by inKubus (199753)

      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.

  • 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? ;)

  • 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)

    by j h woodyatt (13108)

    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?

  • When did RFCs official standards at which you could "cheat"?

    Consider this "cheating" Google and Microsoft's comments.

10 to the 6th power Bicycles = 2 megacycles

Working...