gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

utils: remove unused methods and constructor from RTTStats (#4672)

Browse Source
This commit is contained in:
Marten Seemann
2024-09-12 15:55:57 +08:00
committed by GitHub
parent 5247a8ee42
commit 7a10ed602d
9 changed files with 60 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
internal/utils/rtt_stats.go
View File

@@ -27,11 +27,6 @@ type RTTStats struct {
maxAckDelay time.Duration
}
// NewRTTStats makes a properly initialized RTTStats object
func NewRTTStats() *RTTStats {
return &RTTStats{}
}
// MinRTT Returns the minRTT for the entire connection.
// May return Zero if no valid updates have occurred.
func (r *RTTStats) MinRTT() time.Duration { return r.minRTT }
@@ -113,19 +108,3 @@ func (r *RTTStats) SetInitialRTT(t time.Duration) {
r.smoothedRTT = t
r.latestRTT = t
}
// OnConnectionMigration is called when connection migrates and rtt measurement needs to be reset.
func (r *RTTStats) OnConnectionMigration() {
r.latestRTT = 0
r.minRTT = 0
r.smoothedRTT = 0
r.meanDeviation = 0
}
// ExpireSmoothedMetrics causes the smoothed_rtt to be increased to the latest_rtt if the latest_rtt
// is larger. The mean deviation is increased to the most recent deviation if
// it's larger.
func (r *RTTStats) ExpireSmoothedMetrics() {
r.meanDeviation = max(r.meanDeviation, (r.smoothedRTT - r.latestRTT).Abs())
r.smoothedRTT = max(r.smoothedRTT, r.latestRTT)
}

68
internal/utils/rtt_stats_test.go
View File

@@ -10,18 +10,14 @@ import (
)
var _ = Describe("RTT stats", func() {
var rttStats *RTTStats
BeforeEach(func() {
rttStats = NewRTTStats()
})
It("DefaultsBeforeUpdate", func() {
var rttStats RTTStats
Expect(rttStats.MinRTT()).To(Equal(time.Duration(0)))
Expect(rttStats.SmoothedRTT()).To(Equal(time.Duration(0)))
})
It("SmoothedRTT", func() {
var rttStats RTTStats
// Verify that ack_delay is ignored in the first measurement.
rttStats.UpdateRTT((300 * time.Millisecond), (100 * time.Millisecond), time.Time{})
Expect(rttStats.LatestRTT()).To(Equal((300 * time.Millisecond)))
@@ -37,6 +33,7 @@ var _ = Describe("RTT stats", func() {
})
It("MinRTT", func() {
var rttStats RTTStats
rttStats.UpdateRTT((200 * time.Millisecond), 0, time.Time{})
Expect(rttStats.MinRTT()).To(Equal((200 * time.Millisecond)))
rttStats.UpdateRTT((10 * time.Millisecond), 0, time.Time{}.Add((10 * time.Millisecond)))
@@ -53,14 +50,18 @@ var _ = Describe("RTT stats", func() {
})
It("MaxAckDelay", func() {
var rttStats RTTStats
rttStats.SetMaxAckDelay(42 * time.Minute)
Expect(rttStats.MaxAckDelay()).To(Equal(42 * time.Minute))
})
It("computes the PTO", func() {
maxAckDelay := 42 * time.Minute
var rttStats RTTStats
const (
maxAckDelay = 42 * time.Minute
rtt = time.Second
)
rttStats.SetMaxAckDelay(maxAckDelay)
rtt := time.Second
rttStats.UpdateRTT(rtt, 0, time.Time{})
Expect(rttStats.SmoothedRTT()).To(Equal(rtt))
Expect(rttStats.MeanDeviation()).To(Equal(rtt / 2))
@@ -69,39 +70,15 @@ var _ = Describe("RTT stats", func() {
})
It("uses the granularity for computing the PTO for short RTTs", func() {
rtt := time.Microsecond
var rttStats RTTStats
const rtt = time.Microsecond
rttStats.UpdateRTT(rtt, 0, time.Time{})
Expect(rttStats.PTO(true)).To(Equal(rtt + protocol.TimerGranularity))
})
It("ExpireSmoothedMetrics", func() {
initialRtt := (10 * time.Millisecond)
rttStats.UpdateRTT(initialRtt, 0, time.Time{})
Expect(rttStats.MinRTT()).To(Equal(initialRtt))
Expect(rttStats.SmoothedRTT()).To(Equal(initialRtt))
Expect(rttStats.MeanDeviation()).To(Equal(initialRtt / 2))
// Update once with a 20ms RTT.
doubledRtt := initialRtt * (2)
rttStats.UpdateRTT(doubledRtt, 0, time.Time{})
Expect(rttStats.SmoothedRTT()).To(Equal(time.Duration(float32(initialRtt) * 1.125)))
// Expire the smoothed metrics, increasing smoothed rtt and mean deviation.
rttStats.ExpireSmoothedMetrics()
Expect(rttStats.SmoothedRTT()).To(Equal(doubledRtt))
Expect(rttStats.MeanDeviation()).To(Equal(time.Duration(float32(initialRtt) * 0.875)))
// Now go back down to 5ms and expire the smoothed metrics, and ensure the
// mean deviation increases to 15ms.
halfRtt := initialRtt / 2
rttStats.UpdateRTT(halfRtt, 0, time.Time{})
Expect(doubledRtt).To(BeNumerically(">", rttStats.SmoothedRTT()))
Expect(initialRtt).To(BeNumerically("<", rttStats.MeanDeviation()))
})
It("UpdateRTTWithBadSendDeltas", func() {
initialRtt := 10 * time.Millisecond
var rttStats RTTStats
const initialRtt = 10 * time.Millisecond
rttStats.UpdateRTT(initialRtt, 0, time.Time{})
Expect(rttStats.MinRTT()).To(Equal(initialRtt))
Expect(rttStats.SmoothedRTT()).To(Equal(initialRtt))
@@ -118,24 +95,8 @@ var _ = Describe("RTT stats", func() {
}
})
It("ResetAfterConnectionMigrations", func() {
rttStats.UpdateRTT(200*time.Millisecond, 0, time.Time{})
Expect(rttStats.LatestRTT()).To(Equal((200 * time.Millisecond)))
Expect(rttStats.SmoothedRTT()).To(Equal((200 * time.Millisecond)))
Expect(rttStats.MinRTT()).To(Equal((200 * time.Millisecond)))
rttStats.UpdateRTT((300 * time.Millisecond), (100 * time.Millisecond), time.Time{})
Expect(rttStats.LatestRTT()).To(Equal((200 * time.Millisecond)))
Expect(rttStats.SmoothedRTT()).To(Equal((200 * time.Millisecond)))
Expect(rttStats.MinRTT()).To(Equal((200 * time.Millisecond)))
// Reset rtt stats on connection migrations.
rttStats.OnConnectionMigration()
Expect(rttStats.LatestRTT()).To(Equal(time.Duration(0)))
Expect(rttStats.SmoothedRTT()).To(Equal(time.Duration(0)))
Expect(rttStats.MinRTT()).To(Equal(time.Duration(0)))
})
It("restores the RTT", func() {
var rttStats RTTStats
rttStats.SetInitialRTT(10 * time.Second)
Expect(rttStats.LatestRTT()).To(Equal(10 * time.Second))
Expect(rttStats.SmoothedRTT()).To(Equal(10 * time.Second))
@@ -148,6 +109,7 @@ var _ = Describe("RTT stats", func() {
})
It("doesn't restore the RTT if we already have a measurement", func() {
var rttStats RTTStats
const rtt = 10 * time.Millisecond
rttStats.UpdateRTT(rtt, 0, time.Now())
Expect(rttStats.LatestRTT()).To(Equal(rtt))

36
internal/utils/timer_test.go
View File

@@ -10,40 +10,34 @@ import (
var _ = Describe("Timer", func() {
const d = 10 * time.Millisecond
It("doesn't fire a newly created timer", func() {
It("works correctly for newly created and reset timers", func() {
t := NewTimer()
Consistently(t.Chan()).ShouldNot(Receive())
})
It("works", func() {
t := NewTimer()
t.Reset(time.Now().Add(d))
Eventually(t.Chan()).Should(Receive())
})
It("returns the deadline", func() {
t := NewTimer()
deadline := time.Now().Add(d)
t.Reset(deadline)
Expect(t.Deadline()).To(Equal(deadline))
Eventually(t.Chan()).Should(Receive())
t.SetRead()
t.Reset(time.Now().Add(d))
Eventually(t.Chan()).Should(Receive())
})
It("works multiple times with reading", func() {
It("works multiple times with and without reading", func() {
t := NewTimer()
for i := 0; i < 10; i++ {
t.Reset(time.Now().Add(d))
Eventually(t.Chan()).Should(Receive())
t.SetRead()
}
})
It("works multiple times without reading", func() {
t := NewTimer()
for i := 0; i < 10; i++ {
t.Reset(time.Now().Add(d))
time.Sleep(d * 2)
if i%2 == 0 {
// Read on even iterations
Eventually(t.Chan()).Should(Receive())
t.SetRead()
} else {
// Don't read on odd iterations
time.Sleep(d * 2)
}
}
// Ensure the last timer fires if it wasn't read
Eventually(t.Chan()).Should(Receive())
})