[WIP] malloc optimizations

dv/dv/table_algo.go

@@ -108,22 +108,24 @@ func (dv *Router) fibUpdate() {
 
 	// Update paths to all routers from RIB
 	for _, router := range dv.rib.Entries() {
+		routerName := router.Name()
+
 		// Skip if this is us
-		if router.Name().Equal(dv.config.RouterName()) {
+		if routerName.Equal(dv.config.RouterName()) {
 			continue
 		}
 
 		// Get FIB entry to reach this router
-		fes := dv.rib.GetFibEntries(dv.neighbors, router.Name().Hash())
+		fes := dv.rib.GetFibEntries(dv.neighbors, routerName.Hash())
 
 		// Add entry to the router itself
-		routerPrefix := append(router.Name(),
+		routerPrefix := append(routerName,
 			enc.NewStringComponent(enc.TypeKeywordNameComponent, "DV"),
 		)
 		register(routerPrefix, fes)
 
 		// Add entries to all prefixes announced by this router
-		for _, prefix := range dv.pfx.GetRouter(router.Name()).Prefixes {
+		for _, prefix := range dv.pfx.GetRouter(routerName).Prefixes {
 			// Use the same nexthop entries as the exit router itself
 			// De-duplication is done by the fib table update function
 			register(prefix.Name, fes)

fw/core/logger.go

@@ -137,3 +137,11 @@ func LogTrace(module interface{}, components ...interface{}) {
 		log.Debug(generateLogMessage(module, components...))
 	}
 }
+
+func HasTraceLogs() bool {
+	return shouldPrintTraceLogs
+}
+
+func HasDebugLogs() bool {
+	return logLevel <= log.DebugLevel
+}

fw/defn/mtu.go

@@ -2,3 +2,6 @@ package defn
 
 // MaxNDNPacketSize is the maximum allowed NDN packet size
 const MaxNDNPacketSize = 8800
+
+// Maximum number of next hops for a given path
+const MaxNextHops = 16

fw/defn/pkt.go

@@ -9,19 +9,26 @@ package defn
 
 import (
 	enc "github.com/named-data/ndnd/std/encoding"
+	"github.com/named-data/ndnd/std/ndn"
 	spec "github.com/named-data/ndnd/std/ndn/spec_2022"
 )
 
 // Pkt represents a pending packet to be sent or recently
 // received on the link, plus any associated metadata.
 type Pkt struct {
 	Name enc.Name
-	L3   *spec.Packet
+	L3   PacketIntf
 	Raw  []byte
 
 	PitToken       []byte
 	CongestionMark *uint64
-	IncomingFaceID *uint64
+	IncomingFaceID uint64
 	NextHopFaceID  *uint64
 	CachePolicy    *uint64
 }
+
+type PacketIntf struct {
+	LpPacket *spec.LpPacket
+	Interest ndn.Interest
+	Data     ndn.Data
+}

fw/dispatch/face.go

@@ -33,7 +33,7 @@ type Face interface {
 type OutPkt struct {
 	Pkt      *defn.Pkt
 	PitToken []byte
-	InFace   *uint64
+	InFace   uint64
 }
 
 // FaceDispatch is used to allow forwarding to interact with faces without a circular dependency issue.

fw/face/link-service.go

@@ -226,7 +226,7 @@ func (l *linkServiceBase) dispatchInterest(pkt *defn.Pkt) {
 	}
 
 	// Store name for easy access
-	pkt.Name = pkt.L3.Interest.NameV
+	pkt.Name = pkt.L3.Interest.Name()
 
 	// Hash name to thread
 	thread := fw.HashNameToFwThread(pkt.Name)
@@ -240,7 +240,7 @@ func (l *linkServiceBase) dispatchData(pkt *defn.Pkt) {
 	}
 
 	// Store name for easy access
-	pkt.Name = pkt.L3.Data.NameV
+	pkt.Name = pkt.L3.Data.Name()
 
 	// Decode PitToken. If it's for us, it's a uint16 + uint32.
 	if len(pkt.PitToken) == 6 {

fw/face/ndnlp-link-service.go

@@ -73,6 +73,7 @@ type NDNLPLinkService struct {
 	BufferReader             enc.BufferReader
 	congestionCheck          uint64
 	outFrame                 []byte
+	outWire                  enc.Wire
 }
 
 // MakeNDNLPLinkService creates a new NDNLPv2 link service
@@ -88,7 +89,8 @@ func MakeNDNLPLinkService(transport transport, options NDNLPLinkServiceOptions)
 	l.nextSequence = 0
 	l.nextTxSequence = 0
 	l.congestionCheck = 0
-	l.outFrame = make([]byte, defn.MaxNDNPacketSize)
+	l.outFrame = make([]byte, defn.MaxNDNPacketSize*2)
+	l.outWire = make(enc.Wire, defn.MaxNDNPacketSize)
 	return l
 }
 
@@ -217,6 +219,7 @@ func sendPacket(l *NDNLPLinkService, out dispatch.OutPkt) {
 			}
 			fragments[i] = &spec.LpPacket{Fragment: frag}
 		}
+		reader.Free()
 	} else {
 		fragments = []*spec.LpPacket{{Fragment: enc.Wire{wire}}}
 	}
@@ -256,32 +259,35 @@ func sendPacket(l *NDNLPLinkService, out dispatch.OutPkt) {
 		}
 
 		// Incoming face indication
-		if l.options.IsIncomingFaceIndicationEnabled && out.InFace != nil {
-			fragment.IncomingFaceId = out.InFace
+		if l.options.IsIncomingFaceIndicationEnabled {
+			fragment.IncomingFaceId = utils.IdPtr(out.InFace)
 		}
 
 		// Congestion marking
 		if congestionMark != nil {
 			fragment.CongestionMark = congestionMark
 		}
 
-		pkt := &spec.Packet{
-			LpPacket: fragment,
-		}
+		pkt := spec.Packet{LpPacket: fragment}
+
+		// Use preallocated buffers for outgoing frame
 		encoder := spec.PacketEncoder{}
-		encoder.Init(pkt)
-		frameWire := encoder.Encode(pkt)
-		if frameWire == nil {
-			core.LogError(l, "Unable to encode fragment - DROP")
-			break
+		wirePlan := encoder.Init(&pkt)
+		outFrame := l.outFrame
+		outWire := l.outWire[:len(wirePlan)]
+
+		for i, l := range wirePlan {
+			outWire[i] = outFrame[:l]
+			outFrame = outFrame[l:]
 		}
+		encoder.EncodeInto(&pkt, outWire)
 
-		// Use preallocated buffer for outgoing frame
-		l.outFrame = l.outFrame[:0]
-		for _, b := range frameWire {
-			l.outFrame = append(l.outFrame, b...)
+		// Consolidate fragments. Since we only overwrite behind, there is no conflict.
+		nbytes := 0
+		for _, b := range outWire {
+			nbytes += copy(l.outFrame[nbytes:], b)
 		}
-		l.transport.sendFrame(l.outFrame)
+		l.transport.sendFrame(l.outFrame[:nbytes])
 	}
 }
 
@@ -293,10 +299,12 @@ func (l *NDNLPLinkService) handleIncomingFrame(frame []byte) {
 	// All incoming frames come through a link service
 	// Attempt to decode buffer into LpPacket
 	pkt := &defn.Pkt{
-		IncomingFaceID: utils.IdPtr(l.faceID),
+		IncomingFaceID: l.faceID,
 	}
 
-	L2, err := ReadPacketUnverified(enc.NewBufferReader(wire))
+	L2r := enc.NewBufferReader(wire)
+	L2, err := ReadPacketUnverified(L2r)
+	L2r.Free()
 	if err != nil {
 		core.LogError(l, err)
 		return
@@ -370,7 +378,9 @@ func (l *NDNLPLinkService) handleIncomingFrame(frame []byte) {
 		}
 
 		// Parse inner packet in place
-		L3, err := ReadPacketUnverified(enc.NewBufferReader(wire))
+		L3r := enc.NewBufferReader(wire)
+		L3, err := ReadPacketUnverified(L3r)
+		L3r.Free()
 		if err != nil {
 			return
 		}
@@ -444,8 +454,21 @@ func (op *NDNLPLinkServiceOptions) Flags() (ret uint64) {
 }
 
 // Reads a packet without validating the internal fields
-func ReadPacketUnverified(reader enc.ParseReader) (*spec.Packet, error) {
+func ReadPacketUnverified(reader enc.ParseReader) (ret defn.PacketIntf, err error) {
 	context := spec.PacketParsingContext{}
 	context.Init()
-	return context.Parse(reader, false)
+	packet, err := context.Parse(reader, false)
+	if err != nil {
+		return
+	}
+
+	if packet.LpPacket != nil {
+		ret.LpPacket = packet.LpPacket
+	} else if packet.Interest != nil {
+		ret.Interest = packet.Interest
+	} else if packet.Data != nil {
+		ret.Data = packet.Data
+	}
+
+	return ret, nil
 }

fw/face/stream-transport.go

@@ -33,20 +33,19 @@ func readTlvStream(
 		// Determine whether valid packet received
 		for {
 			rdr := enc.NewBufferReader(recvBuf[tlvOff:recvOff])
-
 			typ, err := enc.ReadTLNum(rdr)
 			if err != nil {
 				// Probably incomplete packet
 				break
 			}
-
-			len, err := enc.ReadTLNum(rdr)
+			length, err := enc.ReadTLNum(rdr)
 			if err != nil {
 				// Probably incomplete packet
 				break
 			}
+			rdr.Free()
 
-			tlvSize := typ.EncodingLength() + len.EncodingLength() + int(len)
+			tlvSize := typ.EncodingLength() + length.EncodingLength() + int(length)
 
 			if recvOff-tlvOff >= tlvSize {
 				// Packet was successfully received, send up to link service