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

move congestion controller related constants to the congestion package

Browse source
This commit is contained in:
Marten Seemann 2020-01-22 14:40:14 +07:00
parent 62d3a4166a
commit 31e4691ffd
9 changed files with 144 additions and 146 deletions
Download patch file Download diff file Expand all files Collapse all files

2
internal/ackhandler/sent_packet_handler.go
View file

@ -87,8 +87,6 @@ func NewSentPacketHandler(
congestion.DefaultClock{}, congestion.DefaultClock{},
rttStats, rttStats,
true, // use Reno true, // use Reno
protocol.InitialCongestionWindow,
protocol.DefaultMaxCongestionWindow,
) )
return &sentPacketHandler{ return &sentPacketHandler{

8
internal/congestion/cubic.go
View file

@ -19,7 +19,7 @@ import (
// where 0.100 is 100 ms which is the scaling round trip time. // where 0.100 is 100 ms which is the scaling round trip time.
const cubeScale = 40 const cubeScale = 40
const cubeCongestionWindowScale = 410 const cubeCongestionWindowScale = 410
const cubeFactor protocol.ByteCount = 1 << cubeScale / cubeCongestionWindowScale / protocol.DefaultTCPMSS const cubeFactor protocol.ByteCount = 1 << cubeScale / cubeCongestionWindowScale / defaultTCPMSS
const defaultNumConnections = 1 const defaultNumConnections = 1
@ -125,7 +125,7 @@ func (c *Cubic) OnApplicationLimited() {
// a loss event. Returns the new congestion window in packets. The new // a loss event. Returns the new congestion window in packets. The new
// congestion window is a multiplicative decrease of our current window. // congestion window is a multiplicative decrease of our current window.
func (c *Cubic) CongestionWindowAfterPacketLoss(currentCongestionWindow protocol.ByteCount) protocol.ByteCount { func (c *Cubic) CongestionWindowAfterPacketLoss(currentCongestionWindow protocol.ByteCount) protocol.ByteCount {
if currentCongestionWindow+protocol.DefaultTCPMSS < c.lastMaxCongestionWindow { if currentCongestionWindow+defaultTCPMSS < c.lastMaxCongestionWindow {
// We never reached the old max, so assume we are competing with another // We never reached the old max, so assume we are competing with another
// flow. Use our extra back off factor to allow the other flow to go up. // flow. Use our extra back off factor to allow the other flow to go up.
c.lastMaxCongestionWindow = protocol.ByteCount(c.betaLastMax() * float32(currentCongestionWindow)) c.lastMaxCongestionWindow = protocol.ByteCount(c.betaLastMax() * float32(currentCongestionWindow))
@ -175,7 +175,7 @@ func (c *Cubic) CongestionWindowAfterAck(
offset = -offset offset = -offset
} }
deltaCongestionWindow := protocol.ByteCount(cubeCongestionWindowScale*offset*offset*offset) * protocol.DefaultTCPMSS >> cubeScale deltaCongestionWindow := protocol.ByteCount(cubeCongestionWindowScale*offset*offset*offset) * defaultTCPMSS >> cubeScale
var targetCongestionWindow protocol.ByteCount var targetCongestionWindow protocol.ByteCount
if elapsedTime > int64(c.timeToOriginPoint) { if elapsedTime > int64(c.timeToOriginPoint) {
targetCongestionWindow = c.originPointCongestionWindow + deltaCongestionWindow targetCongestionWindow = c.originPointCongestionWindow + deltaCongestionWindow
@ -190,7 +190,7 @@ func (c *Cubic) CongestionWindowAfterAck(
// congestion windows (less than 25), the formula below will // congestion windows (less than 25), the formula below will
// increase slightly slower than linearly per estimated tcp window // increase slightly slower than linearly per estimated tcp window
// of bytes. // of bytes.
c.estimatedTCPcongestionWindow += protocol.ByteCount(float32(c.ackedBytesCount) * c.alpha() * float32(protocol.DefaultTCPMSS) / float32(c.estimatedTCPcongestionWindow)) c.estimatedTCPcongestionWindow += protocol.ByteCount(float32(c.ackedBytesCount) * c.alpha() * float32(defaultTCPMSS) / float32(c.estimatedTCPcongestionWindow))
c.ackedBytesCount = 0 c.ackedBytesCount = 0
// We have a new cubic congestion window. // We have a new cubic congestion window.

31
internal/congestion/cubic_sender.go
View file

@ -8,9 +8,14 @@ import (
) )
const ( const (
maxBurstBytes = 3 * protocol.DefaultTCPMSS // defaultTCPMSS is the default maximum packet size used in the Linux TCP implementation.
renoBeta float32 = 0.7 // Reno backoff factor. // Used in QUIC for congestion window computations in bytes.
defaultMinimumCongestionWindow protocol.ByteCount = 2 * protocol.DefaultTCPMSS defaultTCPMSS protocol.ByteCount = 1460
maxBurstBytes = 3 * defaultTCPMSS
renoBeta float32 = 0.7 // Reno backoff factor.
maxCongestionWindow = protocol.MaxCongestionWindowPackets * defaultTCPMSS
minCongestionWindow = 2 * defaultTCPMSS
initialCongestionWindow = 32 * defaultTCPMSS
) )
type cubicSender struct { type cubicSender struct {
@ -67,7 +72,11 @@ var _ SendAlgorithm = &cubicSender{}
var _ SendAlgorithmWithDebugInfos = &cubicSender{} var _ SendAlgorithmWithDebugInfos = &cubicSender{}
// NewCubicSender makes a new cubic sender // NewCubicSender makes a new cubic sender
func NewCubicSender(clock Clock, rttStats *RTTStats, reno bool, initialCongestionWindow, initialMaxCongestionWindow protocol.ByteCount) *cubicSender { func NewCubicSender(clock Clock, rttStats *RTTStats, reno bool) *cubicSender {
return newCubicSender(clock, rttStats, reno, initialCongestionWindow, maxCongestionWindow)
}
func newCubicSender(clock Clock, rttStats *RTTStats, reno bool, initialCongestionWindow, initialMaxCongestionWindow protocol.ByteCount) *cubicSender {
return &cubicSender{ return &cubicSender{
rttStats: rttStats, rttStats: rttStats,
largestSentPacketNumber: protocol.InvalidPacketNumber, largestSentPacketNumber: protocol.InvalidPacketNumber,
@ -76,7 +85,7 @@ func NewCubicSender(clock Clock, rttStats *RTTStats, reno bool, initialCongestio
initialCongestionWindow: initialCongestionWindow, initialCongestionWindow: initialCongestionWindow,
initialMaxCongestionWindow: initialMaxCongestionWindow, initialMaxCongestionWindow: initialMaxCongestionWindow,
congestionWindow: initialCongestionWindow, congestionWindow: initialCongestionWindow,
minCongestionWindow: defaultMinimumCongestionWindow, minCongestionWindow: minCongestionWindow,
slowstartThreshold: initialMaxCongestionWindow, slowstartThreshold: initialMaxCongestionWindow,
maxCongestionWindow: initialMaxCongestionWindow, maxCongestionWindow: initialMaxCongestionWindow,
numConnections: defaultNumConnections, numConnections: defaultNumConnections,
@ -93,7 +102,7 @@ func (c *cubicSender) TimeUntilSend(bytesInFlight protocol.ByteCount) time.Durat
return 0 return 0
} }
} }
return c.rttStats.SmoothedRTT() * time.Duration(protocol.DefaultTCPMSS) / time.Duration(2*c.GetCongestionWindow()) return c.rttStats.SmoothedRTT() * time.Duration(defaultTCPMSS) / time.Duration(2*c.GetCongestionWindow())
} }
func (c *cubicSender) OnPacketSent( func (c *cubicSender) OnPacketSent(
@ -146,7 +155,7 @@ func (c *cubicSender) SlowstartThreshold() protocol.ByteCount {
} }
func (c *cubicSender) MaybeExitSlowStart() { func (c *cubicSender) MaybeExitSlowStart() {
if c.InSlowStart() && c.hybridSlowStart.ShouldExitSlowStart(c.rttStats.LatestRTT(), c.rttStats.MinRTT(), c.GetCongestionWindow()/protocol.DefaultTCPMSS) { if c.InSlowStart() && c.hybridSlowStart.ShouldExitSlowStart(c.rttStats.LatestRTT(), c.rttStats.MinRTT(), c.GetCongestionWindow()/defaultTCPMSS) {
c.ExitSlowstart() c.ExitSlowstart()
} }
} }
@ -204,7 +213,7 @@ func (c *cubicSender) OnPacketLost(
if c.congestionWindow >= 2*c.initialCongestionWindow { if c.congestionWindow >= 2*c.initialCongestionWindow {
c.minSlowStartExitWindow = c.congestionWindow / 2 c.minSlowStartExitWindow = c.congestionWindow / 2
} }
c.congestionWindow -= protocol.DefaultTCPMSS c.congestionWindow -= defaultTCPMSS
} else if c.reno { } else if c.reno {
c.congestionWindow = protocol.ByteCount(float32(c.congestionWindow) * c.RenoBeta()) c.congestionWindow = protocol.ByteCount(float32(c.congestionWindow) * c.RenoBeta())
} else { } else {
@ -247,7 +256,7 @@ func (c *cubicSender) maybeIncreaseCwnd(
} }
if c.InSlowStart() { if c.InSlowStart() {
// TCP slow start, exponential growth, increase by one for each ACK. // TCP slow start, exponential growth, increase by one for each ACK.
c.congestionWindow += protocol.DefaultTCPMSS c.congestionWindow += defaultTCPMSS
return return
} }
// Congestion avoidance // Congestion avoidance
@ -256,8 +265,8 @@ func (c *cubicSender) maybeIncreaseCwnd(
c.numAckedPackets++ c.numAckedPackets++
// Divide by num_connections to smoothly increase the CWND at a faster // Divide by num_connections to smoothly increase the CWND at a faster
// rate than conventional Reno. // rate than conventional Reno.
if c.numAckedPackets*uint64(c.numConnections) >= uint64(c.congestionWindow)/uint64(protocol.DefaultTCPMSS) { if c.numAckedPackets*uint64(c.numConnections) >= uint64(c.congestionWindow)/uint64(defaultTCPMSS) {
c.congestionWindow += protocol.DefaultTCPMSS c.congestionWindow += defaultTCPMSS
c.numAckedPackets = 0 c.numAckedPackets = 0
} }
} else { } else {

104
internal/congestion/cubic_sender_test.go
View file

@ -10,7 +10,7 @@ import (
) )
const initialCongestionWindowPackets = 10 const initialCongestionWindowPackets = 10
const defaultWindowTCP = protocol.ByteCount(initialCongestionWindowPackets) * protocol.DefaultTCPMSS const defaultWindowTCP = protocol.ByteCount(initialCongestionWindowPackets) * defaultTCPMSS
type mockClock time.Time type mockClock time.Time
@ -22,7 +22,7 @@ func (c *mockClock) Advance(d time.Duration) {
*c = mockClock(time.Time(*c).Add(d)) *c = mockClock(time.Time(*c).Add(d))
} }
const MaxCongestionWindow protocol.ByteCount = 200 * protocol.DefaultTCPMSS const MaxCongestionWindow protocol.ByteCount = 200 * defaultTCPMSS
var _ = Describe("Cubic Sender", func() { var _ = Describe("Cubic Sender", func() {
var ( var (
@ -40,7 +40,7 @@ var _ = Describe("Cubic Sender", func() {
ackedPacketNumber = 0 ackedPacketNumber = 0
clock = mockClock{} clock = mockClock{}
rttStats = NewRTTStats() rttStats = NewRTTStats()
sender = NewCubicSender(&clock, rttStats, true /*reno*/, initialCongestionWindowPackets*protocol.DefaultTCPMSS, MaxCongestionWindow) sender = newCubicSender(&clock, rttStats, true /*reno*/, initialCongestionWindowPackets*defaultTCPMSS, MaxCongestionWindow)
}) })
SendAvailableSendWindowLen := func(packetLength protocol.ByteCount) int { SendAvailableSendWindowLen := func(packetLength protocol.ByteCount) int {
@ -60,9 +60,9 @@ var _ = Describe("Cubic Sender", func() {
sender.MaybeExitSlowStart() sender.MaybeExitSlowStart()
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
ackedPacketNumber++ ackedPacketNumber++
sender.OnPacketAcked(ackedPacketNumber, protocol.DefaultTCPMSS, bytesInFlight, clock.Now()) sender.OnPacketAcked(ackedPacketNumber, defaultTCPMSS, bytesInFlight, clock.Now())
} }
bytesInFlight -= protocol.ByteCount(n) * protocol.DefaultTCPMSS bytesInFlight -= protocol.ByteCount(n) * defaultTCPMSS
clock.Advance(time.Millisecond) clock.Advance(time.Millisecond)
} }
@ -76,12 +76,12 @@ var _ = Describe("Cubic Sender", func() {
// Does not increment acked_packet_number_. // Does not increment acked_packet_number_.
LosePacket := func(number protocol.PacketNumber) { LosePacket := func(number protocol.PacketNumber) {
sender.OnPacketLost(number, protocol.DefaultTCPMSS, bytesInFlight) sender.OnPacketLost(number, defaultTCPMSS, bytesInFlight)
bytesInFlight -= protocol.DefaultTCPMSS bytesInFlight -= defaultTCPMSS
} }
SendAvailableSendWindow := func() int { return SendAvailableSendWindowLen(protocol.DefaultTCPMSS) } SendAvailableSendWindow := func() int { return SendAvailableSendWindowLen(defaultTCPMSS) }
LoseNPackets := func(n int) { LoseNPacketsLen(n, protocol.DefaultTCPMSS) } LoseNPackets := func(n int) { LoseNPacketsLen(n, defaultTCPMSS) }
It("has the right values at startup", func() { It("has the right values at startup", func() {
// At startup make sure we are at the default. // At startup make sure we are at the default.
@ -121,7 +121,7 @@ var _ = Describe("Cubic Sender", func() {
bytesToSend := sender.GetCongestionWindow() bytesToSend := sender.GetCongestionWindow()
// It's expected 2 acks will arrive when the bytes_in_flight are greater than // It's expected 2 acks will arrive when the bytes_in_flight are greater than
// half the CWND. // half the CWND.
Expect(bytesToSend).To(Equal(defaultWindowTCP + protocol.DefaultTCPMSS*2*2)) Expect(bytesToSend).To(Equal(defaultWindowTCP + defaultTCPMSS*2*2))
}) })
It("exponential slow start", func() { It("exponential slow start", func() {
@ -139,7 +139,7 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
cwnd := sender.GetCongestionWindow() cwnd := sender.GetCongestionWindow()
Expect(cwnd).To(Equal(defaultWindowTCP + protocol.DefaultTCPMSS*2*numberOfAcks)) Expect(cwnd).To(Equal(defaultWindowTCP + defaultTCPMSS*2*numberOfAcks))
Expect(sender.BandwidthEstimate()).To(Equal(BandwidthFromDelta(cwnd, rttStats.SmoothedRTT()))) Expect(sender.BandwidthEstimate()).To(Equal(BandwidthFromDelta(cwnd, rttStats.SmoothedRTT())))
}) })
@ -152,12 +152,12 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindow() SendAvailableSendWindow()
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Lose a packet to exit slow start. // Lose a packet to exit slow start.
LoseNPackets(1) LoseNPackets(1)
packetsInRecoveryWindow := expectedSendWindow / protocol.DefaultTCPMSS packetsInRecoveryWindow := expectedSendWindow / defaultTCPMSS
// We should now have fallen out of slow start with a reduced window. // We should now have fallen out of slow start with a reduced window.
expectedSendWindow = protocol.ByteCount(float32(expectedSendWindow) * renoBeta) expectedSendWindow = protocol.ByteCount(float32(expectedSendWindow) * renoBeta)
@ -165,7 +165,7 @@ var _ = Describe("Cubic Sender", func() {
// Recovery phase. We need to ack every packet in the recovery window before // Recovery phase. We need to ack every packet in the recovery window before
// we exit recovery. // we exit recovery.
numberOfPacketsInWindow := expectedSendWindow / protocol.DefaultTCPMSS numberOfPacketsInWindow := expectedSendWindow / defaultTCPMSS
AckNPackets(int(packetsInRecoveryWindow)) AckNPackets(int(packetsInRecoveryWindow))
SendAvailableSendWindow() SendAvailableSendWindow()
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
@ -177,7 +177,7 @@ var _ = Describe("Cubic Sender", func() {
// Next ack should increase cwnd by 1. // Next ack should increase cwnd by 1.
AckNPackets(1) AckNPackets(1)
expectedSendWindow += protocol.DefaultTCPMSS expectedSendWindow += defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Now RTO and ensure slow start gets reset. // Now RTO and ensure slow start gets reset.
@ -197,26 +197,26 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindow() SendAvailableSendWindow()
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Lose a packet to exit slow start. We should now have fallen out of // Lose a packet to exit slow start. We should now have fallen out of
// slow start with a window reduced by 1. // slow start with a window reduced by 1.
LoseNPackets(1) LoseNPackets(1)
expectedSendWindow -= protocol.DefaultTCPMSS expectedSendWindow -= defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Lose 5 packets in recovery and verify that congestion window is reduced // Lose 5 packets in recovery and verify that congestion window is reduced
// further. // further.
LoseNPackets(5) LoseNPackets(5)
expectedSendWindow -= 5 * protocol.DefaultTCPMSS expectedSendWindow -= 5 * defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
packetsInRecoveryWindow := expectedSendWindow / protocol.DefaultTCPMSS packetsInRecoveryWindow := expectedSendWindow / defaultTCPMSS
// Recovery phase. We need to ack every packet in the recovery window before // Recovery phase. We need to ack every packet in the recovery window before
// we exit recovery. // we exit recovery.
numberOfPacketsInWindow := expectedSendWindow / protocol.DefaultTCPMSS numberOfPacketsInWindow := expectedSendWindow / defaultTCPMSS
AckNPackets(int(packetsInRecoveryWindow)) AckNPackets(int(packetsInRecoveryWindow))
SendAvailableSendWindow() SendAvailableSendWindow()
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
@ -228,7 +228,7 @@ var _ = Describe("Cubic Sender", func() {
// Next ack should increase cwnd by 1. // Next ack should increase cwnd by 1.
AckNPackets(1) AckNPackets(1)
expectedSendWindow += protocol.DefaultTCPMSS expectedSendWindow += defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Now RTO and ensure slow start gets reset. // Now RTO and ensure slow start gets reset.
@ -244,23 +244,23 @@ var _ = Describe("Cubic Sender", func() {
const numberOfAcks = 10 const numberOfAcks = 10
for i := 0; i < numberOfAcks; i++ { for i := 0; i < numberOfAcks; i++ {
// Send our full send window in half sized packets. // Send our full send window in half sized packets.
SendAvailableSendWindowLen(protocol.DefaultTCPMSS / 2) SendAvailableSendWindowLen(defaultTCPMSS / 2)
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindowLen(protocol.DefaultTCPMSS / 2) SendAvailableSendWindowLen(defaultTCPMSS / 2)
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Lose a packet to exit slow start. We should now have fallen out of // Lose a packet to exit slow start. We should now have fallen out of
// slow start with a window reduced by 1. // slow start with a window reduced by 1.
LoseNPackets(1) LoseNPackets(1)
expectedSendWindow -= protocol.DefaultTCPMSS expectedSendWindow -= defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Lose 10 packets in recovery and verify that congestion window is reduced // Lose 10 packets in recovery and verify that congestion window is reduced
// by 5 packets. // by 5 packets.
LoseNPacketsLen(10, protocol.DefaultTCPMSS/2) LoseNPacketsLen(10, defaultTCPMSS/2)
expectedSendWindow -= 5 * protocol.DefaultTCPMSS expectedSendWindow -= 5 * defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
}) })
@ -287,7 +287,7 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindow() SendAvailableSendWindow()
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
LoseNPackets(1) LoseNPackets(1)
@ -302,7 +302,7 @@ var _ = Describe("Cubic Sender", func() {
// outstanding packets. The number of packets before we exit recovery is the // outstanding packets. The number of packets before we exit recovery is the
// original CWND minus the packet that has been lost and the one which // original CWND minus the packet that has been lost and the one which
// triggered the loss. // triggered the loss.
remainingPacketsInRecovery := sendWindowBeforeLoss/protocol.DefaultTCPMSS - 2 remainingPacketsInRecovery := sendWindowBeforeLoss/defaultTCPMSS - 2
for i := protocol.ByteCount(0); i < remainingPacketsInRecovery; i++ { for i := protocol.ByteCount(0); i < remainingPacketsInRecovery; i++ {
AckNPackets(1) AckNPackets(1)
@ -311,7 +311,7 @@ var _ = Describe("Cubic Sender", func() {
} }
// We need to ack another window before we increase CWND by 1. // We need to ack another window before we increase CWND by 1.
numberOfPacketsInWindow := expectedSendWindow / protocol.DefaultTCPMSS numberOfPacketsInWindow := expectedSendWindow / defaultTCPMSS
for i := protocol.ByteCount(0); i < numberOfPacketsInWindow; i++ { for i := protocol.ByteCount(0); i < numberOfPacketsInWindow; i++ {
AckNPackets(1) AckNPackets(1)
Expect(SendAvailableSendWindow()).To(Equal(1)) Expect(SendAvailableSendWindow()).To(Equal(1))
@ -319,7 +319,7 @@ var _ = Describe("Cubic Sender", func() {
} }
AckNPackets(1) AckNPackets(1)
expectedSendWindow += protocol.DefaultTCPMSS expectedSendWindow += defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
}) })
@ -336,13 +336,13 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindow() SendAvailableSendWindow()
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Lose one more than the congestion window reduction, so that after loss, // Lose one more than the congestion window reduction, so that after loss,
// bytes_in_flight is lesser than the congestion window. // bytes_in_flight is lesser than the congestion window.
sendWindowAfterLoss := protocol.ByteCount(renoBeta * float32(expectedSendWindow)) sendWindowAfterLoss := protocol.ByteCount(renoBeta * float32(expectedSendWindow))
numPacketsToLose := (expectedSendWindow-sendWindowAfterLoss)/protocol.DefaultTCPMSS + 1 numPacketsToLose := (expectedSendWindow-sendWindowAfterLoss)/defaultTCPMSS + 1
LoseNPackets(int(numPacketsToLose)) LoseNPackets(int(numPacketsToLose))
// Immediately after the loss, ensure at least one packet can be sent. // Immediately after the loss, ensure at least one packet can be sent.
// Losses without subsequent acks can occur with timer based loss detection. // Losses without subsequent acks can occur with timer based loss detection.
@ -384,8 +384,8 @@ var _ = Describe("Cubic Sender", func() {
// Expect the window to decrease to the minimum once the RTO fires // Expect the window to decrease to the minimum once the RTO fires
// and slow start threshold to be set to 1/2 of the CWND. // and slow start threshold to be set to 1/2 of the CWND.
sender.OnRetransmissionTimeout(true) sender.OnRetransmissionTimeout(true)
Expect(sender.GetCongestionWindow()).To(Equal(2 * protocol.DefaultTCPMSS)) Expect(sender.GetCongestionWindow()).To(Equal(2 * defaultTCPMSS))
Expect(sender.SlowstartThreshold()).To(Equal(5 * protocol.DefaultTCPMSS)) Expect(sender.SlowstartThreshold()).To(Equal(5 * defaultTCPMSS))
}) })
It("RTO congestion window no retransmission", func() { It("RTO congestion window no retransmission", func() {
@ -399,8 +399,8 @@ var _ = Describe("Cubic Sender", func() {
It("tcp cubic reset epoch on quiescence", func() { It("tcp cubic reset epoch on quiescence", func() {
const maxCongestionWindow = 50 const maxCongestionWindow = 50
const maxCongestionWindowBytes = maxCongestionWindow * protocol.DefaultTCPMSS const maxCongestionWindowBytes = maxCongestionWindow * defaultTCPMSS
sender = NewCubicSender(&clock, rttStats, false, initialCongestionWindowPackets*protocol.DefaultTCPMSS, maxCongestionWindowBytes) sender = newCubicSender(&clock, rttStats, false, initialCongestionWindowPackets*defaultTCPMSS, maxCongestionWindowBytes)
numSent := SendAvailableSendWindow() numSent := SendAvailableSendWindow()
@ -433,7 +433,7 @@ var _ = Describe("Cubic Sender", func() {
savedCwnd = sender.GetCongestionWindow() savedCwnd = sender.GetCongestionWindow()
SendAvailableSendWindow() SendAvailableSendWindow()
AckNPackets(1) AckNPackets(1)
Expect(savedCwnd).To(BeNumerically("~", sender.GetCongestionWindow(), protocol.DefaultTCPMSS)) Expect(savedCwnd).To(BeNumerically("~", sender.GetCongestionWindow(), defaultTCPMSS))
Expect(maxCongestionWindowBytes).To(BeNumerically(">", sender.GetCongestionWindow())) Expect(maxCongestionWindowBytes).To(BeNumerically(">", sender.GetCongestionWindow()))
}) })
@ -463,7 +463,7 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindow() SendAvailableSendWindow()
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
LoseNPackets(1) LoseNPackets(1)
@ -484,7 +484,7 @@ var _ = Describe("Cubic Sender", func() {
Expect(sender.InRecovery()).To(BeFalse()) Expect(sender.InRecovery()).To(BeFalse())
// Out of recovery now. Congestion window should not grow for half an RTT. // Out of recovery now. Congestion window should not grow for half an RTT.
packetsInSendWindow := expectedSendWindow / protocol.DefaultTCPMSS packetsInSendWindow := expectedSendWindow / defaultTCPMSS
SendAvailableSendWindow() SendAvailableSendWindow()
AckNPackets(int(packetsInSendWindow/2 - 2)) AckNPackets(int(packetsInSendWindow/2 - 2))
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
@ -492,7 +492,7 @@ var _ = Describe("Cubic Sender", func() {
// Next ack should increase congestion window by 1MSS. // Next ack should increase congestion window by 1MSS.
SendAvailableSendWindow() SendAvailableSendWindow()
AckNPackets(2) AckNPackets(2)
expectedSendWindow += protocol.DefaultTCPMSS expectedSendWindow += defaultTCPMSS
packetsInSendWindow++ packetsInSendWindow++
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
@ -504,7 +504,7 @@ var _ = Describe("Cubic Sender", func() {
// Next ack should cause congestion window to grow by 1MSS. // Next ack should cause congestion window to grow by 1MSS.
SendAvailableSendWindow() SendAvailableSendWindow()
AckNPackets(2) AckNPackets(2)
expectedSendWindow += protocol.DefaultTCPMSS expectedSendWindow += defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
}) })
@ -518,7 +518,7 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindow() SendAvailableSendWindow()
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
LoseNPackets(1) LoseNPackets(1)
@ -539,7 +539,7 @@ var _ = Describe("Cubic Sender", func() {
Expect(sender.InRecovery()).To(BeFalse()) Expect(sender.InRecovery()).To(BeFalse())
// Out of recovery now. Congestion window should not grow during RTT. // Out of recovery now. Congestion window should not grow during RTT.
for i := protocol.ByteCount(0); i < expectedSendWindow/protocol.DefaultTCPMSS-2; i += 2 { for i := protocol.ByteCount(0); i < expectedSendWindow/defaultTCPMSS-2; i += 2 {
// Send our full send window. // Send our full send window.
SendAvailableSendWindow() SendAvailableSendWindow()
AckNPackets(2) AckNPackets(2)
@ -549,7 +549,7 @@ var _ = Describe("Cubic Sender", func() {
// Next ack should cause congestion window to grow by 1MSS. // Next ack should cause congestion window to grow by 1MSS.
SendAvailableSendWindow() SendAvailableSendWindow()
AckNPackets(2) AckNPackets(2)
expectedSendWindow += protocol.DefaultTCPMSS expectedSendWindow += defaultTCPMSS
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
}) })
@ -562,7 +562,7 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(1) AckNPackets(1)
Expect(sender.GetCongestionWindow()).To(Equal(protocol.ByteCount(renoBeta * float32(defaultWindowTCP)))) Expect(sender.GetCongestionWindow()).To(Equal(protocol.ByteCount(renoBeta * float32(defaultWindowTCP))))
windowInPackets := renoBeta * float32(defaultWindowTCP) / float32(protocol.DefaultTCPMSS) windowInPackets := renoBeta * float32(defaultWindowTCP) / float32(defaultTCPMSS)
numSent := SendAvailableSendWindow() numSent := SendAvailableSendWindow()
Expect(numSent).To(BeEquivalentTo(windowInPackets)) Expect(numSent).To(BeEquivalentTo(windowInPackets))
}) })
@ -580,7 +580,7 @@ var _ = Describe("Cubic Sender", func() {
AckNPackets(2) AckNPackets(2)
} }
SendAvailableSendWindow() SendAvailableSendWindow()
expectedSendWindow := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * numberOfAcks) expectedSendWindow := defaultWindowTCP + (defaultTCPMSS * 2 * numberOfAcks)
Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow)) Expect(sender.GetCongestionWindow()).To(Equal(expectedSendWindow))
// Loses a packet to exit slow start. // Loses a packet to exit slow start.
@ -600,19 +600,19 @@ var _ = Describe("Cubic Sender", func() {
}) })
It("default max cwnd", func() { It("default max cwnd", func() {
sender = NewCubicSender(&clock, rttStats, true /*reno*/, initialCongestionWindowPackets*protocol.DefaultTCPMSS, protocol.DefaultMaxCongestionWindow) sender = newCubicSender(&clock, rttStats, true /*reno*/, initialCongestionWindowPackets*defaultTCPMSS, maxCongestionWindow)
defaultMaxCongestionWindowPackets := protocol.DefaultMaxCongestionWindow / protocol.DefaultTCPMSS defaultMaxCongestionWindowPackets := maxCongestionWindow / defaultTCPMSS
for i := 1; i < int(defaultMaxCongestionWindowPackets); i++ { for i := 1; i < int(defaultMaxCongestionWindowPackets); i++ {
sender.MaybeExitSlowStart() sender.MaybeExitSlowStart()
sender.OnPacketAcked(protocol.PacketNumber(i), 1350, sender.GetCongestionWindow(), clock.Now()) sender.OnPacketAcked(protocol.PacketNumber(i), 1350, sender.GetCongestionWindow(), clock.Now())
} }
Expect(sender.GetCongestionWindow()).To(Equal(protocol.DefaultMaxCongestionWindow)) Expect(sender.GetCongestionWindow()).To(Equal(maxCongestionWindow))
}) })
It("limit cwnd increase in congestion avoidance", func() { It("limit cwnd increase in congestion avoidance", func() {
// Enable Cubic. // Enable Cubic.
sender = NewCubicSender(&clock, rttStats, false, initialCongestionWindowPackets*protocol.DefaultTCPMSS, MaxCongestionWindow) sender = newCubicSender(&clock, rttStats, false, initialCongestionWindowPackets*defaultTCPMSS, MaxCongestionWindow)
numSent := SendAvailableSendWindow() numSent := SendAvailableSendWindow()
// Make sure we fall out of slow start. // Make sure we fall out of slow start.
@ -644,6 +644,6 @@ var _ = Describe("Cubic Sender", func() {
// Ack two packets. The CWND should increase by only one packet. // Ack two packets. The CWND should increase by only one packet.
AckNPackets(2) AckNPackets(2)
Expect(sender.GetCongestionWindow()).To(Equal(savedCwnd + protocol.DefaultTCPMSS)) Expect(sender.GetCongestionWindow()).To(Equal(savedCwnd + defaultTCPMSS))
}) })
}) })

54
internal/congestion/cubic_test.go
View file

@ -28,12 +28,12 @@ var _ = Describe("Cubic", func() {
}) })
renoCwnd := func(currentCwnd protocol.ByteCount) protocol.ByteCount { renoCwnd := func(currentCwnd protocol.ByteCount) protocol.ByteCount {
return currentCwnd + protocol.ByteCount(float32(protocol.DefaultTCPMSS)*nConnectionAlpha*float32(protocol.DefaultTCPMSS)/float32(currentCwnd)) return currentCwnd + protocol.ByteCount(float32(defaultTCPMSS)*nConnectionAlpha*float32(defaultTCPMSS)/float32(currentCwnd))
} }
cubicConvexCwnd := func(initialCwnd protocol.ByteCount, rtt, elapsedTime time.Duration) protocol.ByteCount { cubicConvexCwnd := func(initialCwnd protocol.ByteCount, rtt, elapsedTime time.Duration) protocol.ByteCount {
offset := protocol.ByteCount((elapsedTime+rtt)/time.Microsecond) << 10 / 1000000 offset := protocol.ByteCount((elapsedTime+rtt)/time.Microsecond) << 10 / 1000000
deltaCongestionWindow := 410 * offset * offset * offset * protocol.DefaultTCPMSS >> 40 deltaCongestionWindow := 410 * offset * offset * offset * defaultTCPMSS >> 40
return initialCwnd + deltaCongestionWindow return initialCwnd + deltaCongestionWindow
} }
@ -41,13 +41,13 @@ var _ = Describe("Cubic", func() {
// Convex growth. // Convex growth.
const rttMin = 100 * time.Millisecond const rttMin = 100 * time.Millisecond
const rttMinS = float32(rttMin/time.Millisecond) / 1000.0 const rttMinS = float32(rttMin/time.Millisecond) / 1000.0
currentCwnd := 10 * protocol.DefaultTCPMSS currentCwnd := 10 * defaultTCPMSS
initialCwnd := currentCwnd initialCwnd := currentCwnd
clock.Advance(time.Millisecond) clock.Advance(time.Millisecond)
initialTime := clock.Now() initialTime := clock.Now()
expectedFirstCwnd := renoCwnd(currentCwnd) expectedFirstCwnd := renoCwnd(currentCwnd)
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, initialTime) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, initialTime)
Expect(expectedFirstCwnd).To(Equal(currentCwnd)) Expect(expectedFirstCwnd).To(Equal(currentCwnd))
// Normal TCP phase. // Normal TCP phase.
@ -59,13 +59,13 @@ var _ = Describe("Cubic", func() {
// receive current_cwnd/Alpha acks back. (This is another way of // receive current_cwnd/Alpha acks back. (This is another way of
// saying we expect cwnd to increase by approximately Alpha once // saying we expect cwnd to increase by approximately Alpha once
// we receive current_cwnd number ofacks back). // we receive current_cwnd number ofacks back).
numAcksThisEpoch := int(float32(currentCwnd/protocol.DefaultTCPMSS) / nConnectionAlpha) numAcksThisEpoch := int(float32(currentCwnd/defaultTCPMSS) / nConnectionAlpha)
initialCwndThisEpoch := currentCwnd initialCwndThisEpoch := currentCwnd
for n := 0; n < numAcksThisEpoch; n++ { for n := 0; n < numAcksThisEpoch; n++ {
// Call once per ACK. // Call once per ACK.
expectedNextCwnd := renoCwnd(currentCwnd) expectedNextCwnd := renoCwnd(currentCwnd)
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
Expect(currentCwnd).To(Equal(expectedNextCwnd)) Expect(currentCwnd).To(Equal(expectedNextCwnd))
} }
// Our byte-wise Reno implementation is an estimate. We expect // Our byte-wise Reno implementation is an estimate. We expect
@ -73,51 +73,51 @@ var _ = Describe("Cubic", func() {
// cwnd/kDefaultTCPMSS/Alpha acks, but it may be off by as much as // cwnd/kDefaultTCPMSS/Alpha acks, but it may be off by as much as
// half a packet for smaller values of current_cwnd. // half a packet for smaller values of current_cwnd.
cwndChangeThisEpoch := currentCwnd - initialCwndThisEpoch cwndChangeThisEpoch := currentCwnd - initialCwndThisEpoch
Expect(cwndChangeThisEpoch).To(BeNumerically("~", protocol.DefaultTCPMSS, protocol.DefaultTCPMSS/2)) Expect(cwndChangeThisEpoch).To(BeNumerically("~", defaultTCPMSS, defaultTCPMSS/2))
clock.Advance(100 * time.Millisecond) clock.Advance(100 * time.Millisecond)
} }
for i := 0; i < 54; i++ { for i := 0; i < 54; i++ {
maxAcksThisEpoch := currentCwnd / protocol.DefaultTCPMSS maxAcksThisEpoch := currentCwnd / defaultTCPMSS
interval := time.Duration(100*1000/maxAcksThisEpoch) * time.Microsecond interval := time.Duration(100*1000/maxAcksThisEpoch) * time.Microsecond
for n := 0; n < int(maxAcksThisEpoch); n++ { for n := 0; n < int(maxAcksThisEpoch); n++ {
clock.Advance(interval) clock.Advance(interval)
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
expectedCwnd := cubicConvexCwnd(initialCwnd, rttMin, clock.Now().Sub(initialTime)) expectedCwnd := cubicConvexCwnd(initialCwnd, rttMin, clock.Now().Sub(initialTime))
// If we allow per-ack updates, every update is a small cubic update. // If we allow per-ack updates, every update is a small cubic update.
Expect(currentCwnd).To(Equal(expectedCwnd)) Expect(currentCwnd).To(Equal(expectedCwnd))
} }
} }
expectedCwnd := cubicConvexCwnd(initialCwnd, rttMin, clock.Now().Sub(initialTime)) expectedCwnd := cubicConvexCwnd(initialCwnd, rttMin, clock.Now().Sub(initialTime))
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
Expect(currentCwnd).To(Equal(expectedCwnd)) Expect(currentCwnd).To(Equal(expectedCwnd))
}) })
It("works above the origin with fine grained cubing", func() { It("works above the origin with fine grained cubing", func() {
// Start the test with an artificially large cwnd to prevent Reno // Start the test with an artificially large cwnd to prevent Reno
// from over-taking cubic. // from over-taking cubic.
currentCwnd := 1000 * protocol.DefaultTCPMSS currentCwnd := 1000 * defaultTCPMSS
initialCwnd := currentCwnd initialCwnd := currentCwnd
rttMin := 100 * time.Millisecond rttMin := 100 * time.Millisecond
clock.Advance(time.Millisecond) clock.Advance(time.Millisecond)
initialTime := clock.Now() initialTime := clock.Now()
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
clock.Advance(600 * time.Millisecond) clock.Advance(600 * time.Millisecond)
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
// We expect the algorithm to perform only non-zero, fine-grained cubic // We expect the algorithm to perform only non-zero, fine-grained cubic
// increases on every ack in this case. // increases on every ack in this case.
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
clock.Advance(10 * time.Millisecond) clock.Advance(10 * time.Millisecond)
expectedCwnd := cubicConvexCwnd(initialCwnd, rttMin, clock.Now().Sub(initialTime)) expectedCwnd := cubicConvexCwnd(initialCwnd, rttMin, clock.Now().Sub(initialTime))
nextCwnd := cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) nextCwnd := cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
// Make sure we are performing cubic increases. // Make sure we are performing cubic increases.
Expect(nextCwnd).To(Equal(expectedCwnd)) Expect(nextCwnd).To(Equal(expectedCwnd))
// Make sure that these are non-zero, less-than-packet sized increases. // Make sure that these are non-zero, less-than-packet sized increases.
Expect(nextCwnd).To(BeNumerically(">", currentCwnd)) Expect(nextCwnd).To(BeNumerically(">", currentCwnd))
cwndDelta := nextCwnd - currentCwnd cwndDelta := nextCwnd - currentCwnd
Expect(protocol.DefaultTCPMSS / 10).To(BeNumerically(">", cwndDelta)) Expect(defaultTCPMSS / 10).To(BeNumerically(">", cwndDelta))
currentCwnd = nextCwnd currentCwnd = nextCwnd
} }
}) })
@ -126,14 +126,14 @@ var _ = Describe("Cubic", func() {
// Start the test with a large cwnd and RTT, to force the first // Start the test with a large cwnd and RTT, to force the first
// increase to be a cubic increase. // increase to be a cubic increase.
initialCwndPackets := 150 initialCwndPackets := 150
currentCwnd := protocol.ByteCount(initialCwndPackets) * protocol.DefaultTCPMSS currentCwnd := protocol.ByteCount(initialCwndPackets) * defaultTCPMSS
rttMin := 350 * time.Millisecond rttMin := 350 * time.Millisecond
// Initialize the epoch // Initialize the epoch
clock.Advance(time.Millisecond) clock.Advance(time.Millisecond)
// Keep track of the growth of the reno-equivalent cwnd. // Keep track of the growth of the reno-equivalent cwnd.
rCwnd := renoCwnd(currentCwnd) rCwnd := renoCwnd(currentCwnd)
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
initialCwnd := currentCwnd initialCwnd := currentCwnd
// Simulate the return of cwnd packets in less than // Simulate the return of cwnd packets in less than
@ -149,10 +149,10 @@ var _ = Describe("Cubic", func() {
// regardless of the temporary plateau. // regardless of the temporary plateau.
clock.Advance(interval) clock.Advance(interval)
rCwnd = renoCwnd(rCwnd) rCwnd = renoCwnd(rCwnd)
Expect(cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now())).To(Equal(currentCwnd)) Expect(cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())).To(Equal(currentCwnd))
for i := 1; i < maxAcks; i++ { for i := 1; i < maxAcks; i++ {
clock.Advance(interval) clock.Advance(interval)
nextCwnd := cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) nextCwnd := cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
rCwnd = renoCwnd(rCwnd) rCwnd = renoCwnd(rCwnd)
// The window shoud increase on every ack. // The window shoud increase on every ack.
Expect(nextCwnd).To(BeNumerically(">", currentCwnd)) Expect(nextCwnd).To(BeNumerically(">", currentCwnd))
@ -165,17 +165,17 @@ var _ = Describe("Cubic", func() {
// packet, because our byte-wise Reno algorithm is always a slight // packet, because our byte-wise Reno algorithm is always a slight
// under-estimation). Without per-ack updates, the current_cwnd // under-estimation). Without per-ack updates, the current_cwnd
// would otherwise be unchanged. // would otherwise be unchanged.
minimumExpectedIncrease := protocol.DefaultTCPMSS * 9 / 10 minimumExpectedIncrease := defaultTCPMSS * 9 / 10
Expect(currentCwnd).To(BeNumerically(">", initialCwnd+minimumExpectedIncrease)) Expect(currentCwnd).To(BeNumerically(">", initialCwnd+minimumExpectedIncrease))
}) })
It("handles loss events", func() { It("handles loss events", func() {
rttMin := 100 * time.Millisecond rttMin := 100 * time.Millisecond
currentCwnd := 422 * protocol.DefaultTCPMSS currentCwnd := 422 * defaultTCPMSS
expectedCwnd := renoCwnd(currentCwnd) expectedCwnd := renoCwnd(currentCwnd)
// Initialize the state. // Initialize the state.
clock.Advance(time.Millisecond) clock.Advance(time.Millisecond)
Expect(cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now())).To(Equal(expectedCwnd)) Expect(cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())).To(Equal(expectedCwnd))
// On the first loss, the last max congestion window is set to the // On the first loss, the last max congestion window is set to the
// congestion window before the loss. // congestion window before the loss.
@ -199,7 +199,7 @@ var _ = Describe("Cubic", func() {
Expect(cubic.lastMaxCongestionWindow).To(Equal(expectedLastMax)) Expect(cubic.lastMaxCongestionWindow).To(Equal(expectedLastMax))
Expect(expectedCwnd).To(BeNumerically("<", cubic.lastMaxCongestionWindow)) Expect(expectedCwnd).To(BeNumerically("<", cubic.lastMaxCongestionWindow))
// Simulate an increase, and check that we are below the origin. // Simulate an increase, and check that we are below the origin.
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
Expect(cubic.lastMaxCongestionWindow).To(BeNumerically(">", currentCwnd)) Expect(cubic.lastMaxCongestionWindow).To(BeNumerically(">", currentCwnd))
// On the final loss, simulate the condition where the congestion // On the final loss, simulate the condition where the congestion
@ -215,21 +215,21 @@ var _ = Describe("Cubic", func() {
It("works below origin", func() { It("works below origin", func() {
// Concave growth. // Concave growth.
rttMin := 100 * time.Millisecond rttMin := 100 * time.Millisecond
currentCwnd := 422 * protocol.DefaultTCPMSS currentCwnd := 422 * defaultTCPMSS
expectedCwnd := renoCwnd(currentCwnd) expectedCwnd := renoCwnd(currentCwnd)
// Initialize the state. // Initialize the state.
clock.Advance(time.Millisecond) clock.Advance(time.Millisecond)
Expect(cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now())).To(Equal(expectedCwnd)) Expect(cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())).To(Equal(expectedCwnd))
expectedCwnd = protocol.ByteCount(float32(currentCwnd) * nConnectionBeta) expectedCwnd = protocol.ByteCount(float32(currentCwnd) * nConnectionBeta)
Expect(cubic.CongestionWindowAfterPacketLoss(currentCwnd)).To(Equal(expectedCwnd)) Expect(cubic.CongestionWindowAfterPacketLoss(currentCwnd)).To(Equal(expectedCwnd))
currentCwnd = expectedCwnd currentCwnd = expectedCwnd
// First update after loss to initialize the epoch. // First update after loss to initialize the epoch.
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
// Cubic phase. // Cubic phase.
for i := 0; i < 40; i++ { for i := 0; i < 40; i++ {
clock.Advance(100 * time.Millisecond) clock.Advance(100 * time.Millisecond)
currentCwnd = cubic.CongestionWindowAfterAck(protocol.DefaultTCPMSS, currentCwnd, rttMin, clock.Now()) currentCwnd = cubic.CongestionWindowAfterAck(defaultTCPMSS, currentCwnd, rttMin, clock.Now())
} }
expectedCwnd = 553632 expectedCwnd = 553632
Expect(currentCwnd).To(Equal(expectedCwnd)) Expect(currentCwnd).To(Equal(expectedCwnd))

4
internal/congestion/prr_sender.go
View file

@ -36,7 +36,7 @@ func (p *PrrSender) OnPacketAcked(ackedBytes protocol.ByteCount) {
// CanSend returns if packets can be sent // CanSend returns if packets can be sent
func (p *PrrSender) CanSend(congestionWindow, bytesInFlight, slowstartThreshold protocol.ByteCount) bool { func (p *PrrSender) CanSend(congestionWindow, bytesInFlight, slowstartThreshold protocol.ByteCount) bool {
// Return QuicTime::Zero In order to ensure limited transmit always works. // Return QuicTime::Zero In order to ensure limited transmit always works.
if p.bytesSentSinceLoss == 0 || bytesInFlight < protocol.DefaultTCPMSS { if p.bytesSentSinceLoss == 0 || bytesInFlight < defaultTCPMSS {
return true return true
} }
if congestionWindow > bytesInFlight { if congestionWindow > bytesInFlight {
@ -44,7 +44,7 @@ func (p *PrrSender) CanSend(congestionWindow, bytesInFlight, slowstartThreshold
// of sending the entire available window. This prevents burst retransmits // of sending the entire available window. This prevents burst retransmits
// when more packets are lost than the CWND reduction. // when more packets are lost than the CWND reduction.
// limit = MAX(prr_delivered - prr_out, DeliveredData) + MSS // limit = MAX(prr_delivered - prr_out, DeliveredData) + MSS
return p.bytesDeliveredSinceLoss+p.ackCountSinceLoss*protocol.DefaultTCPMSS > p.bytesSentSinceLoss return p.bytesDeliveredSinceLoss+p.ackCountSinceLoss*defaultTCPMSS > p.bytesSentSinceLoss
} }
// Implement Proportional Rate Reduction (RFC6937). // Implement Proportional Rate Reduction (RFC6937).
// Checks a simplified version of the PRR formula that doesn't use division: // Checks a simplified version of the PRR formula that doesn't use division:

70
internal/congestion/prr_sender_test.go
View file

@ -18,35 +18,35 @@ var _ = Describe("PRR sender", func() {
It("single loss results in send on every other ack", func() { It("single loss results in send on every other ack", func() {
numPacketsInFlight := protocol.ByteCount(50) numPacketsInFlight := protocol.ByteCount(50)
bytesInFlight := numPacketsInFlight * protocol.DefaultTCPMSS bytesInFlight := numPacketsInFlight * defaultTCPMSS
sshthreshAfterLoss := numPacketsInFlight / 2 sshthreshAfterLoss := numPacketsInFlight / 2
congestionWindow := sshthreshAfterLoss * protocol.DefaultTCPMSS congestionWindow := sshthreshAfterLoss * defaultTCPMSS
prr.OnPacketLost(bytesInFlight) prr.OnPacketLost(bytesInFlight)
// Ack a packet. PRR allows one packet to leave immediately. // Ack a packet. PRR allows one packet to leave immediately.
prr.OnPacketAcked(protocol.DefaultTCPMSS) prr.OnPacketAcked(defaultTCPMSS)
bytesInFlight -= protocol.DefaultTCPMSS bytesInFlight -= defaultTCPMSS
Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeTrue()) Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*defaultTCPMSS)).To(BeTrue())
// Send retransmission. // Send retransmission.
prr.OnPacketSent(protocol.DefaultTCPMSS) prr.OnPacketSent(defaultTCPMSS)
// PRR shouldn't allow sending any more packets. // PRR shouldn't allow sending any more packets.
Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeFalse()) Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*defaultTCPMSS)).To(BeFalse())
// One packet is lost, and one ack was consumed above. PRR now paces // One packet is lost, and one ack was consumed above. PRR now paces
// transmissions through the remaining 48 acks. PRR will alternatively // transmissions through the remaining 48 acks. PRR will alternatively
// disallow and allow a packet to be sent in response to an ack. // disallow and allow a packet to be sent in response to an ack.
for i := protocol.ByteCount(0); i < sshthreshAfterLoss-1; i++ { for i := protocol.ByteCount(0); i < sshthreshAfterLoss-1; i++ {
// Ack a packet. PRR shouldn't allow sending a packet in response. // Ack a packet. PRR shouldn't allow sending a packet in response.
prr.OnPacketAcked(protocol.DefaultTCPMSS) prr.OnPacketAcked(defaultTCPMSS)
bytesInFlight -= protocol.DefaultTCPMSS bytesInFlight -= defaultTCPMSS
Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeFalse()) Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*defaultTCPMSS)).To(BeFalse())
// Ack another packet. PRR should now allow sending a packet in response. // Ack another packet. PRR should now allow sending a packet in response.
prr.OnPacketAcked(protocol.DefaultTCPMSS) prr.OnPacketAcked(defaultTCPMSS)
bytesInFlight -= protocol.DefaultTCPMSS bytesInFlight -= defaultTCPMSS
Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeTrue()) Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*defaultTCPMSS)).To(BeTrue())
// Send a packet in response. // Send a packet in response.
prr.OnPacketSent(protocol.DefaultTCPMSS) prr.OnPacketSent(defaultTCPMSS)
bytesInFlight += protocol.DefaultTCPMSS bytesInFlight += defaultTCPMSS
} }
// Since bytes_in_flight is now equal to congestion_window, PRR now maintains // Since bytes_in_flight is now equal to congestion_window, PRR now maintains
@ -54,54 +54,54 @@ var _ = Describe("PRR sender", func() {
Expect(bytesInFlight).To(Equal(congestionWindow)) Expect(bytesInFlight).To(Equal(congestionWindow))
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
// Ack a packet. // Ack a packet.
prr.OnPacketAcked(protocol.DefaultTCPMSS) prr.OnPacketAcked(defaultTCPMSS)
bytesInFlight -= protocol.DefaultTCPMSS bytesInFlight -= defaultTCPMSS
Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeTrue()) Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*defaultTCPMSS)).To(BeTrue())
// Send a packet in response, since PRR allows it. // Send a packet in response, since PRR allows it.
prr.OnPacketSent(protocol.DefaultTCPMSS) prr.OnPacketSent(defaultTCPMSS)
bytesInFlight += protocol.DefaultTCPMSS bytesInFlight += defaultTCPMSS
// Since bytes_in_flight is equal to the congestion_window, // Since bytes_in_flight is equal to the congestion_window,
// PRR disallows sending. // PRR disallows sending.
Expect(bytesInFlight).To(Equal(congestionWindow)) Expect(bytesInFlight).To(Equal(congestionWindow))
Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeFalse()) Expect(prr.CanSend(congestionWindow, bytesInFlight, sshthreshAfterLoss*defaultTCPMSS)).To(BeFalse())
} }
}) })
It("burst loss results in slow start", func() { It("burst loss results in slow start", func() {
bytesInFlight := 20 * protocol.DefaultTCPMSS bytesInFlight := 20 * defaultTCPMSS
const numPacketsLost = 13 const numPacketsLost = 13
const ssthreshAfterLoss = 10 const ssthreshAfterLoss = 10
const congestionWindow = ssthreshAfterLoss * protocol.DefaultTCPMSS const congestionWindow = ssthreshAfterLoss * defaultTCPMSS
// Lose 13 packets. // Lose 13 packets.
bytesInFlight -= numPacketsLost * protocol.DefaultTCPMSS bytesInFlight -= numPacketsLost * defaultTCPMSS
prr.OnPacketLost(bytesInFlight) prr.OnPacketLost(bytesInFlight)
// PRR-SSRB will allow the following 3 acks to send up to 2 packets. // PRR-SSRB will allow the following 3 acks to send up to 2 packets.
for i := 0; i < 3; i++ { for i := 0; i < 3; i++ {
prr.OnPacketAcked(protocol.DefaultTCPMSS) prr.OnPacketAcked(defaultTCPMSS)
bytesInFlight -= protocol.DefaultTCPMSS bytesInFlight -= defaultTCPMSS
// PRR-SSRB should allow two packets to be sent. // PRR-SSRB should allow two packets to be sent.
for j := 0; j < 2; j++ { for j := 0; j < 2; j++ {
Expect(prr.CanSend(congestionWindow, bytesInFlight, ssthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeTrue()) Expect(prr.CanSend(congestionWindow, bytesInFlight, ssthreshAfterLoss*defaultTCPMSS)).To(BeTrue())
// Send a packet in response. // Send a packet in response.
prr.OnPacketSent(protocol.DefaultTCPMSS) prr.OnPacketSent(defaultTCPMSS)
bytesInFlight += protocol.DefaultTCPMSS bytesInFlight += defaultTCPMSS
} }
// PRR should allow no more than 2 packets in response to an ack. // PRR should allow no more than 2 packets in response to an ack.
Expect(prr.CanSend(congestionWindow, bytesInFlight, ssthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeFalse()) Expect(prr.CanSend(congestionWindow, bytesInFlight, ssthreshAfterLoss*defaultTCPMSS)).To(BeFalse())
} }
// Out of SSRB mode, PRR allows one send in response to each ack. // Out of SSRB mode, PRR allows one send in response to each ack.
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
prr.OnPacketAcked(protocol.DefaultTCPMSS) prr.OnPacketAcked(defaultTCPMSS)
bytesInFlight -= protocol.DefaultTCPMSS bytesInFlight -= defaultTCPMSS
Expect(prr.CanSend(congestionWindow, bytesInFlight, ssthreshAfterLoss*protocol.DefaultTCPMSS)).To(BeTrue()) Expect(prr.CanSend(congestionWindow, bytesInFlight, ssthreshAfterLoss*defaultTCPMSS)).To(BeTrue())
// Send a packet in response. // Send a packet in response.
prr.OnPacketSent(protocol.DefaultTCPMSS) prr.OnPacketSent(defaultTCPMSS)
bytesInFlight += protocol.DefaultTCPMSS bytesInFlight += defaultTCPMSS
} }
}) })
}) })

13
internal/protocol/params.go
View file

@ -8,13 +8,8 @@ const MaxPacketSizeIPv4 = 1252
// MaxPacketSizeIPv6 is the maximum packet size that we use for sending IPv6 packets. // MaxPacketSizeIPv6 is the maximum packet size that we use for sending IPv6 packets.
const MaxPacketSizeIPv6 = 1232 const MaxPacketSizeIPv6 = 1232
const defaultMaxCongestionWindowPackets = 10000 // MaxCongestionWindowPackets is the maximum congestion window in packet.
const MaxCongestionWindowPackets = 10000
// DefaultMaxCongestionWindow is the default for the max congestion window
const DefaultMaxCongestionWindow ByteCount = defaultMaxCongestionWindowPackets * DefaultTCPMSS
// InitialCongestionWindow is the initial congestion window in QUIC packets
const InitialCongestionWindow ByteCount = 32 * DefaultTCPMSS
// MaxUndecryptablePackets limits the number of undecryptable packets that are queued in the session. // MaxUndecryptablePackets limits the number of undecryptable packets that are queued in the session.
const MaxUndecryptablePackets = 10 const MaxUndecryptablePackets = 10
@ -45,7 +40,7 @@ const DefaultMaxIncomingStreams = 100
const DefaultMaxIncomingUniStreams = 100 const DefaultMaxIncomingUniStreams = 100
// MaxSessionUnprocessedPackets is the max number of packets stored in each session that are not yet processed. // MaxSessionUnprocessedPackets is the max number of packets stored in each session that are not yet processed.
const MaxSessionUnprocessedPackets = defaultMaxCongestionWindowPackets const MaxSessionUnprocessedPackets = MaxCongestionWindowPackets
// SkipPacketAveragePeriodLength is the average period length in which one packet number is skipped to prevent an Optimistic ACK attack // SkipPacketAveragePeriodLength is the average period length in which one packet number is skipped to prevent an Optimistic ACK attack
const SkipPacketAveragePeriodLength PacketNumber = 500 const SkipPacketAveragePeriodLength PacketNumber = 500
@ -66,7 +61,7 @@ const RetryTokenValidity = 10 * time.Second
// MaxOutstandingSentPackets is maximum number of packets saved for retransmission. // MaxOutstandingSentPackets is maximum number of packets saved for retransmission.
// When reached, it imposes a soft limit on sending new packets: // When reached, it imposes a soft limit on sending new packets:
// Sending ACKs and retransmission is still allowed, but now new regular packets can be sent. // Sending ACKs and retransmission is still allowed, but now new regular packets can be sent.
const MaxOutstandingSentPackets = 2 * defaultMaxCongestionWindowPackets const MaxOutstandingSentPackets = 2 * MaxCongestionWindowPackets
// MaxTrackedSentPackets is maximum number of sent packets saved for retransmission. // MaxTrackedSentPackets is maximum number of sent packets saved for retransmission.
// When reached, no more packets will be sent. // When reached, no more packets will be sent.

4
internal/protocol/protocol.go
View file

@ -49,10 +49,6 @@ type ApplicationErrorCode uint64
// Ethernet's max packet size is 1500 bytes, 1500 - 48 = 1452. // Ethernet's max packet size is 1500 bytes, 1500 - 48 = 1452.
const MaxReceivePacketSize ByteCount = 1452 const MaxReceivePacketSize ByteCount = 1452
// DefaultTCPMSS is the default maximum packet size used in the Linux TCP implementation.
// Used in QUIC for congestion window computations in bytes.
const DefaultTCPMSS ByteCount = 1460
// MinInitialPacketSize is the minimum size an Initial packet is required to have. // MinInitialPacketSize is the minimum size an Initial packet is required to have.
const MinInitialPacketSize = 1200 const MinInitialPacketSize = 1200