Implement Weighted Power of Two (WP2) load balancing strategy as default

Add advanced WP2 load balancing algorithm that selects the better performing
server from two random candidates based on real-time RTT and success rates.
This provides significantly better performance and fault tolerance compared
to the previous P2 strategy.

Key improvements:
- Real-time performance scoring using RTT (70%) + success rate (30%)
- Automatic adaptation to server performance changes
- Better load distribution across all servers
- Enhanced fault tolerance and recovery
- Comprehensive query statistics tracking
- Debug logging for performance monitoring

The WP2 strategy is now the default, replacing P2, while maintaining full
backward compatibility for users who explicitly configure other strategies.

Author: jedisct1

dnscrypt-proxy/config_loader.go

@@ -178,7 +178,8 @@ func configureLoadBalancing(proxy *Proxy, config *Config) {
 	lbStrategy := LBStrategy(DefaultLBStrategy)
 	switch lbStrategyStr := strings.ToLower(config.LBStrategy); lbStrategyStr {
 	case "":
-		// default
+		// default - WP2 is now the default strategy
+		dlog.Noticef("Using default Weighted Power of Two (WP2) load balancing strategy")
 	case "p2":
 		lbStrategy = LBStrategyP2{}
 	case "ph":
@@ -188,6 +189,9 @@ func configureLoadBalancing(proxy *Proxy, config *Config) {
 		lbStrategy = LBStrategyFirst{}
 	case "random":
 		lbStrategy = LBStrategyRandom{}
+	case "wp2":
+		lbStrategy = LBStrategyWP2{}
+		dlog.Noticef("Using Weighted Power of Two (WP2) load balancing strategy")
 	default:
 		if strings.HasPrefix(lbStrategyStr, "p") {
 			n, err := strconv.ParseInt(strings.TrimPrefix(lbStrategyStr, "p"), 10, 32)

dnscrypt-proxy/example-dnscrypt-proxy.toml

@@ -175,11 +175,17 @@ keepalive = 30
 #                        Load Balancing & Performance                          #
 ###############################################################################
 
-## Load-balancing strategy: 'p2' (default), 'ph', 'p<n>', 'first' or 'random'
-## Randomly choose 1 of the fastest 2, half, n, 1 or all live servers by latency.
+## Load-balancing strategy: 'wp2' (default), 'p2', 'ph', 'p<n>', 'first', or 'random'
+## 'wp2' (default): Weighted Power of Two - selects the better performing server from two 
+## random candidates based on real-time RTT and success rates.
+## 'p2': Randomly choose 1 of the fastest 2 servers by latency.
+## 'ph': Randomly choose from fastest half of servers.
+## 'p<n>': Randomly choose from fastest n servers (e.g., 'p3' for fastest 3).
+## 'first': Always use the fastest server.
+## 'random': Randomly choose from all servers.
 ## The response quality still depends on the server itself.
 
-# lb_strategy = 'p2'
+# lb_strategy = 'wp2'
 
 ## Set to `true` to constantly try to estimate the latency of all the resolvers
 ## and adjust the load-balancing parameters accordingly, or to `false` to disable.

dnscrypt-proxy/proxy.go

@@ -289,9 +289,17 @@ func (proxy *Proxy) StartProxy() {
 		dlog.Notice("dnscrypt-proxy is waiting for at least one server to be reachable")
 	}
 	go func() {
+		lastLogTime := time.Now()
 		for {
 			clocksmith.Sleep(PrefetchSources(proxy.xTransport, proxy.sources))
 			proxy.updateRegisteredServers()
+
+			// Log WP2 statistics every 5 minutes if debug logging is enabled
+			if time.Since(lastLogTime) > 5*time.Minute {
+				proxy.serversInfo.logWP2Stats()
+				lastLogTime = time.Now()
+			}
+
 			runtime.GC()
 		}
 	}()
@@ -731,6 +739,11 @@ func (proxy *Proxy) processIncomingQuery(
 
 		// Exchange DNS request with the server
 		exchangeResponse, err := handleDNSExchange(proxy, serverInfo, &pluginsState, query, serverProto)
+
+		// Update server statistics for WP2 strategy
+		success := (err == nil && exchangeResponse != nil)
+		proxy.serversInfo.updateServerStats(serverName, success)
+
 		if err != nil || exchangeResponse == nil {
 			return response
 		}

dnscrypt-proxy/serversInfo.go

@@ -63,6 +63,11 @@ type ServerInfo struct {
 	Proto              stamps.StampProtoType
 	useGet             bool
 	odohTargetConfigs  []ODoHTargetConfig
+
+	// WP2 strategy fields
+	totalQueries   uint64    // Total queries sent to this server
+	failedQueries  uint64    // Failed queries count
+	lastUpdateTime time.Time // Last time metrics were updated
 }
 
 type LBStrategy interface {
@@ -120,7 +125,33 @@ func (LBStrategyRandom) getActiveCount(serversCount int) int {
 	return serversCount
 }
 
-var DefaultLBStrategy = LBStrategyP2{}
+type LBStrategyWP2 struct{}
+
+func (LBStrategyWP2) getCandidate(serversCount int) int {
+	if serversCount <= 1 {
+		return 0
+	}
+	if serversCount == 2 {
+		return rand.Intn(2)
+	}
+
+	// Select two random servers
+	first := rand.Intn(serversCount)
+	second := rand.Intn(serversCount)
+
+	// Ensure we have two different servers
+	for second == first {
+		second = rand.Intn(serversCount)
+	}
+
+	return first // Will be refined in getWeightedCandidate
+}
+
+func (LBStrategyWP2) getActiveCount(serversCount int) int {
+	return serversCount // All servers are considered active for WP2
+}
+
+var DefaultLBStrategy = LBStrategyWP2{}
 
 type DNSCryptRelay struct {
 	RelayUDPAddr *net.UDPAddr
@@ -324,17 +355,136 @@ func (serversInfo *ServersInfo) getOne() *ServerInfo {
 		serversInfo.Unlock()
 		return nil
 	}
-	candidate := serversInfo.lbStrategy.getCandidate(serversCount)
-	if serversInfo.lbEstimator {
-		serversInfo.estimatorUpdate(candidate)
+
+	var candidate int
+
+	// Check if using WP2 strategy
+	if _, isWP2 := serversInfo.lbStrategy.(LBStrategyWP2); isWP2 {
+		candidate = serversInfo.getWeightedCandidate(serversCount)
+	} else {
+		candidate = serversInfo.lbStrategy.getCandidate(serversCount)
+		if serversInfo.lbEstimator {
+			serversInfo.estimatorUpdate(candidate)
+		}
 	}
+
 	serverInfo := serversInfo.inner[candidate]
-	dlog.Debugf("Using candidate [%s] RTT: %d", serverInfo.Name, int(serverInfo.rtt.Value()))
+	dlog.Debugf("Using candidate [%s] RTT: %d Score: %.3f",
+		serverInfo.Name,
+		int(serverInfo.rtt.Value()),
+		serversInfo.calculateServerScore(serverInfo))
 	serversInfo.Unlock()
 
 	return serverInfo
 }
 
+// getWeightedCandidate implements the WP2 algorithm
+func (serversInfo *ServersInfo) getWeightedCandidate(serversCount int) int {
+	if serversCount <= 1 {
+		return 0
+	}
+
+	// Select two random servers
+	first := rand.Intn(serversCount)
+	second := rand.Intn(serversCount)
+
+	// Ensure we have two different servers
+	for second == first {
+		second = rand.Intn(serversCount)
+	}
+
+	server1 := serversInfo.inner[first]
+	server2 := serversInfo.inner[second]
+
+	// Calculate weighted scores
+	score1 := serversInfo.calculateServerScore(server1)
+	score2 := serversInfo.calculateServerScore(server2)
+
+	// Select the better performing server with small randomization
+	if score1 > score2 {
+		return first
+	} else if score2 > score1 {
+		return second
+	} else {
+		// Tie-breaker: random selection
+		if rand.Float64() < 0.5 {
+			return first
+		}
+		return second
+	}
+}
+
+// calculateServerScore computes a performance score for server selection
+func (serversInfo *ServersInfo) calculateServerScore(server *ServerInfo) float64 {
+	// Base score from RTT (lower RTT = higher score)
+	rtt := server.rtt.Value()
+	if rtt <= 0 {
+		rtt = 1000 // Default high RTT for servers without data
+	}
+
+	// Normalize RTT to a 0-1 scale (1000ms max)
+	rttScore := 1.0 - (rtt / 1000.0)
+	if rttScore < 0.0 {
+		rttScore = 0.0
+	}
+
+	// Success rate score
+	successRate := 1.0 // Default to perfect success rate
+	if server.totalQueries > 0 {
+		successRate = float64(server.totalQueries-server.failedQueries) / float64(server.totalQueries)
+	}
+
+	// Combine scores (RTT weighted 70%, success rate 30%)
+	finalScore := (rttScore * 0.7) + (successRate * 0.3)
+
+	return finalScore
+}
+
+// updateServerStats updates server statistics after each query
+func (serversInfo *ServersInfo) updateServerStats(serverName string, success bool) {
+	serversInfo.Lock()
+	defer serversInfo.Unlock()
+
+	for _, server := range serversInfo.inner {
+		if server.Name == serverName {
+			server.totalQueries++
+			if !success {
+				server.failedQueries++
+			}
+			server.lastUpdateTime = time.Now()
+
+			// Reset counters periodically to prevent overflow and adapt to changes
+			if server.totalQueries > 10000 {
+				server.totalQueries = server.totalQueries / 2
+				server.failedQueries = server.failedQueries / 2
+			}
+			break
+		}
+	}
+}
+
+// logWP2Stats logs WP2 performance statistics for debugging
+func (serversInfo *ServersInfo) logWP2Stats() {
+	if _, isWP2 := serversInfo.lbStrategy.(LBStrategyWP2); !isWP2 {
+		return
+	}
+
+	serversInfo.RLock()
+	defer serversInfo.RUnlock()
+
+	dlog.Debug("WP2 Strategy Server Statistics:")
+	for i, server := range serversInfo.inner {
+		score := serversInfo.calculateServerScore(server)
+		successRate := 1.0
+		if server.totalQueries > 0 {
+			successRate = float64(server.totalQueries-server.failedQueries) / float64(server.totalQueries)
+		}
+
+		dlog.Debugf("[%d] %s: RTT=%dms, Score=%.3f, Success=%.2f%%, Queries=%d",
+			i, server.Name, int(server.rtt.Value()), score, successRate*100, server.totalQueries)
+	}
+}
+
 func fetchServerInfo(proxy *Proxy, name string, stamp stamps.ServerStamp, isNew bool) (ServerInfo, error) {
 	if stamp.Proto == stamps.StampProtoTypeDNSCrypt {
 		return fetchDNSCryptServerInfo(proxy, name, stamp, isNew)