kvserver/gc: partially migrate to MVCCRangeKeyStack

Some parts require invasive changes to MVCC stats helpers. These will
shortly be consolidated with other MVCC stats logic elsewhere, so the
existing logic is retained for now by using `AsRangeKeyValues()`.

Release note: None

pkg/kv/kvserver/gc/gc.go

@@ -855,6 +855,7 @@ func processReplicatedRangeTombstones(
 		if !ok {
 			break
 		}
+		// TODO(erikgrinaker): Rewrite to use MVCCRangeKeyStack.
 		rangeKeys := iter.RangeKeys().AsRangeKeyValues()
 
 		if idx := sort.Search(len(rangeKeys), func(i int) bool {

pkg/kv/kvserver/gc/gc_iterator.go

@@ -11,7 +11,6 @@
 package gc
 
 import (
-	"sort"
 	"strings"
 
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/rditer"
@@ -193,15 +192,13 @@ func (it *gcIterator) currentRangeTS() hlc.Timestamp {
 	if rangeTombstoneStartKey.Equal(it.cachedRangeTombstoneKey) {
 		return it.cachedRangeTombstoneTS
 	}
+	it.cachedRangeTombstoneKey = append(it.cachedRangeTombstoneKey[:0], rangeTombstoneStartKey...)
 
-	it.cachedRangeTombstoneTS = hlc.Timestamp{}
-	rangeKeys := it.it.RangeKeys().AsRangeKeyValues()
-	if idx := sort.Search(len(rangeKeys), func(i int) bool {
-		return rangeKeys[i].RangeKey.Timestamp.LessEq(it.threshold)
-	}); idx < len(rangeKeys) {
-		it.cachedRangeTombstoneTS = rangeKeys[idx].RangeKey.Timestamp
+	if v, ok := it.it.RangeKeys().FirstBelow(it.threshold); ok {
+		it.cachedRangeTombstoneTS = v.Timestamp
+	} else {
+		it.cachedRangeTombstoneTS = hlc.Timestamp{}
 	}
-	it.cachedRangeTombstoneKey = append(it.cachedRangeTombstoneKey[:0], rangeTombstoneStartKey...)
 	return it.cachedRangeTombstoneTS
 }
 

pkg/kv/kvserver/gc/gc_random_test.go

@@ -466,12 +466,12 @@ func getExpectationsGenerator(
 						// so we will add them to history of current key for analysis.
 						// Bare range tombstones are ignored.
 						if r {
-							for _, r := range it.RangeKeys().AsRangeKeyValues() {
+							for _, r := range it.RangeKeys().AsRangeKeys() {
 								history = append(history, historyItem{
 									MVCCKeyValue: storage.MVCCKeyValue{
 										Key: storage.MVCCKey{
-											Key:       r.RangeKey.StartKey,
-											Timestamp: r.RangeKey.Timestamp,
+											Key:       r.StartKey,
+											Timestamp: r.Timestamp,
 										},
 										Value: nil,
 									},
@@ -622,13 +622,8 @@ func rangeFragmentsFromIt(t *testing.T, it storage.MVCCIterator) [][]storage.MVC
 		if !ok {
 			break
 		}
-		_, r := it.HasPointAndRange()
-		if r {
-			fragments := make([]storage.MVCCRangeKeyValue, len(it.RangeKeys().AsRangeKeyValues()))
-			for i, r := range it.RangeKeys().AsRangeKeyValues() {
-				fragments[i] = r.Clone()
-			}
-			result = append(result, fragments)
+		if _, hasRange := it.HasPointAndRange(); hasRange {
+			result = append(result, it.RangeKeys().Clone().AsRangeKeyValues())
 		}
 		it.NextKey()
 	}

pkg/kv/kvserver/gc/gc_test.go

@@ -1084,20 +1084,20 @@ func engineData(t *testing.T, r storage.Reader, desc roachpb.RangeDescriptor) []
 		_, r := rangeIt.HasPointAndRange()
 		if r {
 			span := rangeIt.RangeBounds()
-			newKeys := rangeIt.RangeKeys().AsRangeKeyValues()
+			newKeys := rangeIt.RangeKeys().AsRangeKeys()
 			if lastEnd.Equal(span.Key) {
 				// Try merging keys by timestamp.
 				var newPartial []storage.MVCCRangeKey
 				i, j := 0, 0
 				for i < len(newKeys) && j < len(partialRangeKeys) {
-					switch newKeys[i].RangeKey.Timestamp.Compare(partialRangeKeys[j].Timestamp) {
+					switch newKeys[i].Timestamp.Compare(partialRangeKeys[j].Timestamp) {
 					case 1:
-						newPartial = append(newPartial, newKeys[i].RangeKey.Clone())
+						newPartial = append(newPartial, newKeys[i].Clone())
 						i++
 					case 0:
 						newPartial = append(newPartial, storage.MVCCRangeKey{
 							StartKey:  partialRangeKeys[j].StartKey,
-							EndKey:    newKeys[i].RangeKey.EndKey.Clone(),
+							EndKey:    newKeys[i].EndKey.Clone(),
 							Timestamp: partialRangeKeys[j].Timestamp,
 						})
 						i++
@@ -1108,7 +1108,7 @@ func engineData(t *testing.T, r storage.Reader, desc roachpb.RangeDescriptor) []
 					}
 				}
 				for ; i < len(newKeys); i++ {
-					newPartial = append(newPartial, newKeys[i].RangeKey.Clone())
+					newPartial = append(newPartial, newKeys[i].Clone())
 				}
 				for ; j < len(partialRangeKeys); j++ {
 					newPartial = append(newPartial, partialRangeKeys[j].Clone())
@@ -1118,7 +1118,7 @@ func engineData(t *testing.T, r storage.Reader, desc roachpb.RangeDescriptor) []
 				result = append(result, makeRangeCells(partialRangeKeys)...)
 				partialRangeKeys = make([]storage.MVCCRangeKey, len(newKeys))
 				for i, rk := range newKeys {
-					partialRangeKeys[i] = rk.RangeKey.Clone()
+					partialRangeKeys[i] = rk.Clone()
 				}
 			}
 			lastEnd = span.EndKey.Clone()

pkg/storage/mvcc.go

@@ -4599,18 +4599,15 @@ func MVCCGarbageCollect(
 		if ms != nil {
 			// We need to iterate ranges only to compute GCBytesAge if we are updating
 			// stats.
+			//
+			// TODO(erikgrinaker): Rewrite to use MVCCRangeKeyStack.
 			if _, hasRange := iter.HasPointAndRange(); hasRange && !lastRangeTombstoneStart.Equal(iter.RangeBounds().Key) {
-				rangeKeys := iter.RangeKeys().AsRangeKeyValues()
-				newLen := len(rangeKeys)
-				if cap(rangeTombstoneTss) < newLen {
-					rangeTombstoneTss = make([]hlc.Timestamp, newLen)
-				} else {
-					rangeTombstoneTss = rangeTombstoneTss[:newLen]
-				}
-				for i, rkv := range rangeKeys {
-					rangeTombstoneTss[i] = rkv.RangeKey.Timestamp
+				rangeKeys := iter.RangeKeys()
+				lastRangeTombstoneStart = append(lastRangeTombstoneStart[:0], rangeKeys.Bounds.Key...)
+				rangeTombstoneTss = rangeTombstoneTss[:0]
+				for _, v := range rangeKeys.Versions {
+					rangeTombstoneTss = append(rangeTombstoneTss, v.Timestamp)
 				}
-				lastRangeTombstoneStart = append(lastRangeTombstoneStart[:0], rangeKeys[0].RangeKey.StartKey...)
 			} else if !hasRange {
 				lastRangeTombstoneStart = lastRangeTombstoneStart[:0]
 				rangeTombstoneTss = rangeTombstoneTss[:0]
@@ -4816,6 +4813,7 @@ func MVCCGarbageCollectRangeKeys(
 				break
 			}
 
+			// TODO(erikgrinaker): Rewrite to use MVCCRangeKeyStack.
 			bounds := iter.RangeBounds()
 			unsafeRangeKeys := iter.RangeKeys().AsRangeKeyValues()
 

pkg/storage/mvcc_test.go

@@ -5763,9 +5763,9 @@ func TestMVCCGarbageCollectRanges(t *testing.T) {
 						if !ok {
 							break
 						}
-						for _, rkv := range it.RangeKeys().AsRangeKeyValues() {
-							require.Less(t, expectIndex, len(d.after), "not enough expectations; at unexpected range:", rkv.RangeKey.String())
-							require.EqualValues(t, d.after[expectIndex], rkv.RangeKey, "range key is not equal")
+						for _, rk := range it.RangeKeys().AsRangeKeys() {
+							require.Less(t, expectIndex, len(d.after), "not enough expectations; at unexpected range: %s", rk)
+							require.EqualValues(t, d.after[expectIndex], rk, "range key is not equal")
 							expectIndex++
 						}
 					}