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

keep track of highest in order received packet number

Browse Source
This commit is contained in:
Marten Seemann
2016-04-22 17:32:45 +07:00
parent 62a844d326
commit aad1fd2ee7
2 changed files with 131 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
ackhandler/incoming_packet_ack_handler.go
View File

@@ -11,14 +11,15 @@ var ErrDuplicatePacket = errors.New("Duplicate Packet")
// The AckHandler handles ACKs
type incomingPacketAckHandler struct {
highestInOrderObserved protocol.PacketNumber
largestObserved protocol.PacketNumber
observed map[protocol.PacketNumber]bool
packetHistory map[protocol.PacketNumber]bool
}
// NewIncomingPacketAckHandler creates a new outgoingPacketAckHandler
func NewIncomingPacketAckHandler() IncomingPacketAckHandler {
return &incomingPacketAckHandler{
observed: make(map[protocol.PacketNumber]bool),
packetHistory: make(map[protocol.PacketNumber]bool),
}
}
@@ -26,14 +27,19 @@ func (h *incomingPacketAckHandler) ReceivedPacket(packetNumber protocol.PacketNu
if packetNumber == 0 {
return errors.New("Invalid packet number")
}
if h.observed[packetNumber] {
if packetNumber <= h.highestInOrderObserved || h.packetHistory[packetNumber] {
return ErrDuplicatePacket
}
if packetNumber > h.largestObserved {
h.largestObserved = packetNumber
}
h.observed[packetNumber] = true
if packetNumber == h.highestInOrderObserved+1 {
h.highestInOrderObserved = packetNumber
}
h.packetHistory[packetNumber] = true
return nil
}
@@ -42,8 +48,8 @@ func (h *incomingPacketAckHandler) getNackRanges() []frames.NackRange {
// ToDo: improve performance
var ranges []frames.NackRange
inRange := false
for i := protocol.PacketNumber(1); i < h.largestObserved; i++ {
_, ok := h.observed[i]
for i := h.highestInOrderObserved; i < h.largestObserved; i++ {
_, ok := h.packetHistory[i]
if !ok {
if !inRange {
r := frames.NackRange{
@@ -63,5 +69,11 @@ func (h *incomingPacketAckHandler) getNackRanges() []frames.NackRange {
}
func (h *incomingPacketAckHandler) DequeueAckFrame() *frames.AckFrame {
return nil
nackRanges := h.getNackRanges()
entropy := byte(0)
return &frames.AckFrame{
LargestObserved: h.largestObserved,
Entropy: entropy,
NackRanges: nackRanges,
}
}

156
ackhandler/incoming_packet_ack_handler_test.go
View File

@@ -14,75 +14,7 @@ var _ = Describe("incomingPacketAckHandler", func() {
handler = NewIncomingPacketAckHandler().(*incomingPacketAckHandler)
})
It("Returns no NACK ranges for continously received packets", func() {
for i := 1; i < 100; i++ {
err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
Expect(err).ToNot(HaveOccurred())
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(99)))
Expect(len(handler.getNackRanges())).To(Equal(0))
})
It("handles a single lost package", func() {
for i := 1; i < 10; i++ {
if i == 5 {
continue
}
handler.ReceivedPacket(protocol.PacketNumber(i), false)
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(1))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(5)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(5)))
})
It("handles two consecutive lost packages", func() {
for i := 1; i < 10; i++ {
if i == 5 || i == 6 {
continue
}
handler.ReceivedPacket(protocol.PacketNumber(i), false)
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(1))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(5)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(6)))
})
It("handles two non-consecutively lost packages", func() {
for i := 1; i < 10; i++ {
if i == 3 || i == 7 {
continue
}
handler.ReceivedPacket(protocol.PacketNumber(i), false)
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(2))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(3)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(3)))
Expect(nackRanges[1].FirstPacketNumber).To(Equal(protocol.PacketNumber(7)))
Expect(nackRanges[1].LastPacketNumber).To(Equal(protocol.PacketNumber(7)))
})
It("handles two sequences of lost packages", func() {
for i := 1; i < 10; i++ {
if i == 2 || i == 3 || i == 4 || i == 7 || i == 8 {
continue
}
handler.ReceivedPacket(protocol.PacketNumber(i), false)
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(2))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(2)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(4)))
Expect(nackRanges[1].FirstPacketNumber).To(Equal(protocol.PacketNumber(7)))
Expect(nackRanges[1].LastPacketNumber).To(Equal(protocol.PacketNumber(8)))
})
Context("accepting and rejecting packets", func() {
It("handles a packet that arrives late", func() {
err := handler.ReceivedPacket(protocol.PacketNumber(1), false)
Expect(err).ToNot(HaveOccurred())
@@ -113,5 +45,89 @@ var _ = Describe("incomingPacketAckHandler", func() {
Expect(err).To(HaveOccurred())
Expect(err).To(Equal(ErrDuplicatePacket))
})
})
Context("Entropy calculation", func() {
// It("calculates the entropy f")
})
Context("NACK range calculation", func() {
It("Returns no NACK ranges for continously received packets", func() {
for i := 1; i < 100; i++ {
err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
Expect(err).ToNot(HaveOccurred())
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(99)))
Expect(handler.highestInOrderObserved).To(Equal(protocol.PacketNumber(99)))
Expect(len(handler.getNackRanges())).To(Equal(0))
})
It("handles a single lost package", func() {
for i := 1; i < 10; i++ {
if i == 5 {
continue
}
err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
Expect(err).ToNot(HaveOccurred())
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(1))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(5)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(5)))
Expect(handler.highestInOrderObserved).To(Equal(protocol.PacketNumber(4)))
})
It("handles two consecutive lost packages", func() {
for i := 1; i < 10; i++ {
if i == 5 || i == 6 {
continue
}
err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
Expect(err).ToNot(HaveOccurred())
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(1))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(5)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(6)))
Expect(handler.highestInOrderObserved).To(Equal(protocol.PacketNumber(4)))
})
It("handles two non-consecutively lost packages", func() {
for i := 1; i < 10; i++ {
if i == 3 || i == 7 {
continue
}
err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
Expect(err).ToNot(HaveOccurred())
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(2))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(3)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(3)))
Expect(nackRanges[1].FirstPacketNumber).To(Equal(protocol.PacketNumber(7)))
Expect(nackRanges[1].LastPacketNumber).To(Equal(protocol.PacketNumber(7)))
Expect(handler.highestInOrderObserved).To(Equal(protocol.PacketNumber(2)))
})
It("handles two sequences of lost packages", func() {
for i := 1; i < 10; i++ {
if i == 2 || i == 3 || i == 4 || i == 7 || i == 8 {
continue
}
err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
Expect(err).ToNot(HaveOccurred())
}
Expect(handler.largestObserved).To(Equal(protocol.PacketNumber(9)))
nackRanges := handler.getNackRanges()
Expect(len(nackRanges)).To(Equal(2))
Expect(nackRanges[0].FirstPacketNumber).To(Equal(protocol.PacketNumber(2)))
Expect(nackRanges[0].LastPacketNumber).To(Equal(protocol.PacketNumber(4)))
Expect(nackRanges[1].FirstPacketNumber).To(Equal(protocol.PacketNumber(7)))
Expect(nackRanges[1].LastPacketNumber).To(Equal(protocol.PacketNumber(8)))
Expect(handler.highestInOrderObserved).To(Equal(protocol.PacketNumber(1)))
})
})
})