Implement feedback

Author: mawyss

go/pkg/router/dataplane.go

@@ -801,7 +801,12 @@ func (p *scionPacketProcessor) processEPIC() (processResult, error) {
 		}
 	}
 
-	result.Class = tc.ClsEpic
+	// Prioritize EPIC packets at the last two hops:
+	result.Class = tc.ClsOthers
+	if isPenultimate || isLast {
+		result.Class = tc.ClsEpic
+	}
+
 	return result, nil
 }
 
@@ -1233,8 +1238,7 @@ func (p *scionPacketProcessor) process() (processResult, error) {
 		if err != nil {
 			return r, err
 		}
-		return processResult{OutConn: p.d.internal, OutAddr: a,
-			OutPkt: p.rawPkt, Class: tc.ClsScion}, nil
+		return processResult{OutConn: p.d.internal, OutAddr: a, OutPkt: p.rawPkt}, nil
 	}
 
 	// Outbound: pkts leaving the local IA.
@@ -1263,14 +1267,12 @@ func (p *scionPacketProcessor) process() (processResult, error) {
 		if err := p.processEgress(); err != nil {
 			return processResult{}, err
 		}
-		return processResult{EgressID: egressID, OutConn: c,
-			OutPkt: p.rawPkt, Class: tc.ClsScion}, nil
+		return processResult{EgressID: egressID, OutConn: c, OutPkt: p.rawPkt}, nil
 	}
 
 	// ASTransit: pkts leaving from another AS BR.
 	if a, ok := p.d.internalNextHops[egressID]; ok {
-		return processResult{OutConn: p.d.internal, OutAddr: a,
-			OutPkt: p.rawPkt, Class: tc.ClsScion}, nil
+		return processResult{OutConn: p.d.internal, OutAddr: a, OutPkt: p.rawPkt}, nil
 	}
 	errCode := slayers.SCMPCodeUnknownHopFieldEgress
 	if !p.infoField.ConsDir {
@@ -1332,8 +1334,8 @@ func (p *scionPacketProcessor) processOHP() (processResult, error) {
 		// OHP should always be directed to the correct BR.
 		if c, ok := p.d.external[ohp.FirstHop.ConsEgress]; ok {
 			// buffer should already be correct
-			return processResult{EgressID: ohp.FirstHop.ConsEgress, OutConn: c, OutPkt: p.rawPkt,
-				Class: tc.ClsOhp}, nil
+			return processResult{EgressID: ohp.FirstHop.ConsEgress, OutConn: c,
+				OutPkt: p.rawPkt}, nil
 		}
 		// TODO parameter problem invalid interface
 		return processResult{}, serrors.WithCtx(cannotRoute, "type", "ohp",
@@ -1369,8 +1371,7 @@ func (p *scionPacketProcessor) processOHP() (processResult, error) {
 	if err != nil {
 		return processResult{}, err
 	}
-	return processResult{OutConn: p.d.internal, OutAddr: a, OutPkt: p.rawPkt,
-		Class: tc.ClsOhp}, nil
+	return processResult{OutConn: p.d.internal, OutAddr: a, OutPkt: p.rawPkt}, nil
 }
 
 func (d *DataPlane) resolveLocalDst(s slayers.SCION) (*net.UDPAddr, error) {
@@ -1477,17 +1478,8 @@ func (b *bfdSend) Send(bfd *layers.BFD) error {
 		return err
 	}
 
-	r := &processResult{
-		OutAddr:  b.dstAddr,
-		OutPkt:   buffer.Bytes(),
-		OutConn:  b.conn,
-		EgressID: b.ifID,
-		Class:    tc.ClsBfd,
-	}
-	if !b.d.enqueue(r) {
-		return serrors.New("Bfd enqueue failed")
-	}
-	return nil
+	_, err = b.conn.WriteTo(buffer.Bytes(), b.dstAddr)
+	return err
 }
 
 func (p *scionPacketProcessor) prepareSCMP(scmpH *slayers.SCMP, scmpP gopacket.SerializableLayer,

go/pkg/router/tc/BUILD.bazel

@@ -3,9 +3,7 @@ load("//lint:go.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = [
-        "colibriprio.go",
         "others.go",
-        "roundrobin.go",
         "strict.go",
         "tc.go",
     ],

go/pkg/router/tc/colibriprio.go

@@ -22,7 +22,7 @@ type StrictPriorityScheduler struct{}
 
 // Schedule schedules packets based on a strict hierarchy, where a message from a
 // queue is only scheduled if all higher priority queues are empty.
-// The priorities are: COLIBRI > BFD > OHP > EPIC > SCMP > SCION > Others.
+// The priorities are: COLIBRI > EPIC > Others.
 func (s *StrictPriorityScheduler) Schedule(qs *Queues) ([]ipv4.Message, error) {
 	read := 0
 	n, err := qs.dequeue(ClsColibri, outputBatchCnt-read, qs.writeBuffer[read:])
@@ -31,36 +31,12 @@ func (s *StrictPriorityScheduler) Schedule(qs *Queues) ([]ipv4.Message, error) {
 	}
 	read = read + n
 
-	n, err = qs.dequeue(ClsBfd, outputBatchCnt-read, qs.writeBuffer[read:])
-	if err != nil {
-		return nil, err
-	}
-	read = read + n
-
-	n, err = qs.dequeue(ClsOhp, outputBatchCnt-read, qs.writeBuffer[read:])
-	if err != nil {
-		return nil, err
-	}
-	read = read + n
-
 	n, err = qs.dequeue(ClsEpic, outputBatchCnt-read, qs.writeBuffer[read:])
 	if err != nil {
 		return nil, err
 	}
 	read = read + n
 
-	n, err = qs.dequeue(ClsScmp, outputBatchCnt-read, qs.writeBuffer[read:])
-	if err != nil {
-		return nil, err
-	}
-	read = read + n
-
-	n, err = qs.dequeue(ClsScion, outputBatchCnt-read, qs.writeBuffer[read:])
-	if err != nil {
-		return nil, err
-	}
-	read = read + n
-
 	n, err = qs.dequeue(ClsOthers, outputBatchCnt-read, qs.writeBuffer[read:])
 	if err != nil {
 		return nil, err

go/pkg/router/tc/roundrobin.go

@@ -35,17 +35,11 @@ const (
 	ClsOthers TrafficClass = iota
 	ClsColibri
 	ClsEpic
-	ClsBfd
-	ClsOhp
-	ClsScmp
-	ClsScion
 )
 
 // Identify the possible scheduling algorithms.
 const (
 	SchedOthersOnly SchedulerId = iota
-	SchedRoundRobin
-	SchedColibriPrio
 	SchedStrictPriority
 )
 
@@ -77,16 +71,10 @@ func NewQueues(scheduling bool, maxPacketLength int) *Queues {
 	qs.nonempty = make(chan bool, 1)
 	qs.mapping = make(map[TrafficClass]*ZeroAllocQueue)
 
+	qs.mapping[ClsOthers] = newZeroAllocQueue(128, maxPacketLength)
 	if scheduling {
-		qs.mapping[ClsOthers] = newZeroAllocQueue(32, maxPacketLength)
 		qs.mapping[ClsColibri] = newZeroAllocQueue(32, maxPacketLength)
 		qs.mapping[ClsEpic] = newZeroAllocQueue(32, maxPacketLength)
-		qs.mapping[ClsBfd] = newZeroAllocQueue(32, maxPacketLength)
-		qs.mapping[ClsOhp] = newZeroAllocQueue(32, maxPacketLength)
-		qs.mapping[ClsScmp] = newZeroAllocQueue(32, maxPacketLength)
-		qs.mapping[ClsScion] = newZeroAllocQueue(128, maxPacketLength)
-	} else {
-		qs.mapping[ClsOthers] = newZeroAllocQueue(128, maxPacketLength)
 	}
 
 	qs.writeBuffer = conn.NewReadMessages(outputBatchCnt)
@@ -96,16 +84,12 @@ func NewQueues(scheduling bool, maxPacketLength int) *Queues {
 // SetScheduler assigns the provided scheduler to the queues.
 func (qs *Queues) SetScheduler(s SchedulerId) {
 	switch s {
-	case SchedRoundRobin:
-		qs.scheduler = &RoundRobinScheduler{}
-	case SchedColibriPrio:
-		qs.scheduler = &ColibriPriorityScheduler{}
 	case SchedOthersOnly:
 		qs.scheduler = &OthersOnlyScheduler{}
 	case SchedStrictPriority:
 		qs.scheduler = &StrictPriorityScheduler{}
 	default:
-		qs.scheduler = &RoundRobinScheduler{}
+		qs.scheduler = &StrictPriorityScheduler{}
 	}
 }
 
@@ -278,14 +262,6 @@ func (tc TrafficClass) String() string {
 		return "COLIBRI"
 	case ClsEpic:
 		return "EPIC"
-	case ClsBfd:
-		return "BFD"
-	case ClsOhp:
-		return "OHP"
-	case ClsScmp:
-		return "SCMP"
-	case ClsScion:
-		return "SCION"
 	default:
 		return "Unknown traffic class"
 	}