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

use a slightly higher bandwidth for the pacer

Browse source
This commit is contained in:
Marten Seemann 2020-06-18 21:09:15 +07:00
parent fe622dd780
commit fda00fe1cd
2 changed files with 20 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

21
internal/congestion/pacer.go
View file

@ -12,15 +12,20 @@ const maxBurstSize = 10 * maxDatagramSize
// The pacer implements a token bucket pacing algorithm.
type pacer struct {
budgetAtLastSent protocol.ByteCount
lastSentTime time.Time
getBandwidth func() uint64 // in bytes/s
budgetAtLastSent protocol.ByteCount
lastSentTime time.Time
getAdjustedBandwidth func() uint64 // in bytes/s
}
func newPacer(getBandwidth func() Bandwidth) *pacer {
p := &pacer{getBandwidth: func() uint64 {
p := &pacer{getAdjustedBandwidth: func() uint64 {
// Bandwidth is in bits/s. We need the value in bytes/s.
return uint64(getBandwidth() / BytesPerSecond)
bw := uint64(getBandwidth() / BytesPerSecond)
// Use a slightly higher value than the actual measured bandwidth.
// RTT variations then won't result in under-utilization of the congestion window.
// Ultimately, this will result in sending packets as acknowledgments are received rather than when timers fire,
// provided the congestion window is fully utilized and acknowledgments arrive at regular intervals.
return bw * 5 / 4
}}
p.budgetAtLastSent = p.maxBurstSize()
return p
@ -40,13 +45,13 @@ func (p *pacer) Budget(now time.Time) protocol.ByteCount {
if p.lastSentTime.IsZero() {
return p.maxBurstSize()
}
budget := p.budgetAtLastSent + (protocol.ByteCount(p.getBandwidth())*protocol.ByteCount(now.Sub(p.lastSentTime).Nanoseconds()))/1e9
budget := p.budgetAtLastSent + (protocol.ByteCount(p.getAdjustedBandwidth())*protocol.ByteCount(now.Sub(p.lastSentTime).Nanoseconds()))/1e9
return utils.MinByteCount(p.maxBurstSize(), budget)
}
func (p *pacer) maxBurstSize() protocol.ByteCount {
return utils.MaxByteCount(
protocol.ByteCount(uint64((protocol.MinPacingDelay+protocol.TimerGranularity).Nanoseconds())*p.getBandwidth())/1e9,
protocol.ByteCount(uint64((protocol.MinPacingDelay+protocol.TimerGranularity).Nanoseconds())*p.getAdjustedBandwidth())/1e9,
maxBurstSize,
)
}
@ -58,6 +63,6 @@ func (p *pacer) TimeUntilSend() time.Time {
}
return p.lastSentTime.Add(utils.MaxDuration(
protocol.MinPacingDelay,
time.Duration(math.Ceil(float64(maxDatagramSize-p.budgetAtLastSent)*1e9/float64(p.getBandwidth())))*time.Nanosecond,
time.Duration(math.Ceil(float64(maxDatagramSize-p.budgetAtLastSent)*1e9/float64(p.getAdjustedBandwidth())))*time.Nanosecond,
))
}

12
internal/congestion/pacer_test.go
View file

@ -12,12 +12,14 @@ import (
var _ = Describe("Pacer", func() {
var p *pacer
const packetsPerSecond = 42
const packetsPerSecond = 50
var bandwidth uint64 // in bytes/s
BeforeEach(func() {
bandwidth = uint64(packetsPerSecond * maxDatagramSize) // 42 full-size packets per second
p = newPacer(func() Bandwidth { return Bandwidth(bandwidth) * BytesPerSecond })
bandwidth = uint64(packetsPerSecond * maxDatagramSize) // 50 full-size packets per second
// The pacer will multiply the bandwidth with 1.25 to achieve a slightly higher pacing speed.
// For the tests, cancel out this factor, so we can do the math using the exact bandwidth.
p = newPacer(func() Bandwidth { return Bandwidth(bandwidth) * BytesPerSecond * 4 / 5 })
})
It("allows a burst at the beginning", func() {
@ -96,8 +98,8 @@ var _ = Describe("Pacer", func() {
It("changes the bandwidth", func() {
t := time.Now()
sendBurst(t)
bandwidth = uint64(maxDatagramSize) // reduce the bandwidth to 1 packet per second
Expect(p.TimeUntilSend()).To(Equal(t.Add(time.Second)))
bandwidth = uint64(5 * maxDatagramSize) // reduce the bandwidth to 5 packet per second
Expect(p.TimeUntilSend()).To(Equal(t.Add(time.Second / 5)))
})
It("doesn't pace faster than the minimum pacing duration", func() {