http2: increase default window sizes

Increase the default HTTP/2 stream window from 64KB (65535) to 4MB
(4194304) and the default local connection window to 32MB (33554432).

The default 64KB window limits throughput on high-latency connections
to window_size / RTT. With a 250ms RTT, throughput is limited to
256KB/s. The new defaults improve throughput to 16MB/s (128Mbps)
for the stream window and 128MB/s (1Gbps) for the connection window.

Fixes: #38426
Signed-off-by: Matteo Collina <hello@matteocollina.com>
PR-URL: #64623
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Tim Perry <pimterry@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>
Reviewed-By: Aviv Keller <me@aviv.sh>
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>

Author: mcollina

doc/api/http2.md

@@ -3656,7 +3656,7 @@ properties.
   permitted on the `Http2Session` instances. **Default:** `true`.
 * `initialWindowSize` {number} Specifies the _sender's_ initial window size in
   bytes for stream-level flow control. The minimum allowed value is 0. The
-  maximum allowed value is 2<sup>32</sup>-1. **Default:** `65535`.
+  maximum allowed value is 2<sup>32</sup>-1. **Default:** `4194304`.
 * `maxFrameSize` {number} Specifies the size in bytes of the largest frame
   payload. The minimum allowed value is 16,384. The maximum allowed value is
   2<sup>24</sup>-1. **Default:** `16384`.

lib/internal/http2/core.js

@@ -1205,7 +1205,16 @@ function setupHandle(socket, type, options) {
   }
 
   const settings = typeof options.settings === 'object' ?
-    options.settings : {};
+    { ...options.settings } : {};
+
+  // Increase the default initial window size to improve throughput
+  // on high-latency connections. The HTTP/2 default of 65535 (64KB)
+  // limits throughput to window_size / RTT. By increasing to 4MB,
+  // throughput is significantly improved.
+  // See https://github.com/nodejs/node/issues/38426
+  if (settings.initialWindowSize === undefined) {
+    settings.initialWindowSize = constants.DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE;
+  }
 
   this.settings(settings);
 

src/node_http2.cc

@@ -612,6 +612,17 @@ Http2Session::Http2Session(Http2State* http2_state,
       &alloc_info), 0);
   session_.reset(session);
 
+  // Increase the default local connection window to improve throughput
+  // on high-latency connections. The default 64KB window limits throughput
+  // to window_size / RTT. With a 32MB connection window, throughput is
+  // significantly improved. See https://github.com/nodejs/node/issues/38426
+  CHECK_EQ(nghttp2_session_set_local_window_size(
+               session,
+               NGHTTP2_FLAG_NONE,
+               0,
+               DEFAULT_SETTINGS_LOCAL_CONNECTION_WINDOW_SIZE),
+           0);
+
   outgoing_storage_.reserve(1024);
   outgoing_buffers_.reserve(32);
 

src/node_http2.h

@@ -43,14 +43,18 @@ constexpr uint64_t kDefaultMaxSessionMemory = 10000000;
 constexpr uint32_t DEFAULT_SETTINGS_HEADER_TABLE_SIZE = 4096;
 constexpr uint32_t DEFAULT_SETTINGS_ENABLE_PUSH = 1;
 constexpr uint32_t DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS = 0xffffffffu;
-constexpr uint32_t DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE = 65535;
+constexpr uint32_t DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE = 4194304;
 constexpr uint32_t DEFAULT_SETTINGS_MAX_FRAME_SIZE = 16384;
 constexpr uint32_t DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE = 65535;
 constexpr uint32_t DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL = 0;
 constexpr uint32_t MAX_MAX_FRAME_SIZE = 16777215;
 constexpr uint32_t MIN_MAX_FRAME_SIZE = DEFAULT_SETTINGS_MAX_FRAME_SIZE;
 constexpr uint32_t MAX_INITIAL_WINDOW_SIZE = 2147483647;
 
+// Default local connection window size (32MB) to improve throughput
+// on high-latency connections. See https://github.com/nodejs/node/issues/38426
+constexpr uint32_t DEFAULT_SETTINGS_LOCAL_CONNECTION_WINDOW_SIZE = 33554432;
+
 // Stream is not going to have any DATA frames
 constexpr int STREAM_OPTION_EMPTY_PAYLOAD = 0x1;
 

src/stream_base.cc

