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

remove StopWaitingManager from new AckHandler

Browse source
This commit is contained in:
Marten Seemann 2016-07-29 17:23:03 +07:00
parent 459a8ff324
commit 73a64fde5f
5 changed files with 18 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

6
ackhandler/sent_packet_handler.go
View file

@ -38,7 +38,6 @@ type sentPacketHandler struct {
packetHistory map[protocol.PacketNumber]*ackhandlerlegacy.Packet
retransmissionQueue []*ackhandlerlegacy.Packet
stopWaitingManager StopWaitingManager
bytesInFlight protocol.ByteCount
@ -47,7 +46,7 @@ type sentPacketHandler struct {
}
// NewSentPacketHandler creates a new sentPacketHandler
func NewSentPacketHandler(stopWaitingManager StopWaitingManager) SentPacketHandler {
func NewSentPacketHandler() SentPacketHandler {
rttStats := &congestion.RTTStats{}
congestion := congestion.NewCubicSender(
@ -60,7 +59,6 @@ func NewSentPacketHandler(stopWaitingManager StopWaitingManager) SentPacketHandl
return &sentPacketHandler{
packetHistory: make(map[protocol.PacketNumber]*ackhandlerlegacy.Packet),
stopWaitingManager: stopWaitingManager,
rttStats: rttStats,
congestion: congestion,
}
@ -78,8 +76,6 @@ func (h *sentPacketHandler) ackPacket(packetNumber protocol.PacketNumber) *ackha
delete(h.packetHistory, packetNumber)
h.stopWaitingManager.ReceivedAckForPacketNumber(packetNumber)
return packet
}

23
ackhandler/sent_packet_handler_test.go
View file

@ -51,21 +51,6 @@ func (m *mockCongestion) SetNumEmulatedConnections(n int) { panic("not i
func (m *mockCongestion) OnConnectionMigration() { panic("not implemented") }
func (m *mockCongestion) SetSlowStartLargeReduction(enabled bool) { panic("not implemented") }
type mockStopWaiting struct {
receivedAckForPacketNumber protocol.PacketNumber
}
func (m *mockStopWaiting) RegisterPacketForRetransmission(packet *ackhandlerlegacy.Packet) {
panic("not implemented")
}
func (m *mockStopWaiting) GetStopWaitingFrame() *frames.StopWaitingFrame { panic("not implemented") }
func (m *mockStopWaiting) SentStopWaitingWithPacket(packetNumber protocol.PacketNumber) {
panic("not implemented")
}
func (m *mockStopWaiting) ReceivedAckForPacketNumber(packetNumber protocol.PacketNumber) {
m.receivedAckForPacketNumber = packetNumber
}
var _ = Describe("SentPacketHandler", func() {
var (
handler *sentPacketHandler
@ -73,19 +58,13 @@ var _ = Describe("SentPacketHandler", func() {
)
BeforeEach(func() {
stopWaitingManager := &mockStopWaiting{}
handler = NewSentPacketHandler(stopWaitingManager).(*sentPacketHandler)
handler = NewSentPacketHandler().(*sentPacketHandler)
streamFrame = frames.StreamFrame{
StreamID: 5,
Data: []byte{0x13, 0x37},
}
})
It("informs the StopWaitingManager about ACKs received", func() {
handler.ackPacket(2)
Expect(handler.stopWaitingManager.(*mockStopWaiting).receivedAckForPacketNumber).To(Equal(protocol.PacketNumber(2)))
})
It("gets the LargestAcked packet number", func() {
handler.LargestAcked = 0x1337
Expect(handler.GetLargestAcked()).To(Equal(protocol.PacketNumber(0x1337)))

58
ackhandler/stop_waiting_manager.go
View file

@ -1,58 +0,0 @@
package ackhandler
import (
"github.com/lucas-clemente/quic-go/ackhandlerlegacy"
"github.com/lucas-clemente/quic-go/frames"
"github.com/lucas-clemente/quic-go/protocol"
)
// StopWaitingManager manages StopWaitingFrames
type stopWaitingManager struct {
// sentStopWaitings map[protocol.PacketNumber]protocol.PacketNumber // map[LeastUnacked]stopWaitingSentWithPacketNumber
lastNewStopWaitingFirstSentWithPacketNumber protocol.PacketNumber
maxRetransmittedPacketNumber protocol.PacketNumber
currentStopWaitingFrame *frames.StopWaitingFrame
currentStopWaitingFrameSent bool
}
// NewStopWaitingManager creates a new StopWaitingManager
func NewStopWaitingManager() StopWaitingManager {
return &stopWaitingManager{
currentStopWaitingFrame: nil,
}
}
// RegisterPacketForRetransmission prepares the StopWaitingFrame, if necessary
func (h *stopWaitingManager) RegisterPacketForRetransmission(packet *ackhandlerlegacy.Packet) {
// out-of-order retransmission. A StopWaitingFrame with a higher LeastUnacked was already queued (or sent in the past), no need to send another one again
if packet.PacketNumber < h.maxRetransmittedPacketNumber {
return
}
if h.currentStopWaitingFrame == nil || h.currentStopWaitingFrame.LeastUnacked <= packet.PacketNumber { // <= because for StopWaitingFrames LeastUnacked = packet.PacketNumber + 1
h.currentStopWaitingFrame = &frames.StopWaitingFrame{
LeastUnacked: packet.PacketNumber + 1,
}
h.maxRetransmittedPacketNumber = packet.PacketNumber
h.currentStopWaitingFrameSent = false
}
}
// GetStopWaitingFrame gets the StopWaitingFrame that needs to be sent. It returns nil if no StopWaitingFrame needs to be sent
func (h *stopWaitingManager) GetStopWaitingFrame() *frames.StopWaitingFrame {
return h.currentStopWaitingFrame
}
// SentStopWaitingWithPacket must be called after sending out a StopWaitingFrame with a packet
func (h *stopWaitingManager) SentStopWaitingWithPacket(packetNumber protocol.PacketNumber) {
if !h.currentStopWaitingFrameSent {
h.lastNewStopWaitingFirstSentWithPacketNumber = packetNumber
}
h.currentStopWaitingFrameSent = true
}
// ReceivedAckForPacketNumber should be called after receiving an ACK
func (h *stopWaitingManager) ReceivedAckForPacketNumber(packetNumber protocol.PacketNumber) {
if packetNumber >= h.lastNewStopWaitingFirstSentWithPacketNumber {
h.currentStopWaitingFrame = nil
}
}

85
ackhandler/stop_waiting_manager_test.go
View file

@ -1,85 +0,0 @@
package ackhandler
import (
"github.com/lucas-clemente/quic-go/ackhandlerlegacy"
"github.com/lucas-clemente/quic-go/protocol"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("StopWaitingManager", func() {
var manager *stopWaitingManager
BeforeEach(func() {
manager = NewStopWaitingManager().(*stopWaitingManager)
})
It("returns nil in the beginning", func() {
Expect(manager.GetStopWaitingFrame()).To(BeNil())
})
It("gets a StopWaitingFrame after a packet has been registered for retransmission", func() {
leastUnacked := protocol.PacketNumber(10)
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
swf := manager.GetStopWaitingFrame()
Expect(swf).ToNot(BeNil())
Expect(swf.LeastUnacked).To(Equal(leastUnacked + 1))
})
It("always gets the StopWaitingFrame for the highest retransmitted packet number", func() {
leastUnacked := protocol.PacketNumber(10)
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked - 1})
swf := manager.GetStopWaitingFrame()
Expect(swf).ToNot(BeNil())
Expect(swf.LeastUnacked).To(Equal(leastUnacked + 1))
})
It("updates the StopWaitingFrame when a packet with a higher packet number is retransmitted", func() {
leastUnacked := protocol.PacketNumber(10)
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked - 1})
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
swf := manager.GetStopWaitingFrame()
Expect(swf).ToNot(BeNil())
Expect(swf.LeastUnacked).To(Equal(leastUnacked + 1))
})
It("does not create a new StopWaitingFrame for an out-of-order retransmission", func() {
leastUnacked := protocol.PacketNumber(10)
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked})
manager.SentStopWaitingWithPacket(12)
manager.ReceivedAckForPacketNumber(12)
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: leastUnacked - 1})
swf := manager.GetStopWaitingFrame()
Expect(swf).To(BeNil())
})
Context("ACK handling", func() {
It("removes the current StopWaitingFrame when the first packet it was sent with is ACKed", func() {
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: 10})
manager.SentStopWaitingWithPacket(13)
manager.SentStopWaitingWithPacket(14)
manager.SentStopWaitingWithPacket(15)
Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
manager.ReceivedAckForPacketNumber(13)
Expect(manager.GetStopWaitingFrame()).To(BeNil())
})
It("removes the current StopWaitingFrame when any packet it was sent with is ACKed", func() {
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: 10})
manager.SentStopWaitingWithPacket(13)
manager.SentStopWaitingWithPacket(14)
manager.SentStopWaitingWithPacket(15)
Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
manager.ReceivedAckForPacketNumber(14)
Expect(manager.GetStopWaitingFrame()).To(BeNil())
})
It("does not remove the current StopWaitingFrame when a packet before the one containing the StopWaitingFrame is ACKed", func() {
manager.RegisterPacketForRetransmission(&ackhandlerlegacy.Packet{PacketNumber: 10})
manager.SentStopWaitingWithPacket(13)
Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
manager.ReceivedAckForPacketNumber(12)
Expect(manager.GetStopWaitingFrame()).ToNot(BeNil())
})
})
})

