rpc: remove another sort from VerifyClockOffsets

We can calculate the median absolute deviation without re-sorting. The
code is a bit more complicated, but it does seem to be a win for the
benchmark.

```
goos: darwin
goarch: arm64
cpu: Apple M1 Pro
                  │  before.txt  │              after.txt               │
                  │    sec/op    │    sec/op     vs base                │
VerifyClockOffset   101.90µ ± 2%   84.69µ ± 20%  -16.88% (p=0.009 n=20)

                  │  before.txt  │              after.txt              │
                  │     B/op     │     B/op      vs base               │
VerifyClockOffset   16.10Ki ± 0%   16.07Ki ± 0%  -0.19% (p=0.000 n=20)

                  │ before.txt │           after.txt            │
                  │ allocs/op  │ allocs/op   vs base            │
VerifyClockOffset   1.000 ± 0%   1.000 ± 0%  ~ (p=1.000 n=20) ¹
¹ all samples are equal
```

Epic: none
Release note: None

Author: stevendanna

pkg/rpc/clock_offset.go

@@ -369,8 +369,7 @@ func (r *RemoteClockMonitor) VerifyClockOffset(ctx context.Context) error {
 	mean := sum / float64(len(offsets))
 	stdDev := StandardDeviationPopulationKnownMean(offsets, mean)
 	median := MedianSortedInput(offsets)
-	// WARNING: offsets is unusable after this point as it has been modified.
-	medianAbsoluteDeviation := MedianAbsoluteDeviationPopulationSortedInputMutatesInput(offsets)
+	medianAbsoluteDeviation := MedianAbsoluteDeviationPopulationSortedInput(offsets)
 
 	r.metrics.ClockOffsetMeanNanos.Update(int64(mean))
 	r.metrics.ClockOffsetStdDevNanos.Update(int64(stdDev))
@@ -517,21 +516,36 @@ func MedianSortedInput(sortedInput stats.Float64Data) float64 {
 	}
 }
 
-// MedianAbsoluteDeviationPopulationSortedInputMutatesInput calculates the
-// median absolute deviation from a pre-sorted population.
-//
-// WARNING: This function mutates its input to avoid further allocations.
-func MedianAbsoluteDeviationPopulationSortedInputMutatesInput(
-	sortedInput stats.Float64Data,
-) float64 {
-	if sortedInput.Len() == 0 {
+// MedianAbsoluteDeviationPopulationSortedInput calculates the median absolute
+// deviation from a pre-sorted population.
+func MedianAbsoluteDeviationPopulationSortedInput(sortedInput stats.Float64Data) float64 {
+	switch sortedInput.Len() {
+	case 0:
 		return math.NaN()
+	case 1:
+		return 0
 	}
 
 	m := MedianSortedInput(sortedInput)
-	for key, value := range sortedInput {
-		sortedInput[key] = math.Abs(value - m)
+	a := sortedInput
+
+	// Peal off the largest difference on either end until we reach the midpoint(s).
+	last := 0.0
+	for len(a) > (len(sortedInput) / 2) {
+		leftDiff := m - a[0]
+		rightDiff := a[len(a)-1] - m
+		if leftDiff >= rightDiff {
+			last = leftDiff
+			a = a[1:]
+		} else {
+			last = rightDiff
+			a = a[:len(a)-1]
+		}
+	}
+
+	if len(sortedInput)%2 == 1 {
+		return last
+	} else {
+		return (max(m-a[0], a[len(a)-1]-m) + last) * 0.5
 	}
-	sort.Float64s(sortedInput)
-	return MedianSortedInput(sortedInput)
 }

pkg/rpc/clock_offset_test.go

@@ -321,8 +321,8 @@ func TestStatsFuncs(t *testing.T) {
 		floatWithinReasonableTolerance(t, theirVar, ourVar)
 	})
 
-	t.Run("MedianAbsoluteDeviationPopulationSortedInputMutatesInput", func(t *testing.T) {
-		ourMedAbsDev := MedianAbsoluteDeviationPopulationSortedInputMutatesInput(sortedData)
+	t.Run("MedianAbsoluteDeviationPopulationSortedInput", func(t *testing.T) {
+		ourMedAbsDev := MedianAbsoluteDeviationPopulationSortedInput(sortedData)
 		theirMedianAbsDev, err := stats.MedianAbsoluteDeviationPopulation(data)
 		require.NoError(t, err)
 		floatWithinReasonableTolerance(t, theirMedianAbsDev, ourMedAbsDev)