perf(pool): optimize lock-free queue with conditional yielding and opposite-end pooling

- Replace unconditional runtime.Gosched() with conditional yielding (every 8 attempts)
- Add PushOpposite() method to push UNUSABLE connections to opposite end
- Update Put logic to use PushOpposite for UNUSABLE connections
- Reduces Gosched overhead by ~87.5%

Author: ndyakov

internal/pool/lockfree_queue.go

@@ -102,27 +102,54 @@ func (q *lockFreeQueue) Push(cn *Conn) bool {
 	if cn == nil {
 		return false
 	}
-	
+
 	// Check capacity before attempting to add
 	if q.capacity > 0 {
 		currentSize := q.size.Load()
 		if currentSize >= q.capacity {
 			return false
 		}
 	}
-	
+
 	if q.fifo {
 		return q.pushFIFO(cn)
 	}
 	return q.pushLIFO(cn)
 }
 
+// PushOpposite adds a connection to the opposite end of the queue.
+// This is useful for UNUSABLE connections that should not be immediately popped.
+// Returns true if successful, false if queue is at capacity.
+// Thread-safe and lock-free.
+func (q *lockFreeQueue) PushOpposite(cn *Conn) bool {
+	if cn == nil {
+		return false
+	}
+
+	// Check capacity before attempting to add
+	if q.capacity > 0 {
+		currentSize := q.size.Load()
+		if currentSize >= q.capacity {
+			return false
+		}
+	}
+
+	// Push to opposite end
+	if q.fifo {
+		// FIFO mode: normal push is to tail, opposite is to head
+		return q.pushLIFO(cn)
+	}
+	// LIFO mode: normal push is to head, opposite is to tail
+	return q.pushFIFO(cn)
+}
+
 // pushFIFO implements lock-free FIFO push (enqueue at tail).
 // Based on Michael-Scott queue algorithm.
 func (q *lockFreeQueue) pushFIFO(cn *Conn) bool {
 	// Get node from pool instead of allocating
 	node := getNode(cn)
 
+	attempts := 0
 	for {
 		tail := q.tail.Load()
 		next := tail.next.Load()
@@ -145,8 +172,11 @@ func (q *lockFreeQueue) pushFIFO(cn *Conn) bool {
 				q.tail.CompareAndSwap(tail, next)
 			}
 		}
-		// Yield to prevent livelock under high contention
-		runtime.Gosched()
+		// Yield only after multiple attempts to reduce overhead
+		attempts++
+		if attempts&7 == 0 { // Every 8 attempts
+			runtime.Gosched()
+		}
 	}
 }
 
@@ -156,6 +186,7 @@ func (q *lockFreeQueue) pushLIFO(cn *Conn) bool {
 	// Get node from pool instead of allocating
 	node := getNode(cn)
 
+	attempts := 0
 	for {
 		head := q.head.Load()
 		node.next.Store(head)
@@ -165,8 +196,11 @@ func (q *lockFreeQueue) pushLIFO(cn *Conn) bool {
 			q.size.Add(1)
 			return true
 		}
-		// Yield to prevent livelock under high contention
-		runtime.Gosched()
+		// Yield only after multiple attempts to reduce overhead
+		attempts++
+		if attempts&7 == 0 { // Every 8 attempts
+			runtime.Gosched()
+		}
 	}
 }
 
@@ -182,6 +216,7 @@ func (q *lockFreeQueue) Pop() *Conn {
 
 // popFIFO implements lock-free FIFO pop (dequeue from head).
 func (q *lockFreeQueue) popFIFO() *Conn {
+	attempts := 0
 	for {
 		head := q.head.Load()
 		tail := q.tail.Load()
@@ -202,7 +237,10 @@ func (q *lockFreeQueue) popFIFO() *Conn {
 				// But next could be nil if another thread just popped
 				if next == nil {
 					// Retry - another thread modified the queue
-					runtime.Gosched()
+					attempts++
+					if attempts&7 == 0 {
+						runtime.Gosched()
+					}
 					continue
 				}
 
@@ -223,13 +261,17 @@ func (q *lockFreeQueue) popFIFO() *Conn {
 				}
 			}
 		}
-		// Yield to prevent livelock under high contention
-		runtime.Gosched()
+		// Yield only after multiple attempts to reduce overhead
+		attempts++
+		if attempts&7 == 0 { // Every 8 attempts
+			runtime.Gosched()
+		}
 	}
 }
 
 // popLIFO implements lock-free LIFO pop (pop from head).
 func (q *lockFreeQueue) popLIFO() *Conn {
+	attempts := 0
 	for {
 		head := q.head.Load()
 		if head == nil {
@@ -250,8 +292,11 @@ func (q *lockFreeQueue) popLIFO() *Conn {
 
 			return conn
 		}
-		// Yield to prevent livelock under high contention
-		runtime.Gosched()
+		// Yield only after multiple attempts to reduce overhead
+		attempts++
+		if attempts&7 == 0 { // Every 8 attempts
+			runtime.Gosched()
+		}
 	}
 }
 

internal/pool/pool.go

@@ -691,7 +691,7 @@ func (p *ConnPool) putConn(ctx context.Context, cn *Conn, freeTurn bool) {
 		// Handle different connection states:
 		// - CREATED: New connection, never used yet - transition to IDLE
 		// - IN_USE: Normal case after Get() - transition to IDLE
-		// - UNUSABLE: Temporary state (handoff/reauth) - keep as-is and pool it (will become usable later)
+		// - UNUSABLE: Temporary state (handoff/reauth) - keep as-is and pool at opposite end
 		// - IDLE: Already idle (shouldn't happen but handle it)
 		// - Other states: Remove the connection
 
@@ -704,7 +704,7 @@ func (p *ConnPool) putConn(ctx context.Context, cn *Conn, freeTurn bool) {
 				p.removeConnWithLock(cn)
 				shouldCloseConn = true
 			} else {
-				// Successfully transitioned to IDLE, add to pool
+				// Successfully transitioned to IDLE, add to pool at normal end
 				if !p.idleQueue.Push(cn) {
 					internal.Logger.Printf(ctx, "redis: connection pool: idle queue full, removing connection")
 					p.removeConnWithLock(cn)
@@ -713,9 +713,18 @@ func (p *ConnPool) putConn(ctx context.Context, cn *Conn, freeTurn bool) {
 					p.idleConnsLen.Add(1)
 				}
 			}
-		} else if currentState == StateUnusable || currentState == StateIdle {
-			// UNUSABLE: Pool it as-is (will become usable after handoff/reauth completes)
-			// IDLE: Already idle, just pool it
+		} else if currentState == StateUnusable {
+			// UNUSABLE: Pool at opposite end so it's not immediately popped
+			// This gives the connection time to become usable after handoff/reauth completes
+			if !p.idleQueue.PushOpposite(cn) {
+				internal.Logger.Printf(ctx, "redis: connection pool: idle queue full, removing unusable connection")
+				p.removeConnWithLock(cn)
+				shouldCloseConn = true
+			} else {
+				p.idleConnsLen.Add(1)
+			}
+		} else if currentState == StateIdle {
+			// IDLE: Already idle, just pool it at normal end
 			if !p.idleQueue.Push(cn) {
 				internal.Logger.Printf(ctx, "redis: connection pool: idle queue full, removing connection")
 				p.removeConnWithLock(cn)