100ms -> 50ms

Author: ndyakov

internal/pool/conn.go

@@ -18,9 +18,9 @@ import (
 
 var noDeadline = time.Time{}
 
-// Global time cache updated every 100ms by background goroutine.
+// Global time cache updated every 50ms by background goroutine.
 // This avoids expensive time.Now() syscalls in hot paths like getEffectiveReadTimeout.
-// Max staleness: 100ms, which is acceptable for timeout deadline checks (timeouts are typically 3-30 seconds).
+// Max staleness: 50ms, which is acceptable for timeout deadline checks (timeouts are typically 3-30 seconds).
 var globalTimeCache struct {
 	nowNs atomic.Int64
 }
@@ -49,7 +49,7 @@ func getCachedTimeNs() int64 {
 
 // GetCachedTimeNs returns the current time in nanoseconds from the global cache.
 // This is updated every 100ms by a background goroutine, avoiding expensive syscalls.
-// Max staleness: 100ms.
+// Max staleness: 50ms.
 // Exported for use by other packages that need fast time access.
 func GetCachedTimeNs() int64 {
 	return getCachedTimeNs()
@@ -499,7 +499,7 @@ func (cn *Conn) getEffectiveReadTimeout(normalTimeout time.Duration) time.Durati
 		return time.Duration(readTimeoutNs)
 	}
 
-	// Use cached time to avoid expensive syscall (max 100ms staleness is acceptable for timeout checks)
+	// Use cached time to avoid expensive syscall (max 50ms staleness is acceptable for timeout checks)
 	nowNs := getCachedTimeNs()
 	// Check if deadline has passed
 	if nowNs < deadlineNs {
@@ -533,7 +533,7 @@ func (cn *Conn) getEffectiveWriteTimeout(normalTimeout time.Duration) time.Durat
 		return time.Duration(writeTimeoutNs)
 	}
 
-	// Use cached time to avoid expensive syscall (max 100ms staleness is acceptable for timeout checks)
+	// Use cached time to avoid expensive syscall (max 50ms staleness is acceptable for timeout checks)
 	nowNs := getCachedTimeNs()
 	// Check if deadline has passed
 	if nowNs < deadlineNs {
@@ -725,7 +725,7 @@ func (cn *Conn) GetStateMachine() *ConnStateMachine {
 func (cn *Conn) TryAcquire() bool {
 	// The || operator short-circuits, so only 1 CAS in the common case
 	return cn.stateMachine.state.CompareAndSwap(uint32(StateIdle), uint32(StateInUse)) ||
-		cn.stateMachine.state.CompareAndSwap(uint32(StateCreated), uint32(StateCreated))
+		cn.stateMachine.state.Load() == uint32(StateCreated)
 }
 
 // Release releases the connection back to the pool.
@@ -829,19 +829,18 @@ func (cn *Conn) WithWriter(
 		// Use relaxed timeout if set, otherwise use provided timeout
 		effectiveTimeout := cn.getEffectiveWriteTimeout(timeout)
 
-		// Always set write deadline, even if getNetConn() returns nil
-		// This prevents write operations from hanging indefinitely
+		// Set write deadline on the connection
 		if netConn := cn.getNetConn(); netConn != nil {
 			if err := netConn.SetWriteDeadline(cn.deadline(ctx, effectiveTimeout)); err != nil {
 				return err
 			}
 		} else {
-			// If getNetConn() returns nil, we still need to respect the timeout
-			// Return an error to prevent indefinite blocking
+			// Connection is not available - return error
 			return fmt.Errorf("redis: conn[%d] not available for write operation", cn.GetID())
 		}
 	}
 
+	// Reset the buffered writer if needed, should not happen
 	if cn.bw.Buffered() > 0 {
 		if netConn := cn.getNetConn(); netConn != nil {
 			cn.bw.Reset(netConn)
@@ -890,7 +889,7 @@ func (cn *Conn) MaybeHasData() bool {
 
 // deadline computes the effective deadline time based on context and timeout.
 // It updates the usedAt timestamp to now.
-// Uses cached time to avoid expensive syscall (max 100ms staleness is acceptable for deadline calculation).
+// Uses cached time to avoid expensive syscall (max 50ms staleness is acceptable for deadline calculation).
 func (cn *Conn) deadline(ctx context.Context, timeout time.Duration) time.Time {
 	// Use cached time for deadline calculation (called 2x per command: read + write)
 	tm := time.Unix(0, getCachedTimeNs())

internal/pool/conn_used_at_test.go

@@ -22,7 +22,7 @@ func TestConn_UsedAtUpdatedOnRead(t *testing.T) {
 	// Get initial usedAt time
 	initialUsedAt := cn.UsedAt()
 
-	// Wait at least 100ms to ensure time difference (usedAt has ~50ms precision from cached time)
+	// Wait at least 50ms to ensure time difference (usedAt has ~50ms precision from cached time)
 	time.Sleep(100 * time.Millisecond)
 
 	// Simulate a read operation by calling WithReader
@@ -45,10 +45,10 @@ func TestConn_UsedAtUpdatedOnRead(t *testing.T) {
 			initialUsedAt, updatedUsedAt)
 	}
 
-	// Verify the difference is reasonable (should be around 100ms, accounting for ~50ms cache precision)
+	// Verify the difference is reasonable (should be around 50ms, accounting for ~50ms cache precision)
 	diff := updatedUsedAt.Sub(initialUsedAt)
 	if diff < 50*time.Millisecond || diff > 200*time.Millisecond {
-		t.Errorf("Expected usedAt difference to be around 100ms (±50ms for cache), got %v", diff)
+		t.Errorf("Expected usedAt difference to be around 50ms (±50ms for cache), got %v", diff)
 	}
 }