diff --git a/internal/flowcontrol/base_flow_controller.go b/internal/flowcontrol/base_flow_controller.go index b4da7d6d..fac9e194 100644 --- a/internal/flowcontrol/base_flow_controller.go +++ b/internal/flowcontrol/base_flow_controller.go @@ -16,14 +16,14 @@ type baseFlowController struct { lastBlockedAt protocol.ByteCount // for receiving data - mutex sync.RWMutex - bytesRead protocol.ByteCount - highestReceived protocol.ByteCount - receiveWindow protocol.ByteCount - receiveWindowIncrement protocol.ByteCount - maxReceiveWindowIncrement protocol.ByteCount - lastWindowUpdateTime time.Time - rttStats *congestion.RTTStats + mutex sync.RWMutex + bytesRead protocol.ByteCount + highestReceived protocol.ByteCount + receiveWindow protocol.ByteCount + receiveWindowSize protocol.ByteCount + maxReceiveWindowSize protocol.ByteCount + lastWindowUpdateTime time.Time + rttStats *congestion.RTTStats } func (c *baseFlowController) AddBytesSent(n protocol.ByteCount) { @@ -51,7 +51,7 @@ func (c *baseFlowController) AddBytesRead(n protocol.ByteCount) { defer c.mutex.Unlock() // pretend we sent a WindowUpdate when reading the first byte - // this way auto-tuning of the window increment already works for the first WindowUpdate + // this way auto-tuning of the window size already works for the first WindowUpdate if c.bytesRead == 0 { c.lastWindowUpdateTime = time.Now() } @@ -63,12 +63,12 @@ func (c *baseFlowController) AddBytesRead(n protocol.ByteCount) { func (c *baseFlowController) getWindowUpdate() protocol.ByteCount { 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)))) { + if bytesRemaining >= protocol.ByteCount((float64(c.receiveWindowSize) * float64((1 - protocol.WindowUpdateThreshold)))) { return 0 } - c.maybeAdjustWindowIncrement() - c.receiveWindow = c.bytesRead + c.receiveWindowIncrement + c.maybeAdjustWindowSize() + c.receiveWindow = c.bytesRead + c.receiveWindowSize c.lastWindowUpdateTime = time.Now() return c.receiveWindow } @@ -84,9 +84,9 @@ func (c *baseFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) { return true, c.sendWindow } -// maybeAdjustWindowIncrement increases the receiveWindowIncrement if we're sending updates too often. +// maybeAdjustWindowSize increases the receiveWindowSize 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() { +func (c *baseFlowController) maybeAdjustWindowSize() { if c.lastWindowUpdateTime.IsZero() { return } @@ -97,11 +97,11 @@ func (c *baseFlowController) maybeAdjustWindowIncrement() { } timeSinceLastWindowUpdate := time.Since(c.lastWindowUpdateTime) - // interval between the updates is sufficiently large, no need to increase the increment + // interval between the updates is sufficiently large, no need to increase the window size if timeSinceLastWindowUpdate >= 4*protocol.WindowUpdateThreshold*rtt { return } - c.receiveWindowIncrement = utils.MinByteCount(2*c.receiveWindowIncrement, c.maxReceiveWindowIncrement) + c.receiveWindowSize = utils.MinByteCount(2*c.receiveWindowSize, c.maxReceiveWindowSize) } func (c *baseFlowController) checkFlowControlViolation() bool { diff --git a/internal/flowcontrol/base_flow_controller_test.go b/internal/flowcontrol/base_flow_controller_test.go index 7869f2a6..31b64fc9 100644 --- a/internal/flowcontrol/base_flow_controller_test.go +++ b/internal/flowcontrol/base_flow_controller_test.go @@ -76,13 +76,13 @@ var _ = Describe("Base Flow controller", func() { Context("receive flow control", func() { var ( - receiveWindow protocol.ByteCount = 10000 - receiveWindowIncrement protocol.ByteCount = 600 + receiveWindow protocol.ByteCount = 10000 + receiveWindowSize protocol.ByteCount = 600 ) BeforeEach(func() { controller.receiveWindow = receiveWindow - controller.receiveWindowIncrement = receiveWindowIncrement + controller.receiveWindowSize = receiveWindowSize }) It("adds bytes read", func() { @@ -93,21 +93,21 @@ var _ = Describe("Base Flow controller", func() { It("triggers a window update when necessary", func() { controller.lastWindowUpdateTime = time.Now().Add(-time.Hour) - bytesConsumed := float64(receiveWindowIncrement)*protocol.WindowUpdateThreshold + 1 // consumed 1 byte more than the threshold - bytesRemaining := receiveWindowIncrement - protocol.ByteCount(bytesConsumed) + bytesConsumed := float64(receiveWindowSize)*protocol.WindowUpdateThreshold + 1 // consumed 1 byte more than the threshold + bytesRemaining := receiveWindowSize - protocol.ByteCount(bytesConsumed) readPosition := receiveWindow - bytesRemaining controller.bytesRead = readPosition offset := controller.getWindowUpdate() - Expect(offset).To(Equal(readPosition + receiveWindowIncrement)) - Expect(controller.receiveWindow).To(Equal(readPosition + receiveWindowIncrement)) + Expect(offset).To(Equal(readPosition + receiveWindowSize)) + Expect(controller.receiveWindow).To(Equal(readPosition + receiveWindowSize)) Expect(controller.lastWindowUpdateTime).To(BeTemporally("~", time.Now(), 20*time.Millisecond)) }) It("doesn't trigger a window update when not necessary", func() { lastWindowUpdateTime := time.Now().Add(-time.Hour) controller.lastWindowUpdateTime = lastWindowUpdateTime - bytesConsumed := float64(receiveWindowIncrement)*protocol.WindowUpdateThreshold - 1 // consumed 1 byte less than the threshold - bytesRemaining := receiveWindowIncrement - protocol.ByteCount(bytesConsumed) + bytesConsumed := float64(receiveWindowSize)*protocol.WindowUpdateThreshold - 1 // consumed 1 byte less than the threshold + bytesRemaining := receiveWindowSize - protocol.ByteCount(bytesConsumed) readPosition := receiveWindow - bytesRemaining controller.bytesRead = readPosition offset := controller.getWindowUpdate() @@ -115,12 +115,12 @@ var _ = Describe("Base Flow controller", func() { Expect(controller.lastWindowUpdateTime).To(Equal(lastWindowUpdateTime)) }) - Context("receive window increment auto-tuning", func() { - var oldIncrement protocol.ByteCount + Context("receive window size auto-tuning", func() { + var oldWindowSize protocol.ByteCount BeforeEach(func() { - oldIncrement = controller.receiveWindowIncrement - controller.maxReceiveWindowIncrement = 3000 + oldWindowSize = controller.receiveWindowSize + controller.maxReceiveWindowSize = 3000 }) // update the congestion such that it returns a given value for the smoothed RTT @@ -129,69 +129,69 @@ var _ = Describe("Base Flow controller", func() { Expect(controller.rttStats.SmoothedRTT()).To(Equal(t)) // make sure it worked } - It("doesn't increase the increment for a new stream", func() { - controller.maybeAdjustWindowIncrement() - Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) + It("doesn't increase the window size for a new stream", func() { + controller.maybeAdjustWindowSize() + Expect(controller.receiveWindowSize).To(Equal(oldWindowSize)) }) - It("doesn't increase the increment when no RTT estimate is available", func() { + It("doesn't increase the window size when no RTT estimate is available", func() { setRtt(0) controller.lastWindowUpdateTime = time.Now() - controller.maybeAdjustWindowIncrement() - Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) + controller.maybeAdjustWindowSize() + Expect(controller.receiveWindowSize).To(Equal(oldWindowSize)) }) - It("increases the increment when the last WindowUpdate was sent less than (4 * threshold) RTTs ago", func() { + It("increases the window size 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))) + // check that the window size was increased + newWindowSize := controller.receiveWindowSize + Expect(newWindowSize).To(Equal(2 * oldWindowSize)) + // check that the new window size was used to increase the offset + Expect(offset).To(Equal(protocol.ByteCount(9900 + newWindowSize))) }) - It("doesn't increase the increase increment when the last WindowUpdate was sent more than (4 * threshold) RTTs ago", func() { + It("doesn't increase the increase window size 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)) + controller.maybeAdjustWindowSize() + Expect(controller.receiveWindowSize).To(Equal(oldWindowSize)) }) - It("doesn't increase the increment to a value higher than the maxReceiveWindowIncrement", func() { + It("doesn't increase the window size to a value higher than the maxReceiveWindowSize", func() { setRtt(20 * 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 - controller.maybeAdjustWindowIncrement() - Expect(controller.receiveWindowIncrement).To(Equal(2 * 2 * oldIncrement)) // 2400 - controller.maybeAdjustWindowIncrement() - Expect(controller.receiveWindowIncrement).To(Equal(controller.maxReceiveWindowIncrement)) // 3000 - controller.maybeAdjustWindowIncrement() - Expect(controller.receiveWindowIncrement).To(Equal(controller.maxReceiveWindowIncrement)) // 3000 + controller.maybeAdjustWindowSize() + Expect(controller.receiveWindowSize).To(Equal(2 * oldWindowSize)) // 1200 + // because the lastWindowUpdateTime is updated by MaybeTriggerWindowUpdate(), we can just call maybeAdjustWindowSize() multiple times and get an increase of the window size every time + controller.maybeAdjustWindowSize() + Expect(controller.receiveWindowSize).To(Equal(2 * 2 * oldWindowSize)) // 2400 + controller.maybeAdjustWindowSize() + Expect(controller.receiveWindowSize).To(Equal(controller.maxReceiveWindowSize)) // 3000 + controller.maybeAdjustWindowSize() + Expect(controller.receiveWindowSize).To(Equal(controller.maxReceiveWindowSize)) // 3000 }) - It("increases the increment sent in the first WindowUpdate, if data is read fast enough", func() { + It("increases the window size sent in the first WindowUpdate, if data is read fast enough", func() { setRtt(20 * time.Millisecond) controller.AddBytesRead(9900) offset := controller.getWindowUpdate() Expect(offset).ToNot(BeZero()) - Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) + Expect(controller.receiveWindowSize).To(Equal(2 * oldWindowSize)) }) - It("doesn't increamse the increment sent in the first WindowUpdate, if data is read slowly", func() { + It("doesn't increase the window size sent in the first WindowUpdate, if data is read slowly", func() { setRtt(5 * time.Millisecond) controller.AddBytesRead(9900) time.Sleep(15 * time.Millisecond) // more than 2x RTT offset := controller.getWindowUpdate() Expect(offset).ToNot(BeZero()) - Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) + Expect(controller.receiveWindowSize).To(Equal(oldWindowSize)) }) }) }) diff --git a/internal/flowcontrol/connection_flow_controller.go b/internal/flowcontrol/connection_flow_controller.go index 449bf925..a4e1ea03 100644 --- a/internal/flowcontrol/connection_flow_controller.go +++ b/internal/flowcontrol/connection_flow_controller.go @@ -25,10 +25,10 @@ func NewConnectionFlowController( ) ConnectionFlowController { return &connectionFlowController{ baseFlowController: baseFlowController{ - rttStats: rttStats, - receiveWindow: receiveWindow, - receiveWindowIncrement: receiveWindow, - maxReceiveWindowIncrement: maxReceiveWindow, + rttStats: rttStats, + receiveWindow: receiveWindow, + receiveWindowSize: receiveWindow, + maxReceiveWindowSize: maxReceiveWindow, }, } } @@ -51,21 +51,21 @@ func (c *connectionFlowController) IncrementHighestReceived(increment protocol.B func (c *connectionFlowController) GetWindowUpdate() protocol.ByteCount { c.mutex.Lock() - oldWindowIncrement := c.receiveWindowIncrement + oldWindowSize := c.receiveWindowSize offset := c.baseFlowController.getWindowUpdate() - if oldWindowIncrement < c.receiveWindowIncrement { - utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowIncrement/(1<<10)) + if oldWindowSize < c.receiveWindowSize { + utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowSize/(1<<10)) } c.mutex.Unlock() return offset } -// EnsureMinimumWindowIncrement sets a minimum window increment +// EnsureMinimumWindowSize sets a minimum window size // it should make sure that the connection-level window is increased when a stream-level window grows -func (c *connectionFlowController) EnsureMinimumWindowIncrement(inc protocol.ByteCount) { +func (c *connectionFlowController) EnsureMinimumWindowSize(inc protocol.ByteCount) { c.mutex.Lock() - if inc > c.receiveWindowIncrement { - c.receiveWindowIncrement = utils.MinByteCount(inc, c.maxReceiveWindowIncrement) + if inc > c.receiveWindowSize { + c.receiveWindowSize = utils.MinByteCount(inc, c.maxReceiveWindowSize) c.lastWindowUpdateTime = time.Time{} // disables autotuning for the next window update } c.mutex.Unlock() diff --git a/internal/flowcontrol/connection_flow_controller_test.go b/internal/flowcontrol/connection_flow_controller_test.go index 8c8ccb0b..a130cfdc 100644 --- a/internal/flowcontrol/connection_flow_controller_test.go +++ b/internal/flowcontrol/connection_flow_controller_test.go @@ -32,12 +32,12 @@ var _ = Describe("Connection Flow controller", func() { fc := NewConnectionFlowController(receiveWindow, maxReceiveWindow, rttStats).(*connectionFlowController) Expect(fc.receiveWindow).To(Equal(receiveWindow)) - Expect(fc.maxReceiveWindowIncrement).To(Equal(maxReceiveWindow)) + Expect(fc.maxReceiveWindowSize).To(Equal(maxReceiveWindow)) }) }) Context("receive flow control", func() { - It("increases the highestReceived by a given increment", func() { + It("increases the highestReceived by a given window size", func() { controller.highestReceived = 1337 controller.IncrementHighestReceived(123) Expect(controller.highestReceived).To(Equal(protocol.ByteCount(1337 + 123))) @@ -46,8 +46,8 @@ var _ = Describe("Connection Flow controller", func() { Context("getting window updates", func() { BeforeEach(func() { controller.receiveWindow = 100 - controller.receiveWindowIncrement = 60 - controller.maxReceiveWindowIncrement = 1000 + controller.receiveWindowSize = 60 + controller.maxReceiveWindowSize = 1000 }) It("gets a window update", func() { @@ -67,43 +67,43 @@ var _ = Describe("Connection Flow controller", func() { }) }) - Context("setting the minimum increment", func() { + Context("setting the minimum window size", func() { var ( - oldIncrement protocol.ByteCount - receiveWindow protocol.ByteCount = 10000 - receiveWindowIncrement protocol.ByteCount = 600 + oldWindowSize protocol.ByteCount + receiveWindow protocol.ByteCount = 10000 + receiveWindowSize protocol.ByteCount = 600 ) BeforeEach(func() { controller.receiveWindow = receiveWindow - controller.receiveWindowIncrement = receiveWindowIncrement - oldIncrement = controller.receiveWindowIncrement - controller.maxReceiveWindowIncrement = 3000 + controller.receiveWindowSize = receiveWindowSize + oldWindowSize = controller.receiveWindowSize + controller.maxReceiveWindowSize = 3000 }) - It("sets the minimum window increment", func() { - controller.EnsureMinimumWindowIncrement(1000) - Expect(controller.receiveWindowIncrement).To(Equal(protocol.ByteCount(1000))) + It("sets the minimum window window size", func() { + controller.EnsureMinimumWindowSize(1000) + Expect(controller.receiveWindowSize).To(Equal(protocol.ByteCount(1000))) }) - It("doesn't reduce the window increment", func() { - controller.EnsureMinimumWindowIncrement(1) - Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) + It("doesn't reduce the window window size", func() { + controller.EnsureMinimumWindowSize(1) + Expect(controller.receiveWindowSize).To(Equal(oldWindowSize)) }) - It("doens't increase the increment beyond the maxReceiveWindowIncrement", func() { - max := controller.maxReceiveWindowIncrement - controller.EnsureMinimumWindowIncrement(2 * max) - Expect(controller.receiveWindowIncrement).To(Equal(max)) + It("doens't increase the window size beyond the maxReceiveWindowSize", func() { + max := controller.maxReceiveWindowSize + controller.EnsureMinimumWindowSize(2 * max) + Expect(controller.receiveWindowSize).To(Equal(max)) }) - It("doesn't auto-tune the window after the increment was increased", func() { + It("doesn't auto-tune the window after the window size was increased", func() { setRtt(20 * time.Millisecond) controller.bytesRead = 9900 // receive window is 10000 controller.lastWindowUpdateTime = time.Now().Add(-20 * time.Millisecond) - controller.EnsureMinimumWindowIncrement(912) + controller.EnsureMinimumWindowSize(912) offset := controller.getWindowUpdate() - Expect(controller.receiveWindowIncrement).To(Equal(protocol.ByteCount(912))) // no auto-tuning + Expect(controller.receiveWindowSize).To(Equal(protocol.ByteCount(912))) // no auto-tuning Expect(offset).To(Equal(protocol.ByteCount(9900 + 912))) }) }) diff --git a/internal/flowcontrol/interface.go b/internal/flowcontrol/interface.go index a753b4e4..5b859c68 100644 --- a/internal/flowcontrol/interface.go +++ b/internal/flowcontrol/interface.go @@ -31,7 +31,7 @@ type connectionFlowControllerI interface { ConnectionFlowController // The following two methods are not supposed to be called from outside this packet, but are needed internally // for sending - EnsureMinimumWindowIncrement(protocol.ByteCount) + EnsureMinimumWindowSize(protocol.ByteCount) // for receiving IncrementHighestReceived(protocol.ByteCount) error } diff --git a/internal/flowcontrol/stream_flow_controller.go b/internal/flowcontrol/stream_flow_controller.go index 37cdc1f8..36c7539f 100644 --- a/internal/flowcontrol/stream_flow_controller.go +++ b/internal/flowcontrol/stream_flow_controller.go @@ -37,11 +37,11 @@ func NewStreamFlowController( contributesToConnection: contributesToConnection, connection: cfc.(connectionFlowControllerI), baseFlowController: baseFlowController{ - rttStats: rttStats, - receiveWindow: receiveWindow, - receiveWindowIncrement: receiveWindow, - maxReceiveWindowIncrement: maxReceiveWindow, - sendWindow: initialSendWindow, + rttStats: rttStats, + receiveWindow: receiveWindow, + receiveWindowSize: receiveWindow, + maxReceiveWindowSize: maxReceiveWindow, + sendWindow: initialSendWindow, }, } } @@ -118,12 +118,12 @@ func (c *streamFlowController) GetWindowUpdate() protocol.ByteCount { return 0 } - oldWindowIncrement := c.receiveWindowIncrement + oldWindowSize := c.receiveWindowSize offset := c.baseFlowController.getWindowUpdate() - if c.receiveWindowIncrement > oldWindowIncrement { // auto-tuning enlarged the window increment - utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowIncrement/(1<<10)) + if c.receiveWindowSize > oldWindowSize { // auto-tuning enlarged the window size + utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowSize/(1<<10)) if c.contributesToConnection { - c.connection.EnsureMinimumWindowIncrement(protocol.ByteCount(float64(c.receiveWindowIncrement) * protocol.ConnectionFlowControlMultiplier)) + c.connection.EnsureMinimumWindowSize(protocol.ByteCount(float64(c.receiveWindowSize) * protocol.ConnectionFlowControlMultiplier)) } } c.mutex.Unlock() diff --git a/internal/flowcontrol/stream_flow_controller_test.go b/internal/flowcontrol/stream_flow_controller_test.go index 35e07b18..6f67b5e5 100644 --- a/internal/flowcontrol/stream_flow_controller_test.go +++ b/internal/flowcontrol/stream_flow_controller_test.go @@ -19,7 +19,7 @@ var _ = Describe("Stream Flow controller", func() { streamID: 10, connection: NewConnectionFlowController(1000, 1000, rttStats).(*connectionFlowController), } - controller.maxReceiveWindowIncrement = 10000 + controller.maxReceiveWindowSize = 10000 controller.rttStats = rttStats }) @@ -35,7 +35,7 @@ var _ = Describe("Stream Flow controller", func() { fc := NewStreamFlowController(5, true, cc, receiveWindow, maxReceiveWindow, sendWindow, rttStats).(*streamFlowController) Expect(fc.streamID).To(Equal(protocol.StreamID(5))) Expect(fc.receiveWindow).To(Equal(receiveWindow)) - Expect(fc.maxReceiveWindowIncrement).To(Equal(maxReceiveWindow)) + Expect(fc.maxReceiveWindowSize).To(Equal(maxReceiveWindow)) Expect(fc.sendWindow).To(Equal(sendWindow)) Expect(fc.contributesToConnection).To(BeTrue()) }) @@ -44,11 +44,11 @@ var _ = Describe("Stream Flow controller", func() { Context("receiving data", func() { Context("registering received offsets", func() { var receiveWindow protocol.ByteCount = 10000 - var receiveWindowIncrement protocol.ByteCount = 600 + var receiveWindowSize protocol.ByteCount = 600 BeforeEach(func() { controller.receiveWindow = receiveWindow - controller.receiveWindowIncrement = receiveWindowIncrement + controller.receiveWindowSize = receiveWindowSize }) It("updates the highestReceived", func() { @@ -157,7 +157,7 @@ var _ = Describe("Stream Flow controller", func() { }) Context("generating window updates", func() { - var oldIncrement protocol.ByteCount + var oldWindowSize protocol.ByteCount // update the congestion such that it returns a given value for the smoothed RTT setRtt := func(t time.Duration) { @@ -167,9 +167,9 @@ var _ = Describe("Stream Flow controller", func() { BeforeEach(func() { controller.receiveWindow = 100 - controller.receiveWindowIncrement = 60 - controller.connection.(*connectionFlowController).receiveWindowIncrement = 120 - oldIncrement = controller.receiveWindowIncrement + controller.receiveWindowSize = 60 + controller.connection.(*connectionFlowController).receiveWindowSize = 120 + oldWindowSize = controller.receiveWindowSize }) It("tells the connection flow controller when the window was autotuned", func() { @@ -180,8 +180,8 @@ var _ = Describe("Stream Flow controller", func() { 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)) - Expect(controller.connection.(*connectionFlowController).receiveWindowIncrement).To(Equal(protocol.ByteCount(float64(controller.receiveWindowIncrement) * protocol.ConnectionFlowControlMultiplier))) + Expect(controller.receiveWindowSize).To(Equal(2 * oldWindowSize)) + Expect(controller.connection.(*connectionFlowController).receiveWindowSize).To(Equal(protocol.ByteCount(float64(controller.receiveWindowSize) * protocol.ConnectionFlowControlMultiplier))) }) It("doesn't tell the connection flow controller if it doesn't contribute", func() { @@ -192,8 +192,8 @@ var _ = Describe("Stream Flow controller", func() { 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)) - Expect(controller.connection.(*connectionFlowController).receiveWindowIncrement).To(Equal(protocol.ByteCount(120))) // unchanged + Expect(controller.receiveWindowSize).To(Equal(2 * oldWindowSize)) + Expect(controller.connection.(*connectionFlowController).receiveWindowSize).To(Equal(protocol.ByteCount(120))) // unchanged }) It("doesn't increase the window after a final offset was already received", func() {