Upgrade versions of vendored libs

vendor/github.com/cockroachdb/pebble/internal/cache/clockpro.go

@@ -33,7 +33,7 @@ import (
 type fileKey struct {
 	// id is the namespace for fileNums.
 	id      uint64
-	fileNum base.FileNum
+	fileNum base.DiskFileNum
 }
 
 type key struct {
@@ -113,7 +113,7 @@ type shard struct {
 	countTest int64
 }
 
-func (c *shard) Get(id uint64, fileNum base.FileNum, offset uint64) Handle {
+func (c *shard) Get(id uint64, fileNum base.DiskFileNum, offset uint64) Handle {
 	c.mu.RLock()
 	var value *Value
 	if e := c.blocks.Get(key{fileKey{id, fileNum}, offset}); e != nil {
@@ -131,7 +131,7 @@ func (c *shard) Get(id uint64, fileNum base.FileNum, offset uint64) Handle {
 	return Handle{value: value}
 }
 
-func (c *shard) Set(id uint64, fileNum base.FileNum, offset uint64, value *Value) Handle {
+func (c *shard) Set(id uint64, fileNum base.DiskFileNum, offset uint64, value *Value) Handle {
 	if n := value.refs(); n != 1 {
 		panic(fmt.Sprintf("pebble: Value has already been added to the cache: refs=%d", n))
 	}
@@ -222,7 +222,7 @@ func (c *shard) checkConsistency() {
 }
 
 // Delete deletes the cached value for the specified file and offset.
-func (c *shard) Delete(id uint64, fileNum base.FileNum, offset uint64) {
+func (c *shard) Delete(id uint64, fileNum base.DiskFileNum, offset uint64) {
 	// The common case is there is nothing to delete, so do a quick check with
 	// shared lock.
 	k := key{fileKey{id, fileNum}, offset}
@@ -246,7 +246,7 @@ func (c *shard) Delete(id uint64, fileNum base.FileNum, offset uint64) {
 }
 
 // EvictFile evicts all of the cache values for the specified file.
-func (c *shard) EvictFile(id uint64, fileNum base.FileNum) {
+func (c *shard) EvictFile(id uint64, fileNum base.DiskFileNum) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
@@ -603,7 +603,7 @@ type Metrics struct {
 // efficient eviction of all of the blocks for a file which is used when an
 // sstable is deleted from disk.
 //
-// Memory Management
+// # Memory Management
 //
 // In order to reduce pressure on the Go GC, manual memory management is
 // performed for the data stored in the cache. Manual memory management is
@@ -639,9 +639,9 @@ type Cache struct {
 // creator of the cache should usually release their reference after the DB is
 // created.
 //
-//   c := cache.New(...)
-//   defer c.Unref()
-//   d, err := pebble.Open(pebble.Options{Cache: c})
+//	c := cache.New(...)
+//	defer c.Unref()
+//	d, err := pebble.Open(pebble.Options{Cache: c})
 func New(size int64) *Cache {
 	return newShards(size, 2*runtime.GOMAXPROCS(0))
 }
@@ -683,7 +683,7 @@ func newShards(size int64, shards int) *Cache {
 	return c
 }
 
-func (c *Cache) getShard(id uint64, fileNum base.FileNum, offset uint64) *shard {
+func (c *Cache) getShard(id uint64, fileNum base.DiskFileNum, offset uint64) *shard {
 	if id == 0 {
 		panic("pebble: 0 cache ID is invalid")
 	}
@@ -698,10 +698,11 @@ func (c *Cache) getShard(id uint64, fileNum base.FileNum, offset uint64) *shard
 		h ^= uint64(id & 0xff)
 		id >>= 8
 	}
+	fileNumVal := uint64(fileNum.FileNum())
 	for i := 0; i < 8; i++ {
 		h *= prime64
-		h ^= uint64(fileNum & 0xff)
-		fileNum >>= 8
+		h ^= uint64(fileNumVal) & 0xff
+		fileNumVal >>= 8
 	}
 	for i := 0; i < 8; i++ {
 		h *= prime64
@@ -738,7 +739,7 @@ func (c *Cache) Unref() {
 
 // Get retrieves the cache value for the specified file and offset, returning
 // nil if no value is present.
-func (c *Cache) Get(id uint64, fileNum base.FileNum, offset uint64) Handle {
+func (c *Cache) Get(id uint64, fileNum base.DiskFileNum, offset uint64) Handle {
 	return c.getShard(id, fileNum, offset).Get(id, fileNum, offset)
 }
 
@@ -746,17 +747,17 @@ func (c *Cache) Get(id uint64, fileNum base.FileNum, offset uint64) Handle {
 // existing value if present. A Handle is returned which provides faster
 // retrieval of the cached value than Get (lock-free and avoidance of the map
 // lookup). The value must have been allocated by Cache.Alloc.
-func (c *Cache) Set(id uint64, fileNum base.FileNum, offset uint64, value *Value) Handle {
+func (c *Cache) Set(id uint64, fileNum base.DiskFileNum, offset uint64, value *Value) Handle {
 	return c.getShard(id, fileNum, offset).Set(id, fileNum, offset, value)
 }
 
 // Delete deletes the cached value for the specified file and offset.
-func (c *Cache) Delete(id uint64, fileNum base.FileNum, offset uint64) {
+func (c *Cache) Delete(id uint64, fileNum base.DiskFileNum, offset uint64) {
 	c.getShard(id, fileNum, offset).Delete(id, fileNum, offset)
 }
 
 // EvictFile evicts all of the cache values for the specified file.
-func (c *Cache) EvictFile(id uint64, fileNum base.FileNum) {
+func (c *Cache) EvictFile(id uint64, fileNum base.DiskFileNum) {
 	if id == 0 {
 		panic("pebble: 0 cache ID is invalid")
 	}

vendor/github.com/cockroachdb/pebble/internal/cache/entry.go

@@ -30,7 +30,7 @@ func (p entryType) String() string {
 // Using manual memory management for entries is technically a volation of the
 // Cgo pointer rules:
 //
-//   https://golang.org/cmd/cgo/#hdr-Passing_pointers
+//	https://golang.org/cmd/cgo/#hdr-Passing_pointers
 //
 // Specifically, Go pointers should not be stored in C allocated memory. The
 // reason for this rule is that the Go GC will not look at C allocated memory

vendor/github.com/cockroachdb/pebble/internal/cache/robin_hood.go

@@ -24,7 +24,7 @@ func robinHoodHash(k key, shift uint32) uint32 {
 	const m = 11400714819323198485
 	h := hashSeed
 	h ^= k.id * m
-	h ^= uint64(k.fileNum) * m
+	h ^= uint64(k.fileNum.FileNum()) * m
 	h ^= k.offset * m
 	return uint32(h >> shift)
 }
@@ -95,11 +95,11 @@ func (e robinHoodEntries) free() {
 // table is 2, maxDist is computed as 4 and the actual size of the entry slice
 // is 6.
 //
-//   +---+---+---+---+---+---+
-//   | 0 | 1 | 2 | 3 | 4 | 5 |
-//   +---+---+---+---+---+---+
-//           ^
-//          size
+//	+---+---+---+---+---+---+
+//	| 0 | 1 | 2 | 3 | 4 | 5 |
+//	+---+---+---+---+---+---+
+//	        ^
+//	       size
 //
 // In this scenario, the target entry for a key will always be in the range
 // [0,1]. Valid entries may reside in the range [0,4] due to the linear probing