From eb3e253be22a6737a74bbd0576cdbf207e2377e1 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Fri, 8 Dec 2017 18:12:49 +0700 Subject: [PATCH] send MAX_{STREAM}_DATA frames more frequently WINDOW_UPDATEs are relatively small, and it doesn't cost much to grant the peer more flow control credit earlier. --- internal/flowcontrol/base_flow_controller.go | 13 ++--- .../flowcontrol/base_flow_controller_test.go | 51 ++++++++++--------- .../connection_flow_controller_test.go | 5 +- .../stream_flow_controller_test.go | 10 ++-- internal/protocol/server_parameters.go | 3 ++ 5 files changed, 46 insertions(+), 36 deletions(-) diff --git a/internal/flowcontrol/base_flow_controller.go b/internal/flowcontrol/base_flow_controller.go index e74c1d11..f7d70c7e 100644 --- a/internal/flowcontrol/base_flow_controller.go +++ b/internal/flowcontrol/base_flow_controller.go @@ -67,9 +67,9 @@ func (c *baseFlowController) AddBytesRead(n protocol.ByteCount) { // getWindowUpdate updates the receive window, if necessary // it returns the new offset func (c *baseFlowController) getWindowUpdate() protocol.ByteCount { - diff := c.receiveWindow - c.bytesRead - // update the window when more than half of it was already consumed - if diff >= (c.receiveWindowIncrement / 2) { + bytesRemaining := c.receiveWindow - c.bytesRead + // update the window when more than the threshold was consumed + if bytesRemaining >= protocol.ByteCount((float64(c.receiveWindowIncrement) * float64((1 - protocol.WindowUpdateThreshold)))) { return 0 } @@ -86,7 +86,8 @@ func (c *baseFlowController) IsBlocked() bool { return c.sendWindowSize() == 0 } -// maybeAdjustWindowIncrement increases the receiveWindowIncrement if we're sending WindowUpdates too often +// maybeAdjustWindowIncrement increases the receiveWindowIncrement if we're sending updates too often. +// For details about auto-tuning, see https://docs.google.com/document/d/1F2YfdDXKpy20WVKJueEf4abn_LVZHhMUMS5gX6Pgjl4/edit#heading=h.hcm2y5x4qmqt. func (c *baseFlowController) maybeAdjustWindowIncrement() { if c.lastWindowUpdateTime.IsZero() { return @@ -98,8 +99,8 @@ func (c *baseFlowController) maybeAdjustWindowIncrement() { } timeSinceLastWindowUpdate := time.Since(c.lastWindowUpdateTime) - // interval between the window updates is sufficiently large, no need to increase the increment - if timeSinceLastWindowUpdate >= 2*rtt { + // interval between the updates is sufficiently large, no need to increase the increment + if timeSinceLastWindowUpdate >= 4*protocol.WindowUpdateThreshold*rtt { return } c.receiveWindowIncrement = utils.MinByteCount(2*c.receiveWindowIncrement, c.maxReceiveWindowIncrement) diff --git a/internal/flowcontrol/base_flow_controller_test.go b/internal/flowcontrol/base_flow_controller_test.go index 0ac218bf..9239722c 100644 --- a/internal/flowcontrol/base_flow_controller_test.go +++ b/internal/flowcontrol/base_flow_controller_test.go @@ -59,8 +59,10 @@ var _ = Describe("Base Flow controller", func() { }) Context("receive flow control", func() { - var receiveWindow protocol.ByteCount = 10000 - var receiveWindowIncrement protocol.ByteCount = 600 + var ( + receiveWindow protocol.ByteCount = 10000 + receiveWindowIncrement protocol.ByteCount = 600 + ) BeforeEach(func() { controller.receiveWindow = receiveWindow @@ -75,7 +77,9 @@ var _ = Describe("Base Flow controller", func() { It("triggers a window update when necessary", func() { controller.lastWindowUpdateTime = time.Now().Add(-time.Hour) - readPosition := receiveWindow - receiveWindowIncrement/2 + 1 + bytesConsumed := float64(receiveWindowIncrement)*protocol.WindowUpdateThreshold + 1 // consumed 1 byte more than the threshold + bytesRemaining := receiveWindowIncrement - protocol.ByteCount(bytesConsumed) + readPosition := receiveWindow - bytesRemaining controller.bytesRead = readPosition offset := controller.getWindowUpdate() Expect(offset).To(Equal(readPosition + receiveWindowIncrement)) @@ -86,7 +90,9 @@ var _ = Describe("Base Flow controller", func() { It("doesn't trigger a window update when not necessary", func() { lastWindowUpdateTime := time.Now().Add(-time.Hour) controller.lastWindowUpdateTime = lastWindowUpdateTime - readPosition := receiveWindow - receiveWindow/2 - 1 + bytesConsumed := float64(receiveWindowIncrement)*protocol.WindowUpdateThreshold - 1 // consumed 1 byte less than the threshold + bytesRemaining := receiveWindowIncrement - protocol.ByteCount(bytesConsumed) + readPosition := receiveWindow - bytesRemaining controller.bytesRead = readPosition offset := controller.getWindowUpdate() Expect(offset).To(BeZero()) @@ -119,23 +125,31 @@ var _ = Describe("Base Flow controller", func() { Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) }) - It("increases the increment when the last WindowUpdate was sent less than two RTTs ago", func() { - setRtt(20 * time.Millisecond) - controller.lastWindowUpdateTime = time.Now().Add(-35 * time.Millisecond) - controller.maybeAdjustWindowIncrement() - Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) + It("increases the increment when the last WindowUpdate was sent less than (4 * threshold) RTTs ago", func() { + rtt := 20 * time.Millisecond + setRtt(rtt) + controller.AddBytesRead(9900) // receive window is 10000 + controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond) + offset := controller.getWindowUpdate() + Expect(offset).ToNot(BeZero()) + // check that the increment was increased + newIncrement := controller.receiveWindowIncrement + Expect(newIncrement).To(Equal(2 * oldIncrement)) + // check that the new increment was used to increase the offset + Expect(offset).To(Equal(protocol.ByteCount(9900 + newIncrement))) }) - It("doesn't increase the increase increment when the last WindowUpdate was sent more than two RTTs ago", func() { - setRtt(20 * time.Millisecond) - controller.lastWindowUpdateTime = time.Now().Add(-45 * time.Millisecond) + It("doesn't increase the increase increment when the last WindowUpdate was sent more than (4 * threshold) RTTs ago", func() { + rtt := 20 * time.Millisecond + setRtt(rtt) + controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt - time.Millisecond) controller.maybeAdjustWindowIncrement() Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) }) It("doesn't increase the increment to a value higher than the maxReceiveWindowIncrement", func() { setRtt(20 * time.Millisecond) - controller.lastWindowUpdateTime = time.Now().Add(-35 * time.Millisecond) + controller.lastWindowUpdateTime = time.Now().Add(-time.Millisecond) controller.maybeAdjustWindowIncrement() Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) // 1200 // because the lastWindowUpdateTime is updated by MaybeTriggerWindowUpdate(), we can just call maybeAdjustWindowIncrement() multiple times and get an increase of the increment every time @@ -147,17 +161,6 @@ var _ = Describe("Base Flow controller", func() { Expect(controller.receiveWindowIncrement).To(Equal(controller.maxReceiveWindowIncrement)) // 3000 }) - It("returns the new increment when updating the window", func() { - setRtt(20 * time.Millisecond) - controller.AddBytesRead(9900) // receive window is 10000 - controller.lastWindowUpdateTime = time.Now().Add(-35 * time.Millisecond) - offset := controller.getWindowUpdate() - Expect(offset).ToNot(BeZero()) - newIncrement := controller.receiveWindowIncrement - Expect(newIncrement).To(Equal(2 * oldIncrement)) - Expect(offset).To(Equal(protocol.ByteCount(9900 + newIncrement))) - }) - It("increases the increment sent in the first WindowUpdate, if data is read fast enough", func() { setRtt(20 * time.Millisecond) controller.AddBytesRead(9900) diff --git a/internal/flowcontrol/connection_flow_controller_test.go b/internal/flowcontrol/connection_flow_controller_test.go index dc400e1f..8c8ccb0b 100644 --- a/internal/flowcontrol/connection_flow_controller_test.go +++ b/internal/flowcontrol/connection_flow_controller_test.go @@ -58,8 +58,9 @@ var _ = Describe("Connection Flow controller", func() { It("autotunes the window", func() { controller.AddBytesRead(80) - setRtt(20 * time.Millisecond) - controller.lastWindowUpdateTime = time.Now().Add(-35 * time.Millisecond) + rtt := 20 * time.Millisecond + setRtt(rtt) + controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond) offset := controller.GetWindowUpdate() Expect(offset).To(Equal(protocol.ByteCount(80 + 2*60))) }) diff --git a/internal/flowcontrol/stream_flow_controller_test.go b/internal/flowcontrol/stream_flow_controller_test.go index 76c1e9df..ed51adcf 100644 --- a/internal/flowcontrol/stream_flow_controller_test.go +++ b/internal/flowcontrol/stream_flow_controller_test.go @@ -175,8 +175,9 @@ var _ = Describe("Stream Flow controller", func() { It("tells the connection flow controller when the window was autotuned", func() { controller.contributesToConnection = true controller.AddBytesRead(75) - setRtt(20 * time.Millisecond) - controller.lastWindowUpdateTime = time.Now().Add(-35 * time.Millisecond) + rtt := 20 * time.Millisecond + setRtt(rtt) + controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond) offset := controller.GetWindowUpdate() Expect(offset).To(Equal(protocol.ByteCount(75 + 2*60))) Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) @@ -186,8 +187,9 @@ var _ = Describe("Stream Flow controller", func() { It("doesn't tell the connection flow controller if it doesn't contribute", func() { controller.contributesToConnection = false controller.AddBytesRead(75) - setRtt(20 * time.Millisecond) - controller.lastWindowUpdateTime = time.Now().Add(-35 * time.Millisecond) + rtt := 20 * time.Millisecond + setRtt(rtt) + controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond) offset := controller.GetWindowUpdate() Expect(offset).ToNot(BeZero()) Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) diff --git a/internal/protocol/server_parameters.go b/internal/protocol/server_parameters.go index 28465660..e0d4f06a 100644 --- a/internal/protocol/server_parameters.go +++ b/internal/protocol/server_parameters.go @@ -56,6 +56,9 @@ const DefaultMaxReceiveConnectionFlowControlWindowClient = 15 * (1 << 20) // 15 // This is the value that Chromium is using const ConnectionFlowControlMultiplier = 1.5 +// WindowUpdateThreshold is the fraction of the receive window that has to be consumed before an higher offset is advertised to the client +const WindowUpdateThreshold = 0.25 + // MaxIncomingStreams is the maximum number of streams that a peer may open const MaxIncomingStreams = 100