internal/testkeys: move Slice, EveryN out of the interface

Move the Slice and EveryN funcs out of the Keyspace interface and into
top-level funcs that accept a Keyspace.

Author: jbowens

error_test.go

@@ -487,7 +487,7 @@ func TestDBCompactionCrash(t *testing.T) {
 		const valLength = 4 << 10
 		timestamps := []int{10, 5}
 		ks := testkeys.Alpha(maxKeyLength)
-		ks = ks.EveryN(10)
+		ks = testkeys.EveryN(ks, 10)
 		buf := make([]byte, ks.MaxLen()+testkeys.MaxSuffixLen)
 		vbuf := make([]byte, valLength)
 		b := d.NewBatch()

internal/testkeys/testkeys.go

@@ -189,14 +189,6 @@ type Keyspace interface {
 	// keyspace. This is only guaranteed to return an upper bound.
 	MaxLen() int
 
-	// Slice returns the sub-keyspace from index i, inclusive, to index j,
-	// exclusive. The receiver is unmodified.
-	Slice(i, j uint64) Keyspace
-
-	// EveryN returns a key space that includes 1 key for every N keys in the
-	// original keyspace. The receiver is unmodified.
-	EveryN(n uint64) Keyspace
-
 	// key writes the i-th key to the buffer and returns the length.
 	key(buf []byte, i uint64) int
 }
@@ -205,8 +197,8 @@ type Keyspace interface {
 // disjoint keys evenly distributed across the keyspace.
 func Divvy(ks Keyspace, n uint64) []Keyspace {
 	ret := make([]Keyspace, n)
-	for i := uint64(0); i < n; i++ {
-		ret[i] = ks.Slice(i, ks.Count()).EveryN(n)
+	for i := range n {
+		ret[i] = EveryN(Slice(ks, i, ks.Count()), n)
 	}
 	return ret
 }
@@ -312,19 +304,6 @@ func (a alphabet) MaxLen() int {
 	return a.maxLength
 }
 
-func (a alphabet) Slice(i, j uint64) Keyspace {
-	s := a
-	s.headSkip += i
-	s.tailSkip += a.Count() - j
-	return s
-}
-
-func (a alphabet) EveryN(n uint64) Keyspace {
-	s := a
-	s.increment *= n
-	return s
-}
-
 func keyCount(n, l int) uint64 {
 	// The number of representable keys in the keyspace is a function of the
 	// length of the alphabet n and the max key length l:
@@ -491,3 +470,70 @@ func assertLE(a, b []byte) {
 		panic(fmt.Sprintf("invalid key ordering: %q > %q", a, b))
 	}
 }
+
+// Slice returns the sub-keyspace from index i, inclusive, to index j,
+// exclusive. The receiver is unmodified.
+func Slice(ks Keyspace, i, j uint64) Keyspace {
+	if i >= ks.Count() || j > ks.Count() {
+		panic(errors.AssertionFailedf("invalid slice: [%d,%d) of keyspace with %d keys", i, j, ks.Count()))
+	}
+	return &sliceKeyspace{ks: ks, i: i, j: j}
+}
+
+type sliceKeyspace struct {
+	ks   Keyspace
+	i, j uint64
+}
+
+// Count returns the number of keys that exist within this keyspace.
+func (s *sliceKeyspace) Count() uint64 {
+	return s.j - s.i
+}
+
+// MaxLen returns the maximum length, in bytes, of a key within this
+// keyspace. This is only guaranteed to return an upper bound.
+func (s *sliceKeyspace) MaxLen() int {
+	return s.ks.MaxLen()
+}
+
+// key writes the i-th key to the buffer and returns the length.
+func (s *sliceKeyspace) key(buf []byte, i uint64) int {
+	return s.ks.key(buf, s.i+i)
+}
+
+// EveryN returns the keyspace consisting of every n-th key in the provided
+// keyspace.
+func EveryN(ks Keyspace, n uint64) Keyspace {
+	innerCount := ks.Count()
+	c := innerCount / n
+	// We are returning keys at index 0, n, 2n, ... up to cn (to be determined
+	// whether inclusive or exclusive), such that the last key is < innerCount.
+	// Since cn < innerCount, it becomes inclusive and we return c+1 keys (hence
+	// this increment).
+	if innerCount%n > 0 {
+		c++
+	}
+	return &everyNKeyspace{ks: ks, n: n, c: c}
+}
+
+type everyNKeyspace struct {
+	ks Keyspace
+	n  uint64
+	c  uint64
+}
+
+// Count returns the number of keys that exist within this keyspace.
+func (e everyNKeyspace) Count() uint64 {
+	return e.c
+}
+
+// MaxLen returns the maximum length, in bytes, of a key within this
+// keyspace. This is only guaranteed to return an upper bound.
+func (e everyNKeyspace) MaxLen() int {
+	return e.ks.MaxLen()
+}
+
+// key writes the i-th key to the buffer and returns the length.
+func (e everyNKeyspace) key(buf []byte, i uint64) int {
+	return e.ks.key(buf, i*e.n)
+}

internal/testkeys/testkeys_test.go

@@ -122,11 +122,11 @@ func TestSlice(t *testing.T) {
 		want string
 	}{
 		{Alpha(1), 1, 25, "b c d e f g h i j k l m n o p q r s t u v w x y"},
-		{Alpha(1).Slice(1, 25), 1, 23, "c d e f g h i j k l m n o p q r s t u v w x"},
-		{Alpha(1).Slice(1, 25).Slice(1, 23), 10, 22, "m n o p q r s t u v w x"},
+		{Slice(Alpha(1), 1, 25), 1, 23, "c d e f g h i j k l m n o p q r s t u v w x"},
+		{Slice(Slice(Alpha(1), 1, 25), 1, 23), 10, 22, "m n o p q r s t u v w x"},
 	}
 	for _, tc := range testCases {
-		got := keyspaceToString(tc.orig.Slice(tc.i, tc.j))
+		got := keyspaceToString(Slice(tc.orig, tc.i, tc.j))
 		if got != tc.want {
 			t.Errorf("(%q).Slice(%d, %d) = %q, want %q",
 				keyspaceToString(tc.orig), tc.i, tc.j, got, tc.want)

iterator_test.go

@@ -2469,7 +2469,7 @@ func BenchmarkIteratorScan(b *testing.B) {
 				// characters of lengths up to `maxPrefixLen` and reduce it down
 				// to `keyCount` keys by picking every 1 key every `keyCount` keys.
 				keys := testkeys.Alpha(maxPrefixLen)
-				keys = keys.EveryN(keys.Count() / keyCount)
+				keys = testkeys.EveryN(keys, keys.Count()/keyCount)
 				if keys.Count() < keyCount {
 					b.Fatalf("expected %d keys, found %d", keyCount, keys.Count())
 				}
@@ -2532,10 +2532,10 @@ func BenchmarkIteratorScanNextPrefix(b *testing.B) {
 		for l := readAmp; l > 0; l-- {
 			ks := testkeys.Alpha(l)
 			if step := ks.Count() / uint64(maxKeysPerLevel); step > 1 {
-				ks = ks.EveryN(step)
+				ks = testkeys.EveryN(ks, step)
 			}
 			if ks.Count() > uint64(maxKeysPerLevel) {
-				ks = ks.Slice(0, uint64(maxKeysPerLevel))
+				ks = testkeys.Slice(ks, 0, uint64(maxKeysPerLevel))
 			}
 
 			batch := d.NewBatch()

sstable/random_test.go

@@ -365,7 +365,7 @@ func buildRandomSSTable(f vfs.File, cfg randomTableConfig) (*WriterMetadata, err
 	// Constrain the space we generate keys to the middle 90% of the keyspace.
 	// This helps exercise code paths that are only run when a seek key is
 	// beyond or before all index block entries.
-	sstKeys := cfg.keys.Slice(cfg.keys.Count()/20, cfg.keys.Count()-cfg.keys.Count()/20)
+	sstKeys := testkeys.Slice(cfg.keys, cfg.keys.Count()/20, cfg.keys.Count()-cfg.keys.Count()/20)
 	randomKey := func() keyID {
 		k := keyID{
 			idx:    cfg.rng.Uint64N(sstKeys.Count()),

sstable/reader_test.go

@@ -2177,7 +2177,7 @@ func BenchmarkIteratorScanManyVersions(b *testing.B) {
 	// lengths up to unsharedPrefixLen and reduce it down to keyCount keys by
 	// picking every 1 key every keyCount keys.
 	keys := testkeys.Alpha(unsharedPrefixLen)
-	keys = keys.EveryN(keys.Count() / keyCount)
+	keys = testkeys.EveryN(keys, keys.Count()/keyCount)
 	if keys.Count() < keyCount {
 		b.Fatalf("expected %d keys, found %d", keyCount, keys.Count())
 	}
@@ -2297,7 +2297,7 @@ func BenchmarkIteratorScanNextPrefix(b *testing.B) {
 	// lengths up to unsharedPrefixLen and reduce it down to keyCount keys by
 	// picking every 1 key every keyCount keys.
 	keys := testkeys.Alpha(unsharedPrefixLen)
-	keys = keys.EveryN(keys.Count() / keyCount)
+	keys = testkeys.EveryN(keys, keys.Count()/keyCount)
 	if keys.Count() < keyCount {
 		b.Fatalf("expected %d keys, found %d", keyCount, keys.Count())
 	}
@@ -2464,7 +2464,7 @@ func BenchmarkIteratorScanObsolete(b *testing.B) {
 	// lengths up to unsharedPrefixLen and reduce it down to keyCount keys by
 	// picking every 1 key every keyCount keys.
 	keys := testkeys.Alpha(keyLen)
-	keys = keys.EveryN(keys.Count() / keyCount)
+	keys = testkeys.EveryN(keys, keys.Count()/keyCount)
 	if keys.Count() < keyCount {
 		b.Fatalf("expected %d keys, found %d", keyCount, keys.Count())
 	}

sstable/writer_test.go

@@ -1076,7 +1076,7 @@ func TestWriter_TableFormatCompatibility(t *testing.T) {
 func TestWriterRace(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 	ks := testkeys.Alpha(5)
-	ks = ks.EveryN(ks.Count() / 1_000)
+	ks = testkeys.EveryN(ks, ks.Count()/1_000)
 	keys := make([][]byte, ks.Count())
 	for ki := 0; ki < len(keys); ki++ {
 		keys[ki] = testkeys.Key(ks, uint64(ki))