@@ -752,6 +752,8 @@ void CustomBufferJSListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
 void ReportWritesToJSStreamListener::OnStreamAfterReqFinished(
     StreamReq* req_wrap, int status) {
   StreamBase* stream = static_cast<StreamBase*>(stream_);
+  if (stream == nullptr) return;
+  if (req_wrap == nullptr) return;
   Environment* env = stream->stream_env();
   if (!env->can_call_into_js()) return;
   AsyncWrap* async_wrap = req_wrap->GetAsyncWrap();

src/stream_pipe.cc

@@ -59,7 +59,7 @@ void StreamPipe::Unpipe(bool is_in_deletion) {
   is_closed_ = true;
   is_reading_ = false;
   source()->RemoveStreamListener(&readable_listener_);
-  if (pending_writes_ == 0)
+  if (pending_writes_ == 0 || sink_destroyed_)
     sink()->RemoveStreamListener(&writable_listener_);
 
   if (is_in_deletion) return;
@@ -159,13 +159,18 @@ void StreamPipe::WritableListener::OnStreamAfterWrite(WriteWrap* w,
   StreamPipe* pipe = ContainerOf(&StreamPipe::writable_listener_, this);
   pipe->pending_writes_--;
   if (pipe->is_closed_) {
-    if (pipe->pending_writes_ == 0) {
+    // If the sink has been destroyed, pending_writes_ may have been
+    // reset and we should check <= 0 instead of == 0. Also guard
+    // against the listener having already been removed.
+    bool writes_done = pipe->sink_destroyed_ ? pipe->pending_writes_ <= 0
+                                             : pipe->pending_writes_ == 0;
+    if (writes_done) {
       Environment* env = pipe->env();
       HandleScope handle_scope(env->isolate());
       Context::Scope context_scope(env->context());
       if (pipe->MakeCallback(env->oncomplete_string(), 0, nullptr).IsEmpty())
         return;
-      stream()->RemoveStreamListener(this);
+      if (stream() != nullptr) stream()->RemoveStreamListener(this);
     }
     return;
   }
@@ -213,7 +218,9 @@ void StreamPipe::WritableListener::OnStreamDestroy() {
   StreamPipe* pipe = ContainerOf(&StreamPipe::writable_listener_, this);
   pipe->sink_destroyed_ = true;
   pipe->is_eof_ = true;
-  pipe->pending_writes_ = 0;
+  // Don't reset pending_writes_ here; let OnStreamAfterWrite track
+  // completion naturally. Unpipe() will remove this listener from the
+  // sink regardless of pending_writes_ since sink_destroyed_ is set.
   pipe->Unpipe();
 }
 

test/parallel/test-http2-binding.js

@@ -17,7 +17,7 @@ const settings = http2.getDefaultSettings();
 assert.strictEqual(settings.headerTableSize, 4096);
 assert.strictEqual(settings.enablePush, true);
 assert.strictEqual(settings.maxConcurrentStreams, 4294967295);
-assert.strictEqual(settings.initialWindowSize, 65535);
+assert.strictEqual(settings.initialWindowSize, 4194304);
 assert.strictEqual(settings.maxFrameSize, 16384);
 
 assert.strictEqual(binding.nghttp2ErrorString(-517),
@@ -239,7 +239,7 @@ const defaultSettings = {
   DEFAULT_SETTINGS_HEADER_TABLE_SIZE: 4096,
   DEFAULT_SETTINGS_ENABLE_PUSH: 1,
   DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS: 4294967295,
-  DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE: 65535,
+  DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE: 4194304,
   DEFAULT_SETTINGS_MAX_FRAME_SIZE: 16384,
   DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE: 65535,
   DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL: 0

test/parallel/test-http2-client-setLocalWindowSize.js

@@ -73,15 +73,16 @@ const http2 = require('http2');
 
     client.on('connect', common.mustCall(() => {
       const windowSize = 2 ** 20;
-      const defaultSetting = http2.getDefaultSettings();
       client.setLocalWindowSize(windowSize);
 
       assert.strictEqual(client.state.effectiveLocalWindowSize, windowSize);
-      assert.strictEqual(client.state.localWindowSize, windowSize);
-      assert.strictEqual(
-        client.state.remoteWindowSize,
-        defaultSetting.initialWindowSize
-      );
+      // localWindowSize returns the available connection window.
+      // When decreasing from the default 33554432 to 1048576,
+      // the available window stays at 33554432.
+      assert.strictEqual(client.state.localWindowSize, 33554432);
+      // remoteWindowSize is the connection-level send window,
+      // which remains at the HTTP/2 default of 65535.
+      assert.strictEqual(client.state.remoteWindowSize, 65535);
 
       server.close();
       client.close();
@@ -101,18 +102,16 @@ const http2 = require('http2');
 
     client.on('connect', common.mustCall(() => {
       const windowSize = 20;
-      const defaultSetting = http2.getDefaultSettings();
       client.setLocalWindowSize(windowSize);
 
       assert.strictEqual(client.state.effectiveLocalWindowSize, windowSize);
-      assert.strictEqual(
-        client.state.localWindowSize,
-        defaultSetting.initialWindowSize
-      );
-      assert.strictEqual(
-        client.state.remoteWindowSize,
-        defaultSetting.initialWindowSize
-      );
+      // localWindowSize returns the available connection window.
+      // When decreasing from the default 33554432 to 20,
+      // the available window stays at 33554432.
+      assert.strictEqual(client.state.localWindowSize, 33554432);
+      // remoteWindowSize is the connection-level send window,
+      // which remains at the HTTP/2 default of 65535.
+      assert.strictEqual(client.state.remoteWindowSize, 65535);
 
       server.close();
       client.close();

test/parallel/test-http2-getpackedsettings.js

@@ -9,7 +9,7 @@ const http2 = require('http2');
 const check = Buffer.from([0x00, 0x01, 0x00, 0x00, 0x10, 0x00,
                            0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
                            0x00, 0x03, 0xff, 0xff, 0xff, 0xff,
-                           0x00, 0x04, 0x00, 0x00, 0xff, 0xff,
+                           0x00, 0x04, 0x00, 0x40, 0x00, 0x00,
                            0x00, 0x05, 0x00, 0x00, 0x40, 0x00,
                            0x00, 0x06, 0x00, 0x00, 0xff, 0xff,
                            0x00, 0x08, 0x00, 0x00, 0x00, 0x00]);

test/parallel/test-http2-pack-end-stream-flag.js

@@ -52,8 +52,10 @@ function testRequest(path, targetFrameCount, callback) {
     });
 }
 
-// SETTINGS => SETTINGS => HEADERS => DATA
-const MIN_FRAME_COUNT = 4;
+// SETTINGS => WINDOW_UPDATE => SETTINGS ACK => HEADERS => DATA
+// The WINDOW_UPDATE frame is sent because the default local connection
+// window is now increased to 32MB (see https://github.com/nodejs/node/issues/38426)
+const MIN_FRAME_COUNT = 5;
 
 server.listen(0, () => {
   testRequest('/singleEnd', MIN_FRAME_COUNT, () => {