From fda00fe1cd8e77972aaba25e6d63846548bbe62b Mon Sep 17 00:00:00 2001
From: Marten Seemann <martenseemann@gmail.com>
Date: Thu, 18 Jun 2020 21:09:15 +0700
Subject: [PATCH] use a slightly higher bandwidth for the pacer

---
 internal/congestion/pacer.go      | 21 +++++++++++++--------
 internal/congestion/pacer_test.go | 12 +++++++-----
 2 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/internal/congestion/pacer.go b/internal/congestion/pacer.go
index e83d7704..03767361 100644
--- a/internal/congestion/pacer.go
+++ b/internal/congestion/pacer.go
@@ -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,
 	))
 }
diff --git a/internal/congestion/pacer_test.go b/internal/congestion/pacer_test.go
index 8b96747a..531bb93b 100644
--- a/internal/congestion/pacer_test.go
+++ b/internal/congestion/pacer_test.go
@@ -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() {