14
session.go
View file

@ -104,8 +104,7 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol
sentPacketHandler = ackhandlerlegacy.NewSentPacketHandler(stopWaitingManager).(ackhandler.SentPacketHandler)
receivedPacketHandler = ackhandlerlegacy.NewReceivedPacketHandler().(ackhandler.ReceivedPacketHandler)
} else {
stopWaitingManager = ackhandler.NewStopWaitingManager()
sentPacketHandler = ackhandler.NewSentPacketHandler(stopWaitingManager)
sentPacketHandler = ackhandler.NewSentPacketHandler()
receivedPacketHandler = ackhandler.NewReceivedPacketHandler()
}
@ -480,7 +479,10 @@ func (s *Session) sendPacket() error {
break
}
utils.Debugf("\tDequeueing retransmission for packet 0x%x", retransmitPacket.PacketNumber)
if s.version <= protocol.Version33 {
s.stopWaitingManager.RegisterPacketForRetransmission(retransmitPacket)
}
// resend the frames that were in the packet
controlFrames = append(controlFrames, retransmitPacket.GetControlFramesForRetransmission()...)
for _, streamFrame := range retransmitPacket.GetStreamFramesForRetransmission() {
@ -508,7 +510,10 @@ func (s *Session) sendPacket() error {
// Check whether we are allowed to send a packet containing only an ACK
maySendOnlyAck := time.Now().Sub(s.delayedAckOriginTime) > protocol.AckSendDelay
stopWaitingFrame := s.stopWaitingManager.GetStopWaitingFrame()
var stopWaitingFrame *frames.StopWaitingFrame
if s.version <= protocol.Version33 {
stopWaitingFrame = s.stopWaitingManager.GetStopWaitingFrame()
}
packet, err := s.packer.PackPacket(stopWaitingFrame, controlFrames, s.sentPacketHandler.GetLargestAcked(), maySendOnlyAck)
if err != nil {
return err
@ -536,7 +541,10 @@ func (s *Session) sendPacket() error {
if err != nil {
return err
}
if s.version <= protocol.Version33 {
s.stopWaitingManager.SentStopWaitingWithPacket(packet.number)
}
s.logPacket(packet)
s.delayedAckOriginTime = time.Time{}