Logarithmic timestamp comparison for ReplicSet downscaling

Change-Id: I0657ea0ce41b98fdee1a5307b5826a10deaff98c

pkg/controller/controller_utils.go

@@ -22,6 +22,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"hash/fnv"
+	"math"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -807,6 +808,10 @@ func (s ActivePods) Less(i, j int) bool {
 // 8. If the pods' creation times differ, the pod that was created more recently
 //    comes before the older pod.
 //
+// In 6 and 8, times are compared in a logarithmic scale. This allows a level
+// of randomness among equivalent Pods when sorting. If two pods have the same
+// logarithmic rank, they are sorted by UUID to provide a pseudorandom order.
+//
 // If none of these rules matches, the second pod comes before the first pod.
 //
 // The intention of this ordering is to put pods that should be preferred for
@@ -819,6 +824,10 @@ type ActivePodsWithRanks struct {
 	// comparing two pods that are both scheduled, in the same phase, and
 	// having the same ready status.
 	Rank []int
+
+	// Now is a reference timestamp for doing logarithmic timestamp comparisons.
+	// If zero, comparison happens without scaling.
+	Now metav1.Time
 }
 
 func (s ActivePodsWithRanks) Len() int {
@@ -872,7 +881,18 @@ func (s ActivePodsWithRanks) Less(i, j int) bool {
 		readyTime1 := podReadyTime(s.Pods[i])
 		readyTime2 := podReadyTime(s.Pods[j])
 		if !readyTime1.Equal(readyTime2) {
-			return afterOrZero(readyTime1, readyTime2)
+			if !utilfeature.DefaultFeatureGate.Enabled(features.LogarithmicScaleDown) {
+				return afterOrZero(readyTime1, readyTime2)
+			} else {
+				if s.Now.IsZero() || readyTime1.IsZero() || readyTime2.IsZero() {
+					return afterOrZero(readyTime1, readyTime2)
+				}
+				rankDiff := logarithmicRankDiff(*readyTime1, *readyTime2, s.Now)
+				if rankDiff == 0 {
+					return s.Pods[i].UID < s.Pods[j].UID
+				}
+				return rankDiff < 0
+			}
 		}
 	}
 	// 7. Pods with containers with higher restart counts < lower restart counts
@@ -881,7 +901,18 @@ func (s ActivePodsWithRanks) Less(i, j int) bool {
 	}
 	// 8. Empty creation time pods < newer pods < older pods
 	if !s.Pods[i].CreationTimestamp.Equal(&s.Pods[j].CreationTimestamp) {
-		return afterOrZero(&s.Pods[i].CreationTimestamp, &s.Pods[j].CreationTimestamp)
+		if !utilfeature.DefaultFeatureGate.Enabled(features.LogarithmicScaleDown) {
+			return afterOrZero(&s.Pods[i].CreationTimestamp, &s.Pods[j].CreationTimestamp)
+		} else {
+			if s.Now.IsZero() || s.Pods[i].CreationTimestamp.IsZero() || s.Pods[j].CreationTimestamp.IsZero() {
+				return afterOrZero(&s.Pods[i].CreationTimestamp, &s.Pods[j].CreationTimestamp)
+			}
+			rankDiff := logarithmicRankDiff(s.Pods[i].CreationTimestamp, s.Pods[j].CreationTimestamp, s.Now)
+			if rankDiff == 0 {
+				return s.Pods[i].UID < s.Pods[j].UID
+			}
+			return rankDiff < 0
+		}
 	}
 	return false
 }
@@ -895,6 +926,22 @@ func afterOrZero(t1, t2 *metav1.Time) bool {
 	return t1.After(t2.Time)
 }
 
+// logarithmicRankDiff calculates the base-2 logarithmic ranks of 2 timestamps,
+// compared to the current timestamp
+func logarithmicRankDiff(t1, t2, now metav1.Time) int64 {
+	d1 := now.Sub(t1.Time)
+	d2 := now.Sub(t2.Time)
+	r1 := int64(-1)
+	r2 := int64(-1)
+	if d1 > 0 {
+		r1 = int64(math.Log2(float64(d1)))
+	}
+	if d2 > 0 {
+		r2 = int64(math.Log2(float64(d2)))
+	}
+	return r1 - r2
+}
+
 func podReadyTime(pod *v1.Pod) *metav1.Time {
 	if podutil.IsPodReady(pod) {
 		for _, c := range pod.Status.Conditions {