fix: prefix

Author: istae

pkg/topology/kademlia/binprefix.go

@@ -13,59 +13,76 @@ import (
 
 // generateCommonBinPrefixes generates the common bin prefixes
 // used by the bin balancer.
-func generateCommonBinPrefixes(base swarm.Address, suffixLength int) [][]swarm.Address {
+func generateConstCommonBinPrefixes(base swarm.Address, suffixLength int) [][]swarm.Address {
+	binPrefixes := make([][]swarm.Address, int(swarm.MaxBins))
+
+	for i := 0; i < int(swarm.MaxBins); i++ {
+		binPrefixes[i] = generateBinPrefixes(base, i, suffixLength)
+	}
+
+	return binPrefixes
+}
+
+// generateCommonBinPrefixes generates the common bin prefixes
+// used by the bin balancer.
+func generateCommonBinPrefixes(base swarm.Address, suffixLengths []int) [][]swarm.Address {
+	binPrefixes := make([][]swarm.Address, int(swarm.MaxBins))
+
+	for i := 0; i < int(swarm.MaxBins); i++ {
+		binPrefixes[i] = generateBinPrefixes(base, i, suffixLengths[i])
+	}
+
+	return binPrefixes
+}
+
+func generateBinPrefixes(base swarm.Address, bin, suffixLength int) []swarm.Address {
 	bitCombinationsCount := int(math.Pow(2, float64(suffixLength)))
 	bitSuffixes := make([]uint8, bitCombinationsCount)
 
 	for i := 0; i < bitCombinationsCount; i++ {
 		bitSuffixes[i] = uint8(i)
 	}
 
-	binPrefixes := make([][]swarm.Address, int(swarm.MaxBins))
+	binPrefixes := make([]swarm.Address, bitCombinationsCount)
 
 	// copy base address
-	for i := range binPrefixes {
-		binPrefixes[i] = make([]swarm.Address, bitCombinationsCount)
-		for j := range binPrefixes[i] {
-			binPrefixes[i][j] = base.Clone()
-		}
+	for j := range binPrefixes {
+		binPrefixes[j] = base.Clone()
 	}
 
-	for i := range binPrefixes {
-		for j := range binPrefixes[i] {
-			pseudoAddrBytes := binPrefixes[i][j].Bytes()
-
-			if len(pseudoAddrBytes) < 1 {
-				continue
-			}
-
-			// flip first bit for bin
-			indexByte, posBit := i/8, i%8
-			if hasBit(bits.Reverse8(pseudoAddrBytes[indexByte]), uint8(posBit)) {
-				pseudoAddrBytes[indexByte] = bits.Reverse8(clearBit(bits.Reverse8(pseudoAddrBytes[indexByte]), uint8(posBit)))
-			} else {
-				pseudoAddrBytes[indexByte] = bits.Reverse8(setBit(bits.Reverse8(pseudoAddrBytes[indexByte]), uint8(posBit)))
-			}
+	for j := range binPrefixes {
+		pseudoAddrBytes := binPrefixes[j].Bytes()
 
-			// set pseudo suffix
-			bitSuffixPos := suffixLength - 1
-			for l := i + 1; l < i+suffixLength+1; l++ {
-				index, pos := l/8, l%8
+		if len(pseudoAddrBytes) < 1 {
+			continue
+		}
 
-				if hasBit(bitSuffixes[j], uint8(bitSuffixPos)) {
-					pseudoAddrBytes[index] = bits.Reverse8(setBit(bits.Reverse8(pseudoAddrBytes[index]), uint8(pos)))
-				} else {
-					pseudoAddrBytes[index] = bits.Reverse8(clearBit(bits.Reverse8(pseudoAddrBytes[index]), uint8(pos)))
-				}
+		// flip first bit for bin
+		indexByte, posBit := bin/8, bin%8
+		if hasBit(bits.Reverse8(pseudoAddrBytes[indexByte]), uint8(posBit)) {
+			pseudoAddrBytes[indexByte] = bits.Reverse8(clearBit(bits.Reverse8(pseudoAddrBytes[indexByte]), uint8(posBit)))
+		} else {
+			pseudoAddrBytes[indexByte] = bits.Reverse8(setBit(bits.Reverse8(pseudoAddrBytes[indexByte]), uint8(posBit)))
+		}
 
-				bitSuffixPos--
-			}
+		// set pseudo suffix
+		bitSuffixPos := suffixLength - 1
+		for l := bin + 1; l < bin+suffixLength+1; l++ {
+			index, pos := l/8, l%8
 
-			// clear rest of the bits
-			for l := i + suffixLength + 1; l < len(pseudoAddrBytes)*8; l++ {
-				index, pos := l/8, l%8
+			if hasBit(bitSuffixes[j], uint8(bitSuffixPos)) {
+				pseudoAddrBytes[index] = bits.Reverse8(setBit(bits.Reverse8(pseudoAddrBytes[index]), uint8(pos)))
+			} else {
 				pseudoAddrBytes[index] = bits.Reverse8(clearBit(bits.Reverse8(pseudoAddrBytes[index]), uint8(pos)))
 			}
+
+			bitSuffixPos--
+		}
+
+		// clear rest of the bits
+		for l := bin + suffixLength + 1; l < len(pseudoAddrBytes)*8; l++ {
+			index, pos := l/8, l%8
+			pseudoAddrBytes[index] = bits.Reverse8(clearBit(bits.Reverse8(pseudoAddrBytes[index]), uint8(pos)))
 		}
 	}
 

pkg/topology/kademlia/binprefix_test.go

@@ -0,0 +1,45 @@
+package kademlia
+
+import (
+	"testing"
+
+	"github.com/ethersphere/bee/v2/pkg/swarm"
+)
+
+func TestGenerateCommonBinPrefixes(t *testing.T) {
+	base := swarm.MustParseHexAddress("abcdef1234567890")
+	suffixLength := 3
+
+	suffixLengths := make([]int, 32)
+	for i := range suffixLengths {
+		suffixLengths[i] = 3
+	}
+
+	prefixes := generateCommonBinPrefixes(base, suffixLengths)
+
+	if len(prefixes) != int(swarm.MaxBins) {
+		t.Fatalf("expected %d bins, got %d", swarm.MaxBins, len(prefixes))
+	}
+
+	for i := 0; i < int(swarm.MaxBins); i++ {
+		for j := 0; j < len(prefixes[i]); j++ {
+			proximity := swarm.Proximity(base.Bytes(), prefixes[i][j].Bytes())
+			if want := uint8(i); want != proximity {
+				t.Fatalf("expected proximity %d for bin %d, got %d", want, i, proximity)
+			}
+		}
+	}
+
+	bitCombinationsCount := 1 << suffixLength
+	for i := 0; i < int(swarm.MaxBins); i++ {
+		if len(prefixes[i]) != bitCombinationsCount {
+			t.Fatalf("expected %d addresses in bin %d, got %d", bitCombinationsCount, i, len(prefixes[i]))
+		}
+
+		for j := 0; j < bitCombinationsCount; j++ {
+			if len(prefixes[i][j].Bytes()) != len(base.Bytes()) {
+				t.Fatalf("expected address length %d, got %d", len(base.Bytes()), len(prefixes[i][j].Bytes()))
+			}
+		}
+	}
+}

pkg/topology/kademlia/export_test.go

@@ -14,7 +14,7 @@ var (
 	PruneOversaturatedBinsFunc = func(k *Kad) func(uint8) {
 		return k.pruneOversaturatedBins
 	}
-	GenerateCommonBinPrefixes = generateCommonBinPrefixes
+	GenerateCommonBinPrefixes = generateConstCommonBinPrefixes
 )
 
 const (

pkg/topology/kademlia/kademlia.go

@@ -49,7 +49,7 @@ const (
 
 // Default option values
 const (
-	defaultBitSuffixLength             = 2 // the number of bits used to create pseudo addresses for balancing, 2^2, 8 addresses
+	defaultBitSuffixLength             = 4 // the number of bits used to create pseudo addresses for balancing, 2^2, 8 addresses
 	defaultLowWaterMark                = 3 // the number of peers in consecutive deepest bins that constitute as nearest neighbours
 	defaultSaturationPeers             = 8
 	defaultOverSaturationPeers         = 18
@@ -111,18 +111,21 @@ type kadOptions struct {
 	StaticNodes    []swarm.Address
 	ExcludeFunc    excludeFunc
 
-	TimeToRetry                 time.Duration
-	ShortRetry                  time.Duration
-	PruneWakeup                 time.Duration
-	BitSuffixLength             int // additional depth of common prefix for bin
+	TimeToRetry time.Duration
+	ShortRetry  time.Duration
+	PruneWakeup time.Duration
+	// BitSuffixLength             int // additional depth of common prefix for bin
 	SaturationPeers             int
 	OverSaturationPeers         int
 	BootnodeOverSaturationPeers int
 	BroadcastBinSize            int
 	LowWaterMark                int
 }
 
-var saturationCounts = [swarm.MaxBins]int{64, 32, 16, 12, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8}
+var (
+	saturationCounts = [swarm.MaxBins]int{64, 32, 16, 12, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8}
+	prefixBits       = [swarm.MaxBins]int{6, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}
+)
 
 func newKadOptions(o Options) kadOptions {
 	ko := kadOptions{
@@ -134,12 +137,10 @@ func newKadOptions(o Options) kadOptions {
 		StaticNodes:    o.StaticNodes,
 		ExcludeFunc:    o.ExcludeFunc,
 		// copy or use default
-		TimeToRetry:                 defaultValDuration(o.TimeToRetry, defaultTimeToRetry),
-		ShortRetry:                  defaultValDuration(o.ShortRetry, defaultShortRetry),
-		PruneWakeup:                 defaultValDuration(o.PruneWakeup, defaultPruneWakeup),
-		BitSuffixLength:             defaultValInt(o.BitSuffixLength, defaultBitSuffixLength),
-		SaturationPeers:             defaultValInt(o.SaturationPeers, defaultSaturationPeers),
-		OverSaturationPeers:         defaultValInt(o.OverSaturationPeers, defaultOverSaturationPeers),
+		TimeToRetry: defaultValDuration(o.TimeToRetry, defaultTimeToRetry),
+		ShortRetry:  defaultValDuration(o.ShortRetry, defaultShortRetry),
+		PruneWakeup: defaultValDuration(o.PruneWakeup, defaultPruneWakeup),
+		// BitSuffixLength:             defaultValInt(o.BitSuffixLength, defaultBitSuffixLength),
 		BootnodeOverSaturationPeers: defaultValInt(o.BootnodeOverSaturationPeers, defaultBootNodeOverSaturationPeers),
 		BroadcastBinSize:            defaultValInt(o.BroadcastBinSize, defaultBroadcastBinSize),
 		LowWaterMark:                defaultValInt(o.LowWaterMark, defaultLowWaterMark),
@@ -167,11 +168,7 @@ func defaultValDuration(v *time.Duration, d time.Duration) time.Duration {
 }
 
 func makeSaturationFunc(o kadOptions) binSaturationFunc {
-	os := o.OverSaturationPeers
-	if o.BootnodeMode {
-		os = o.BootnodeOverSaturationPeers
-	}
-	return binSaturated(os, isStaticPeer(o.StaticNodes))
+	return binSaturated(isStaticPeer(o.StaticNodes))
 }
 
 // Kad is the Swarm forwarding kademlia implementation.
@@ -258,11 +255,7 @@ func New(
 		k.opt.PruneFunc = k.pruneOversaturatedBins
 	}
 
-	os := k.opt.OverSaturationPeers
-	if k.opt.BootnodeMode {
-		os = k.opt.BootnodeOverSaturationPeers
-	}
-	k.opt.PruneCountFunc = binPruneCount(os, isStaticPeer(k.opt.StaticNodes))
+	k.opt.PruneCountFunc = binPruneCount(isStaticPeer(k.opt.StaticNodes))
 
 	if k.opt.ExcludeFunc == nil {
 		k.opt.ExcludeFunc = func(f ...im.ExcludeOp) peerExcludeFunc {
@@ -272,9 +265,7 @@ func New(
 		}
 	}
 
-	if k.opt.BitSuffixLength > 0 {
-		k.commonBinPrefixes = generateCommonBinPrefixes(k.base, k.opt.BitSuffixLength)
-	}
+	k.commonBinPrefixes = generateCommonBinPrefixes(k.base, prefixBits[:])
 
 	k.bgBroadcastCtx, k.bgBroadcastCancel = context.WithCancel(context.Background())
 
@@ -317,12 +308,12 @@ func (k *Kad) connectBalanced(wg *sync.WaitGroup, peerConnChan chan<- *peerConnI
 
 			// Connect to closest known peer which we haven't tried connecting to recently.
 
-			_, exists := nClosePeerInSlice(binConnectedPeers, pseudoAddr, noopSanctionedPeerFn, uint8(i+k.opt.BitSuffixLength+1))
+			_, exists := nClosePeerInSlice(binConnectedPeers, pseudoAddr, noopSanctionedPeerFn, uint8(i+prefixBits[i]+1))
 			if exists {
 				continue
 			}
 
-			closestKnownPeer, exists := nClosePeerInSlice(binPeers, pseudoAddr, skipPeers, uint8(i+k.opt.BitSuffixLength+1))
+			closestKnownPeer, exists := nClosePeerInSlice(binPeers, pseudoAddr, skipPeers, uint8(i+prefixBits[i]+1))
 			if !exists {
 				continue
 			}
@@ -738,7 +729,7 @@ func (k *Kad) balancedSlotPeers(pseudoAddr swarm.Address, peers []swarm.Address,
 	var ret []swarm.Address
 
 	for _, peer := range peers {
-		if int(swarm.ExtendedProximity(peer.Bytes(), pseudoAddr.Bytes())) >= po+k.opt.BitSuffixLength+1 {
+		if int(swarm.ExtendedProximity(peer.Bytes(), pseudoAddr.Bytes())) >= po+prefixBits[po]+1 {
 			ret = append(ret, peer)
 		}
 	}
@@ -866,7 +857,7 @@ func (k *Kad) connectBootNodes(ctx context.Context) {
 // binSaturated indicates whether a certain bin is saturated or not.
 // when a bin is not saturated it means we would like to proactively
 // initiate connections to other peers in the bin.
-func binSaturated(oversaturationAmount int, staticNode staticPeerFunc) binSaturationFunc {
+func binSaturated(staticNode staticPeerFunc) binSaturationFunc {
 	return func(bin uint8, connected *pslice.PSlice, exclude peerExcludeFunc) bool {
 		size := 0
 		_ = connected.EachBin(func(addr swarm.Address, po uint8) (bool, bool, error) {
@@ -881,7 +872,7 @@ func binSaturated(oversaturationAmount int, staticNode staticPeerFunc) binSatura
 }
 
 // binPruneCount counts how many peers should be pruned from a bin.
-func binPruneCount(oversaturationAmount int, staticNode staticPeerFunc) pruneCountFunc {
+func binPruneCount(staticNode staticPeerFunc) pruneCountFunc {
 	return func(bin uint8, connected *pslice.PSlice, exclude peerExcludeFunc) (int, int) {
 		size := 0
 		_ = connected.EachBin(func(addr swarm.Address, po uint8) (bool, bool, error) {

pkg/topology/kademlia/kademlia_test.go

@@ -1898,6 +1898,7 @@ func mineBin(t *testing.T, base swarm.Address, bin, count int, isBalanced bool)
 	}
 
 	if isBalanced {
+
 		prefixes := kademlia.GenerateCommonBinPrefixes(base, kademlia.DefaultBitSuffixLength)
 		for i := 0; i < int(math.Pow(2, float64(kademlia.DefaultBitSuffixLength))); i++ {
 			rndAddrs[i] = prefixes[bin][i]