mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-05 05:07:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

rename window increment to window size in the flow controller

Browse source 
No functional change expected.
This commit is contained in:
Marten Seemann 2017-12-21 13:44:10 +07:00
parent 8c0d8bb568
commit ac05343b00
7 changed files with 115 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

20
internal/flowcontrol/base_flow_controller.go
View file

@ -20,8 +20,8 @@ type baseFlowController struct {
bytesRead protocol.ByteCount bytesRead protocol.ByteCount
highestReceived protocol.ByteCount highestReceived protocol.ByteCount
receiveWindow protocol.ByteCount receiveWindow protocol.ByteCount
receiveWindowIncrement protocol.ByteCount receiveWindowSize protocol.ByteCount
maxReceiveWindowIncrement protocol.ByteCount maxReceiveWindowSize protocol.ByteCount
lastWindowUpdateTime time.Time lastWindowUpdateTime time.Time
rttStats *congestion.RTTStats rttStats *congestion.RTTStats
} }
@ -51,7 +51,7 @@ func (c *baseFlowController) AddBytesRead(n protocol.ByteCount) {
defer c.mutex.Unlock() defer c.mutex.Unlock()
// pretend we sent a WindowUpdate when reading the first byte // 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 { if c.bytesRead == 0 {
c.lastWindowUpdateTime = time.Now() c.lastWindowUpdateTime = time.Now()
} }
@ -63,12 +63,12 @@ func (c *baseFlowController) AddBytesRead(n protocol.ByteCount) {
func (c *baseFlowController) getWindowUpdate() protocol.ByteCount { func (c *baseFlowController) getWindowUpdate() protocol.ByteCount {
bytesRemaining := c.receiveWindow - c.bytesRead bytesRemaining := c.receiveWindow - c.bytesRead
// update the window when more than the threshold was consumed // 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 return 0
} }
c.maybeAdjustWindowIncrement() c.maybeAdjustWindowSize()
c.receiveWindow = c.bytesRead + c.receiveWindowIncrement c.receiveWindow = c.bytesRead + c.receiveWindowSize
c.lastWindowUpdateTime = time.Now() c.lastWindowUpdateTime = time.Now()
return c.receiveWindow return c.receiveWindow
} }
@ -84,9 +84,9 @@ func (c *baseFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) {
return true, c.sendWindow 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. // 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() { if c.lastWindowUpdateTime.IsZero() {
return return
} }
@ -97,11 +97,11 @@ func (c *baseFlowController) maybeAdjustWindowIncrement() {
} }
timeSinceLastWindowUpdate := time.Since(c.lastWindowUpdateTime) 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 { if timeSinceLastWindowUpdate >= 4*protocol.WindowUpdateThreshold*rtt {
return return
} }
c.receiveWindowIncrement = utils.MinByteCount(2*c.receiveWindowIncrement, c.maxReceiveWindowIncrement) c.receiveWindowSize = utils.MinByteCount(2*c.receiveWindowSize, c.maxReceiveWindowSize)
} }
func (c *baseFlowController) checkFlowControlViolation() bool { func (c *baseFlowController) checkFlowControlViolation() bool {

82
internal/flowcontrol/base_flow_controller_test.go
View file

@ -77,12 +77,12 @@ var _ = Describe("Base Flow controller", func() {
Context("receive flow control", func() { Context("receive flow control", func() {
var ( var (
receiveWindow protocol.ByteCount = 10000 receiveWindow protocol.ByteCount = 10000
receiveWindowIncrement protocol.ByteCount = 600 receiveWindowSize protocol.ByteCount = 600
) )
BeforeEach(func() { BeforeEach(func() {
controller.receiveWindow = receiveWindow controller.receiveWindow = receiveWindow
controller.receiveWindowIncrement = receiveWindowIncrement controller.receiveWindowSize = receiveWindowSize
}) })
It("adds bytes read", func() { It("adds bytes read", func() {
@ -93,21 +93,21 @@ var _ = Describe("Base Flow controller", func() {
It("triggers a window update when necessary", func() { It("triggers a window update when necessary", func() {
controller.lastWindowUpdateTime = time.Now().Add(-time.Hour) controller.lastWindowUpdateTime = time.Now().Add(-time.Hour)
bytesConsumed := float64(receiveWindowIncrement)*protocol.WindowUpdateThreshold + 1 // consumed 1 byte more than the threshold bytesConsumed := float64(receiveWindowSize)*protocol.WindowUpdateThreshold + 1 // consumed 1 byte more than the threshold
bytesRemaining := receiveWindowIncrement - protocol.ByteCount(bytesConsumed) bytesRemaining := receiveWindowSize - protocol.ByteCount(bytesConsumed)
readPosition := receiveWindow - bytesRemaining readPosition := receiveWindow - bytesRemaining
controller.bytesRead = readPosition controller.bytesRead = readPosition
offset := controller.getWindowUpdate() offset := controller.getWindowUpdate()
Expect(offset).To(Equal(readPosition + receiveWindowIncrement)) Expect(offset).To(Equal(readPosition + receiveWindowSize))
Expect(controller.receiveWindow).To(Equal(readPosition + receiveWindowIncrement)) Expect(controller.receiveWindow).To(Equal(readPosition + receiveWindowSize))
Expect(controller.lastWindowUpdateTime).To(BeTemporally("~", time.Now(), 20*time.Millisecond)) Expect(controller.lastWindowUpdateTime).To(BeTemporally("~", time.Now(), 20*time.Millisecond))
}) })
It("doesn't trigger a window update when not necessary", func() { It("doesn't trigger a window update when not necessary", func() {
lastWindowUpdateTime := time.Now().Add(-time.Hour) lastWindowUpdateTime := time.Now().Add(-time.Hour)
controller.lastWindowUpdateTime = lastWindowUpdateTime controller.lastWindowUpdateTime = lastWindowUpdateTime
bytesConsumed := float64(receiveWindowIncrement)*protocol.WindowUpdateThreshold - 1 // consumed 1 byte less than the threshold bytesConsumed := float64(receiveWindowSize)*protocol.WindowUpdateThreshold - 1 // consumed 1 byte less than the threshold
bytesRemaining := receiveWindowIncrement - protocol.ByteCount(bytesConsumed) bytesRemaining := receiveWindowSize - protocol.ByteCount(bytesConsumed)
readPosition := receiveWindow - bytesRemaining readPosition := receiveWindow - bytesRemaining
controller.bytesRead = readPosition controller.bytesRead = readPosition
offset := controller.getWindowUpdate() offset := controller.getWindowUpdate()
@ -115,12 +115,12 @@ var _ = Describe("Base Flow controller", func() {
Expect(controller.lastWindowUpdateTime).To(Equal(lastWindowUpdateTime)) Expect(controller.lastWindowUpdateTime).To(Equal(lastWindowUpdateTime))
}) })
Context("receive window increment auto-tuning", func() { Context("receive window size auto-tuning", func() {
var oldIncrement protocol.ByteCount var oldWindowSize protocol.ByteCount
BeforeEach(func() { BeforeEach(func() {
oldIncrement = controller.receiveWindowIncrement oldWindowSize = controller.receiveWindowSize
controller.maxReceiveWindowIncrement = 3000 controller.maxReceiveWindowSize = 3000
}) })
// update the congestion such that it returns a given value for the smoothed RTT // 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 Expect(controller.rttStats.SmoothedRTT()).To(Equal(t)) // make sure it worked
} }
It("doesn't increase the increment for a new stream", func() { It("doesn't increase the window size for a new stream", func() {
controller.maybeAdjustWindowIncrement() controller.maybeAdjustWindowSize()
Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) 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) setRtt(0)
controller.lastWindowUpdateTime = time.Now() controller.lastWindowUpdateTime = time.Now()
controller.maybeAdjustWindowIncrement() controller.maybeAdjustWindowSize()
Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) 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 rtt := 20 * time.Millisecond
setRtt(rtt) setRtt(rtt)
controller.AddBytesRead(9900) // receive window is 10000 controller.AddBytesRead(9900) // receive window is 10000
controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond) controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond)
offset := controller.getWindowUpdate() offset := controller.getWindowUpdate()
Expect(offset).ToNot(BeZero()) Expect(offset).ToNot(BeZero())
// check that the increment was increased // check that the window size was increased
newIncrement := controller.receiveWindowIncrement newWindowSize := controller.receiveWindowSize
Expect(newIncrement).To(Equal(2 * oldIncrement)) Expect(newWindowSize).To(Equal(2 * oldWindowSize))
// check that the new increment was used to increase the offset // check that the new window size was used to increase the offset
Expect(offset).To(Equal(protocol.ByteCount(9900 + newIncrement))) 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 rtt := 20 * time.Millisecond
setRtt(rtt) setRtt(rtt)
controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt - time.Millisecond) controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt - time.Millisecond)
controller.maybeAdjustWindowIncrement() controller.maybeAdjustWindowSize()
Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) 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) setRtt(20 * time.Millisecond)
controller.lastWindowUpdateTime = time.Now().Add(-time.Millisecond) controller.lastWindowUpdateTime = time.Now().Add(-time.Millisecond)
controller.maybeAdjustWindowIncrement() controller.maybeAdjustWindowSize()
Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) // 1200 Expect(controller.receiveWindowSize).To(Equal(2 * oldWindowSize)) // 1200
// because the lastWindowUpdateTime is updated by MaybeTriggerWindowUpdate(), we can just call maybeAdjustWindowIncrement() multiple times and get an increase of the increment every time // 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.maybeAdjustWindowIncrement() controller.maybeAdjustWindowSize()
Expect(controller.receiveWindowIncrement).To(Equal(2 * 2 * oldIncrement)) // 2400 Expect(controller.receiveWindowSize).To(Equal(2 * 2 * oldWindowSize)) // 2400
controller.maybeAdjustWindowIncrement() controller.maybeAdjustWindowSize()
Expect(controller.receiveWindowIncrement).To(Equal(controller.maxReceiveWindowIncrement)) // 3000 Expect(controller.receiveWindowSize).To(Equal(controller.maxReceiveWindowSize)) // 3000
controller.maybeAdjustWindowIncrement() controller.maybeAdjustWindowSize()
Expect(controller.receiveWindowIncrement).To(Equal(controller.maxReceiveWindowIncrement)) // 3000 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) setRtt(20 * time.Millisecond)
controller.AddBytesRead(9900) controller.AddBytesRead(9900)
offset := controller.getWindowUpdate() offset := controller.getWindowUpdate()
Expect(offset).ToNot(BeZero()) 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) setRtt(5 * time.Millisecond)
controller.AddBytesRead(9900) controller.AddBytesRead(9900)
time.Sleep(15 * time.Millisecond) // more than 2x RTT time.Sleep(15 * time.Millisecond) // more than 2x RTT
offset := controller.getWindowUpdate() offset := controller.getWindowUpdate()
Expect(offset).ToNot(BeZero()) Expect(offset).ToNot(BeZero())
Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) Expect(controller.receiveWindowSize).To(Equal(oldWindowSize))
}) })
}) })
}) })

