mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-05 21:27:35 +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

32
internal/flowcontrol/base_flow_controller.go
View file

@ -16,14 +16,14 @@ type baseFlowController struct {
lastBlockedAt protocol.ByteCount lastBlockedAt protocol.ByteCount
// for receiving data // for receiving data
mutex sync.RWMutex mutex sync.RWMutex
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
} }
func (c *baseFlowController) AddBytesSent(n protocol.ByteCount) { func (c *baseFlowController) AddBytesSent(n protocol.ByteCount) {
@ -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 {

84
internal/flowcontrol/base_flow_controller_test.go
View file

@ -76,13 +76,13 @@ 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))
}) })
}) })
}) })

22
internal/flowcontrol/connection_flow_controller.go
View file

@ -25,10 +25,10 @@ func NewConnectionFlowController(
) ConnectionFlowController { ) ConnectionFlowController {
return &connectionFlowController{ return &connectionFlowController{
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()

48
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
} }

18
internal/flowcontrol/stream_flow_controller.go
View file

@ -37,11 +37,11 @@ func NewStreamFlowController(
contributesToConnection: contributesToConnection, contributesToConnection: contributesToConnection,
connection: cfc.(connectionFlowControllerI), connection: cfc.(connectionFlowControllerI),
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() {