Improve memory efficiency

Refactored packet processing to avoid multiple make calls and
eliminate append usage. This reduces garbage collection overhead
and enhances overall memory management efficiency.

Author: arjunshajitech

pkg/nack/generator_interceptor.go

@@ -145,6 +145,9 @@ func (n *GeneratorInterceptor) loop(rtcpWriter interceptor.RTCPWriter) {
 
 	senderSSRC := rand.Uint32() // #nosec
 
+	missingPacketSeqNums := make([]uint16, n.size)
+	filteredMissingPacket := make([]uint16, n.size)
+
 	ticker := time.NewTicker(n.interval)
 	defer ticker.Stop()
 	for {
@@ -155,7 +158,7 @@ func (n *GeneratorInterceptor) loop(rtcpWriter interceptor.RTCPWriter) {
 				defer n.receiveLogsMu.Unlock()
 
 				for ssrc, receiveLog := range n.receiveLogs {
-					missing := receiveLog.missingSeqNumbers(n.skipLastN)
+					missing := receiveLog.missingSeqNumbers(n.skipLastN, missingPacketSeqNums)
 
 					if len(missing) == 0 || n.nackCountLogs[ssrc] == nil {
 						n.nackCountLogs[ssrc] = map[uint16]uint16{}
@@ -164,22 +167,33 @@ func (n *GeneratorInterceptor) loop(rtcpWriter interceptor.RTCPWriter) {
 						continue
 					}
 
-					filteredMissing := []uint16{}
+					nack := &rtcp.TransportLayerNack{} // nolint:ineffassign,wastedassign
+
+					c := 0 // nolint:varnamelen,
 					if n.maxNacksPerPacket > 0 {
 						for _, missingSeq := range missing {
 							if n.nackCountLogs[ssrc][missingSeq] < n.maxNacksPerPacket {
-								filteredMissing = append(filteredMissing, missingSeq)
+								filteredMissingPacket[c] = missingSeq
+								c++
 							}
 							n.nackCountLogs[ssrc][missingSeq]++
 						}
-					} else {
-						filteredMissing = missing
-					}
 
-					nack := &rtcp.TransportLayerNack{
-						SenderSSRC: senderSSRC,
-						MediaSSRC:  ssrc,
-						Nacks:      rtcp.NackPairsFromSequenceNumbers(filteredMissing),
+						if c == 0 {
+							continue
+						}
+
+						nack = &rtcp.TransportLayerNack{
+							SenderSSRC: senderSSRC,
+							MediaSSRC:  ssrc,
+							Nacks:      rtcp.NackPairsFromSequenceNumbers(filteredMissingPacket[:c]),
+						}
+					} else {
+						nack = &rtcp.TransportLayerNack{
+							SenderSSRC: senderSSRC,
+							MediaSSRC:  ssrc,
+							Nacks:      rtcp.NackPairsFromSequenceNumbers(missing),
+						}
 					}
 
 					for nackSeq := range n.nackCountLogs[ssrc] {
@@ -196,10 +210,6 @@ func (n *GeneratorInterceptor) loop(rtcpWriter interceptor.RTCPWriter) {
 						}
 					}
 
-					if len(filteredMissing) == 0 {
-						continue
-					}
-
 					if _, err := rtcpWriter.Write([]rtcp.Packet{nack}, interceptor.Attributes{}); err != nil {
 						n.log.Warnf("failed sending nack: %+v", err)
 					}

pkg/nack/generator_interceptor_test.go

@@ -20,6 +20,7 @@ func TestGeneratorInterceptor(t *testing.T) {
 	f, err := NewGeneratorInterceptor(
 		GeneratorSize(64),
 		GeneratorSkipLastN(2),
+		GeneratorMaxNacksPerPacket(10),
 		GeneratorInterval(interval),
 		GeneratorLog(logging.NewDefaultLoggerFactory().NewLogger("test")),
 	)

pkg/nack/receive_log.go

@@ -97,7 +97,7 @@ func (s *receiveLog) get(seq uint16) bool {
 	return s.getReceived(seq)
 }
 
-func (s *receiveLog) missingSeqNumbers(skipLastN uint16) []uint16 {
+func (s *receiveLog) missingSeqNumbers(skipLastN uint16, missingPacketSeqNums []uint16) []uint16 {
 	s.m.RLock()
 	defer s.m.RUnlock()
 
@@ -107,14 +107,15 @@ func (s *receiveLog) missingSeqNumbers(skipLastN uint16) []uint16 {
 		return nil
 	}
 
-	missingPacketSeqNums := make([]uint16, 0)
+	c := 0
 	for i := s.lastConsecutive + 1; i != until+1; i++ {
 		if !s.getReceived(i) {
-			missingPacketSeqNums = append(missingPacketSeqNums, i)
+			missingPacketSeqNums[c] = i
+			c++
 		}
 	}
 
-	return missingPacketSeqNums
+	return missingPacketSeqNums[:c]
 }
 
 func (s *receiveLog) setReceived(seq uint16) {

pkg/nack/receive_log_test.go

@@ -61,7 +61,8 @@ func TestReceivedBuffer(t *testing.T) {
 			}
 			assertMissing := func(skipLastN uint16, nums []uint16) {
 				t.Helper()
-				missing := rl.missingSeqNumbers(skipLastN)
+				missingPacketSeqNums := make([]uint16, rl.size)
+				missing := rl.missingSeqNumbers(skipLastN, missingPacketSeqNums)
 				if missing == nil {
 					missing = []uint16{}
 				}
@@ -131,6 +132,24 @@ func TestReceivedBuffer(t *testing.T) {
 			assertGet(321)
 			assertMissing(0, all(330, 332))
 			assertLastConsecutive(329) // after adding a single missing packet, lastConsecutive should jump forward
+
+			add(all(330, 332)...)
+			assertMissing(0, []uint16{})
+			assertLastConsecutive(334)
+
+			// Add a packet beyond the current missing range to trigger buffer overflow behavior.
+			// Ensure that when the number of missing packets exceeds the buffer size,
+			// only the latest (rl.size - 1) entries are considered for NACKs.
+			add(466)
+			assertGet(466)
+
+			missing := all(335, 465)
+			if len(missing) > int(rl.size) {
+				assertLastConsecutive(missing[len(missing)-int(rl.size)])
+				assertMissing(0, missing[len(missing)-(int(rl.size-1)):])
+			} else {
+				assertMissing(0, all(335, 465))
+			}
 		})
 	}
 }