18
internal/flowcontrol/connection_flow_controller.go
View file

@ -27,8 +27,8 @@ func NewConnectionFlowController(
baseFlowController: baseFlowController{ baseFlowController: baseFlowController{
rttStats: rttStats, rttStats: rttStats,
receiveWindow: receiveWindow, receiveWindow: receiveWindow,
receiveWindowIncrement: receiveWindow, receiveWindowSize: receiveWindow,
maxReceiveWindowIncrement: maxReceiveWindow, maxReceiveWindowSize: maxReceiveWindow,
}, },
} }
} }
@ -51,21 +51,21 @@ func (c *connectionFlowController) IncrementHighestReceived(increment protocol.B
func (c *connectionFlowController) GetWindowUpdate() protocol.ByteCount { func (c *connectionFlowController) GetWindowUpdate() protocol.ByteCount {
c.mutex.Lock() c.mutex.Lock()
oldWindowIncrement := c.receiveWindowIncrement oldWindowSize := c.receiveWindowSize
offset := c.baseFlowController.getWindowUpdate() offset := c.baseFlowController.getWindowUpdate()
if oldWindowIncrement < c.receiveWindowIncrement { if oldWindowSize < c.receiveWindowSize {
utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowIncrement/(1<<10)) utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowSize/(1<<10))
} }
c.mutex.Unlock() c.mutex.Unlock()
return offset 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 // 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() c.mutex.Lock()
if inc > c.receiveWindowIncrement { if inc > c.receiveWindowSize {
c.receiveWindowIncrement = utils.MinByteCount(inc, c.maxReceiveWindowIncrement) c.receiveWindowSize = utils.MinByteCount(inc, c.maxReceiveWindowSize)
c.lastWindowUpdateTime = time.Time{} // disables autotuning for the next window update c.lastWindowUpdateTime = time.Time{} // disables autotuning for the next window update
} }
c.mutex.Unlock() c.mutex.Unlock()

46
internal/flowcontrol/connection_flow_controller_test.go
View file

@ -32,12 +32,12 @@ var _ = Describe("Connection Flow controller", func() {
fc := NewConnectionFlowController(receiveWindow, maxReceiveWindow, rttStats).(*connectionFlowController) fc := NewConnectionFlowController(receiveWindow, maxReceiveWindow, rttStats).(*connectionFlowController)
Expect(fc.receiveWindow).To(Equal(receiveWindow)) Expect(fc.receiveWindow).To(Equal(receiveWindow))
Expect(fc.maxReceiveWindowIncrement).To(Equal(maxReceiveWindow)) Expect(fc.maxReceiveWindowSize).To(Equal(maxReceiveWindow))
}) })
}) })
Context("receive flow control", func() { 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.highestReceived = 1337
controller.IncrementHighestReceived(123) controller.IncrementHighestReceived(123)
Expect(controller.highestReceived).To(Equal(protocol.ByteCount(1337 + 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() { Context("getting window updates", func() {
BeforeEach(func() { BeforeEach(func() {
controller.receiveWindow = 100 controller.receiveWindow = 100
controller.receiveWindowIncrement = 60 controller.receiveWindowSize = 60
controller.maxReceiveWindowIncrement = 1000 controller.maxReceiveWindowSize = 1000
}) })
It("gets a window update", func() { 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 ( var (
oldIncrement protocol.ByteCount oldWindowSize protocol.ByteCount
receiveWindow protocol.ByteCount = 10000 receiveWindow protocol.ByteCount = 10000
receiveWindowIncrement protocol.ByteCount = 600 receiveWindowSize protocol.ByteCount = 600
) )
BeforeEach(func() { BeforeEach(func() {
controller.receiveWindow = receiveWindow controller.receiveWindow = receiveWindow
controller.receiveWindowIncrement = receiveWindowIncrement controller.receiveWindowSize = receiveWindowSize
oldIncrement = controller.receiveWindowIncrement oldWindowSize = controller.receiveWindowSize
controller.maxReceiveWindowIncrement = 3000 controller.maxReceiveWindowSize = 3000
}) })
It("sets the minimum window increment", func() { It("sets the minimum window window size", func() {
controller.EnsureMinimumWindowIncrement(1000) controller.EnsureMinimumWindowSize(1000)
Expect(controller.receiveWindowIncrement).To(Equal(protocol.ByteCount(1000))) Expect(controller.receiveWindowSize).To(Equal(protocol.ByteCount(1000)))
}) })
It("doesn't reduce the window increment", func() { It("doesn't reduce the window window size", func() {
controller.EnsureMinimumWindowIncrement(1) controller.EnsureMinimumWindowSize(1)
Expect(controller.receiveWindowIncrement).To(Equal(oldIncrement)) Expect(controller.receiveWindowSize).To(Equal(oldWindowSize))
}) })
It("doens't increase the increment beyond the maxReceiveWindowIncrement", func() { It("doens't increase the window size beyond the maxReceiveWindowSize", func() {
max := controller.maxReceiveWindowIncrement max := controller.maxReceiveWindowSize
controller.EnsureMinimumWindowIncrement(2 * max) controller.EnsureMinimumWindowSize(2 * max)
Expect(controller.receiveWindowIncrement).To(Equal(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) setRtt(20 * time.Millisecond)
controller.bytesRead = 9900 // receive window is 10000 controller.bytesRead = 9900 // receive window is 10000
controller.lastWindowUpdateTime = time.Now().Add(-20 * time.Millisecond) controller.lastWindowUpdateTime = time.Now().Add(-20 * time.Millisecond)
controller.EnsureMinimumWindowIncrement(912) controller.EnsureMinimumWindowSize(912)
offset := controller.getWindowUpdate() 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))) Expect(offset).To(Equal(protocol.ByteCount(9900 + 912)))
}) })
}) })

2
internal/flowcontrol/interface.go
View file

@ -31,7 +31,7 @@ type connectionFlowControllerI interface {
ConnectionFlowController ConnectionFlowController
// The following two methods are not supposed to be called from outside this packet, but are needed internally // The following two methods are not supposed to be called from outside this packet, but are needed internally
// for sending // for sending
EnsureMinimumWindowIncrement(protocol.ByteCount) EnsureMinimumWindowSize(protocol.ByteCount)
// for receiving // for receiving
IncrementHighestReceived(protocol.ByteCount) error IncrementHighestReceived(protocol.ByteCount) error
} }

12
internal/flowcontrol/stream_flow_controller.go
View file

@ -39,8 +39,8 @@ func NewStreamFlowController(
baseFlowController: baseFlowController{ baseFlowController: baseFlowController{
rttStats: rttStats, rttStats: rttStats,
receiveWindow: receiveWindow, receiveWindow: receiveWindow,
receiveWindowIncrement: receiveWindow, receiveWindowSize: receiveWindow,
maxReceiveWindowIncrement: maxReceiveWindow, maxReceiveWindowSize: maxReceiveWindow,
sendWindow: initialSendWindow, sendWindow: initialSendWindow,
}, },
} }
@ -118,12 +118,12 @@ func (c *streamFlowController) GetWindowUpdate() protocol.ByteCount {
return 0 return 0
} }
oldWindowIncrement := c.receiveWindowIncrement oldWindowSize := c.receiveWindowSize
offset := c.baseFlowController.getWindowUpdate() offset := c.baseFlowController.getWindowUpdate()
if c.receiveWindowIncrement > oldWindowIncrement { // auto-tuning enlarged the window increment if c.receiveWindowSize > oldWindowSize { // auto-tuning enlarged the window size
utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowIncrement/(1<<10)) utils.Debugf("Increasing receive flow control window for the connection to %d kB", c.receiveWindowSize/(1<<10))
if c.contributesToConnection { 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() c.mutex.Unlock()

24
internal/flowcontrol/stream_flow_controller_test.go
View file

@ -19,7 +19,7 @@ var _ = Describe("Stream Flow controller", func() {
streamID: 10, streamID: 10,
connection: NewConnectionFlowController(1000, 1000, rttStats).(*connectionFlowController), connection: NewConnectionFlowController(1000, 1000, rttStats).(*connectionFlowController),
} }
controller.maxReceiveWindowIncrement = 10000 controller.maxReceiveWindowSize = 10000
controller.rttStats = rttStats controller.rttStats = rttStats
}) })
@ -35,7 +35,7 @@ var _ = Describe("Stream Flow controller", func() {
fc := NewStreamFlowController(5, true, cc, receiveWindow, maxReceiveWindow, sendWindow, rttStats).(*streamFlowController) fc := NewStreamFlowController(5, true, cc, receiveWindow, maxReceiveWindow, sendWindow, rttStats).(*streamFlowController)
Expect(fc.streamID).To(Equal(protocol.StreamID(5))) Expect(fc.streamID).To(Equal(protocol.StreamID(5)))
Expect(fc.receiveWindow).To(Equal(receiveWindow)) 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.sendWindow).To(Equal(sendWindow))
Expect(fc.contributesToConnection).To(BeTrue()) Expect(fc.contributesToConnection).To(BeTrue())
}) })
@ -44,11 +44,11 @@ var _ = Describe("Stream Flow controller", func() {
Context("receiving data", func() { Context("receiving data", func() {
Context("registering received offsets", func() { Context("registering received offsets", func() {
var receiveWindow protocol.ByteCount = 10000 var receiveWindow protocol.ByteCount = 10000
var receiveWindowIncrement protocol.ByteCount = 600 var receiveWindowSize protocol.ByteCount = 600
BeforeEach(func() { BeforeEach(func() {
controller.receiveWindow = receiveWindow controller.receiveWindow = receiveWindow
controller.receiveWindowIncrement = receiveWindowIncrement controller.receiveWindowSize = receiveWindowSize
}) })
It("updates the highestReceived", func() { It("updates the highestReceived", func() {
@ -157,7 +157,7 @@ var _ = Describe("Stream Flow controller", func() {
}) })
Context("generating window updates", 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 // update the congestion such that it returns a given value for the smoothed RTT
setRtt := func(t time.Duration) { setRtt := func(t time.Duration) {
@ -167,9 +167,9 @@ var _ = Describe("Stream Flow controller", func() {
BeforeEach(func() { BeforeEach(func() {
controller.receiveWindow = 100 controller.receiveWindow = 100
controller.receiveWindowIncrement = 60 controller.receiveWindowSize = 60
controller.connection.(*connectionFlowController).receiveWindowIncrement = 120 controller.connection.(*connectionFlowController).receiveWindowSize = 120
oldIncrement = controller.receiveWindowIncrement oldWindowSize = controller.receiveWindowSize
}) })
It("tells the connection flow controller when the window was autotuned", func() { 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) controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond)
offset := controller.GetWindowUpdate() offset := controller.GetWindowUpdate()
Expect(offset).To(Equal(protocol.ByteCount(75 + 2*60))) Expect(offset).To(Equal(protocol.ByteCount(75 + 2*60)))
Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) Expect(controller.receiveWindowSize).To(Equal(2 * oldWindowSize))
Expect(controller.connection.(*connectionFlowController).receiveWindowIncrement).To(Equal(protocol.ByteCount(float64(controller.receiveWindowIncrement) * protocol.ConnectionFlowControlMultiplier))) 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() { 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) controller.lastWindowUpdateTime = time.Now().Add(-4*protocol.WindowUpdateThreshold*rtt + time.Millisecond)
offset := controller.GetWindowUpdate() offset := controller.GetWindowUpdate()
Expect(offset).ToNot(BeZero()) Expect(offset).ToNot(BeZero())
Expect(controller.receiveWindowIncrement).To(Equal(2 * oldIncrement)) Expect(controller.receiveWindowSize).To(Equal(2 * oldWindowSize))
Expect(controller.connection.(*connectionFlowController).receiveWindowIncrement).To(Equal(protocol.ByteCount(120))) // unchanged 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() { It("doesn't increase the window after a final offset was already received", func() {