slightly faster switch logic, should be easier to have a useful tie-breaker for peers that are equally close to the destination via the tree metric

misc/sim/treesim.go

@@ -6,13 +6,15 @@ import "os"
 import "strings"
 import "strconv"
 import "time"
-import "log"
 
 import "runtime"
 import "runtime/pprof"
 import "flag"
 
+import "github.com/gologme/log"
+
 import . "github.com/yggdrasil-network/yggdrasil-go/src/yggdrasil"
+import . "github.com/yggdrasil-network/yggdrasil-go/src/crypto"
 
 ////////////////////////////////////////////////////////////////////////////////
 

src/yggdrasil/switch.go

@@ -569,23 +569,23 @@ func (t *switchTable) start() error {
 	return nil
 }
 
-// Check if a packet should go to the self node
+// Return a map of ports onto distance, keeping only ports closer to the destination than this node
-// This means there's no node closer to the destination than us
+// If the map is empty (or nil), then no peer is closer
-// This is mainly used to identify packets addressed to us, or that hit a blackhole
+func (t *switchTable) getCloser(dest []byte) map[switchPort]int {
-func (t *switchTable) selfIsClosest(dest []byte) bool {
 	table := t.getTable()
 	myDist := table.self.dist(dest)
 	if myDist == 0 {
 		// Skip the iteration step if it's impossible to be closer
-		return true
+		return nil
 	}
+	closer := make(map[switchPort]int, len(table.elems))
 	for _, info := range table.elems {
 		dist := info.locator.dist(dest)
 		if dist < myDist {
-			return false
+			closer[info.port] = dist
 		}
 	}
-	return true
+	return closer
 }
 
 // Returns true if the peer is closer to the destination than ourself
@@ -639,25 +639,26 @@ func (t *switchTable) bestPortForCoords(coords []byte) switchPort {
 func (t *switchTable) handleIn(packet []byte, idle map[switchPort]struct{}) bool {
 	coords := switch_getPacketCoords(packet)
 	ports := t.core.peers.getPorts()
-	if t.selfIsClosest(coords) {
+	closer := t.getCloser(coords)
+	if len(closer) == 0 {
 		// TODO? call the router directly, and remove the whole concept of a self peer?
 		ports[0].sendPacket(packet)
 		return true
 	}
-	table := t.getTable()
-	myDist := table.self.dist(coords)
 	var best *peer
-	bestDist := myDist
+	var bestDist int
-	for port := range idle {
+	for port, dist := range closer {
-		if to := ports[port]; to != nil {
+		to := ports[port]
-			if info, isIn := table.elems[to.port]; isIn {
+		_, isIdle := idle[port]
-				dist := info.locator.dist(coords)
+		switch {
-				if !(dist < bestDist) {
+		case to == nil: // skip
-					continue
+		case !isIdle: // skip
-				}
+		case best == nil: // keep
+			fallthrough
+		case dist < bestDist: // keep
 			best = to
 			bestDist = dist
-			}
+		default: // skip
 		}
 	}
 	if best != nil {
@@ -696,7 +697,7 @@ func (b *switch_buffers) cleanup(t *switchTable) {
 		// Remove queues for which we have no next hop
 		packet := buf.packets[0]
 		coords := switch_getPacketCoords(packet.bytes)
-		if t.selfIsClosest(coords) {
+		if len(t.getCloser(coords)) == 0 {
 			for _, packet := range buf.packets {
 				util.PutBytes(packet.bytes)
 			}