Change the IO buffer size on Windows to 32k

runtime/bin/eventhandler_win.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/eventhandler.h"
 
 #include <process.h>  // NOLINT
 #include <winsock2.h>  // NOLINT
 #include <ws2tcpip.h>  // NOLINT
 #include <mswsock.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/utils.h"
 #include "platform/thread.h"
 
 
+#define BUFFER_SIZE 32 * 1024

[Mads Ager (google), 2013/03/19 15:11:20]

Please use a constant as below.

static const int kBufferSize = 32 * 1024;

[Søren Gjesse, 2013/03/19 15:26:48]

Done.

+
 static const int kInfinityTimeout = -1;
 static const int kTimeoutId = -1;
 static const int kShutdownId = -2;
 
 IOBuffer* IOBuffer::AllocateBuffer(int buffer_size, Operation operation) {
   IOBuffer* buffer = new(buffer_size) IOBuffer(buffer_size, operation);
   return buffer;
 }
 
 
@@ skipping 194 matching lines @@
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
   }
 }
 
 
 bool Handle::IssueRead() {
   ScopedLock lock(this);
   ASSERT(type_ != kListenSocket);
   ASSERT(pending_read_ == NULL);
-  IOBuffer* buffer = IOBuffer::AllocateReadBuffer(1024);
+  IOBuffer* buffer = IOBuffer::AllocateReadBuffer(BUFFER_SIZE);
   if (SupportsOverlappedIO()) {
     ASSERT(completion_port_ != INVALID_HANDLE_VALUE);
 
     BOOL ok = ReadFile(handle_,
                        buffer->GetBufferStart(),
                        buffer->GetBufferSize(),
                        NULL,
                        buffer->GetCleanOverlapped());
     if (ok || GetLastError() == ERROR_IO_PENDING) {
       // Completing asynchronously.
@@ skipping 236 matching lines @@
   }
   return num_bytes;
 }
 
 
 int Handle::Write(const void* buffer, int num_bytes) {
   ScopedLock lock(this);
   if (SupportsOverlappedIO()) {
     if (pending_write_ != NULL) return 0;
     if (completion_port_ == INVALID_HANDLE_VALUE) return 0;
-    if (num_bytes > 4096) num_bytes = 4096;
+    if (num_bytes > BUFFER_SIZE) num_bytes = BUFFER_SIZE;
     pending_write_ = IOBuffer::AllocateWriteBuffer(num_bytes);
     pending_write_->Write(buffer, num_bytes);
     if (!IssueWrite()) return -1;
     return num_bytes;
   } else {
     DWORD bytes_written = -1;
     BOOL ok = WriteFile(handle_,
                         buffer,
                         num_bytes,
                         &bytes_written,
@@ skipping 478 matching lines @@
     FATAL("Failed to initialized Windows sockets");
   }
 }
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 #endif  // defined(TARGET_OS_WINDOWS)