Only tune SO_SNDBUF/SO_RCVBUF sizes for pre-Vista systems.

net/base/tcp_client_socket_win.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/tcp_client_socket.h"
 
 #include "base/memory_debug.h"
 #include "base/string_util.h"
+#include "base/sys_info.h"
 #include "base/trace_event.h"
 #include "net/base/net_errors.h"
 #include "net/base/winsock_init.h"
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 
 static int MapWinsockError(DWORD err) {
   // There are numerous Winsock error codes, but these are the ones we thus far
@@ skipping 224 matching lines @@
 
 int TCPClientSocket::CreateSocket(const struct addrinfo* ai) {
   socket_ = WSASocket(ai->ai_family, ai->ai_socktype, ai->ai_protocol, NULL, 0,
                       WSA_FLAG_OVERLAPPED);
   if (socket_ == INVALID_SOCKET) {
     DWORD err = WSAGetLastError();
     LOG(ERROR) << "WSASocket failed: " << err;
     return MapWinsockError(err);
   }
 
-  // Increase the socket buffer sizes from the default sizes.
-  // In performance testing, there is substantial benefit by increasing
-  // from 8KB to 32KB.  I tested 64, 128, and 256KB as well, but did not
-  // see additional performance benefit (will be network dependent).
+  // Increase the socket buffer sizes from the default sizes for WinXP.  In
+  // performance testing, there is substantial benefit by increasing from 8KB
+  // to 64KB.
   // See also:
   //    http://support.microsoft.com/kb/823764/EN-US
-  // On XP, the default buffer sizes are 8KB.
-  const int kSocketBufferSize = 32 * 1024;
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
-      reinterpret_cast<const char*>(&kSocketBufferSize),
-      sizeof(kSocketBufferSize));
-  DCHECK(!rv) << "Could not set socket send buffer size";
-  rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
-      reinterpret_cast<const char*>(&kSocketBufferSize),
-      sizeof(kSocketBufferSize));
-  DCHECK(!rv) << "Could not set socket receive buffer size";
+  // On Vista, if we manually set these sizes, Vista turns off its receive
+  // window auto-tuning feature.
+  //    http://blogs.msdn.com/wndp/archive/2006/05/05/Winhec-blog-tcpip-2.aspx
+  // Since Vista's auto-tune is better than any static value we can could set,
+  // only change these on pre-vista machines.
+  int32 major_version, minor_version, fix_version;
+  base::SysInfo::OperatingSystemVersionNumbers(&major_version, &minor_version,
+    &fix_version);
+  if (major_version < 6) {
+    const int kSocketBufferSize = 64 * 1024;
+    int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+        reinterpret_cast<const char*>(&kSocketBufferSize),
+        sizeof(kSocketBufferSize));
+    DCHECK(!rv) << "Could not set socket send buffer size";
+    rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
+        reinterpret_cast<const char*>(&kSocketBufferSize),
+        sizeof(kSocketBufferSize));
+    DCHECK(!rv) << "Could not set socket receive buffer size";
+  }
 
   // Disable Nagle.
   // The Nagle implementation on windows is governed by RFC 896.  The idea
   // behind Nagle is to reduce small packets on the network.  When Nagle is
   // enabled, if a partial packet has been sent, the TCP stack will disallow
   // further *partial* packets until an ACK has been received from the other
   // side.  Good applications should always strive to send as much data as
   // possible and avoid partial-packet sends.  However, in most real world
   // applications, there are edge cases where this does not happen, and two
   // partil packets may be sent back to back.  For a browser, it is NEVER
   // a benefit to delay for an RTT before the second packet is sent.
   //
   // As a practical example in Chromium today, consider the case of a small
   // POST.  I have verified this:
   //     Client writes 649 bytes of header  (partial packet #1)
   //     Client writes 50 bytes of POST data (partial packet #2)
   // In the above example, with Nagle, a RTT delay is inserted between these
   // two sends due to nagle.  RTTs can easily be 100ms or more.  The best
   // fix is to make sure that for POSTing data, we write as much data as
   // possible and minimize partial packets.  We will fix that.  But disabling
   // Nagle also ensure we don't run into this delay in other edge cases.
   // See also:
   //    http://technet.microsoft.com/en-us/library/bb726981.aspx
   const BOOL kDisableNagle = TRUE;
-  rv = setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY,
+  int rv = setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY,
       reinterpret_cast<const char*>(&kDisableNagle), sizeof(kDisableNagle));
   DCHECK(!rv) << "Could not disable nagle";
 
   return OK;
 }
 
 void TCPClientSocket::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(callback_);
 
@@ skipping 75 matching lines @@
 void TCPClientSocket::WaitForAndResetEvent() {
   // TODO(wtc): Remove the CHECKs after enough testing.
   DWORD wait_rv = WaitForSingleObject(overlapped_.hEvent, INFINITE);
   CHECK(wait_rv == WAIT_OBJECT_0);
   BOOL ok = WSAResetEvent(overlapped_.hEvent);
   CHECK(ok);
 }
 
 }  // namespace net