SimpleSeq.Seek: fast-path for count=1 case (#19101)

`SimpleSequence.search` is read on `erigon snapshots
check-commitment-hist-at-blk-range` profiler

```
	// Real data lengths:
	//   - 70% len=1
	//   - 15% len=2
	//   - ...
	//
	// Real data return `idx`:
	//   - 85% return idx=0 (first element)
	//   - 10% return "not found"
	//   - 5% other lengths
	//
	// As a result: early-check for `max` + full-scan search instead of `sort.Search`
```

Add fast-path for `len=1`:
```
                                       │  old0.txt   │               new.txt               │
                                     │   sec/op    │   sec/op     vs base                │
SimpleSequenceSeek/n=1/hit_first-16    2.975n ± 0%   2.381n ± 0%  -19.97% (p=0.000 n=10)
SimpleSequenceSeek/n=1/hit_mid-16      2.970n ± 0%   2.387n ± 1%  -19.63% (p=0.000 n=10)
SimpleSequenceSeek/n=1/hit_last-16     2.999n ± 3%   2.391n ± 0%  -20.29% (p=0.000 n=10)
SimpleSequenceSeek/n=1/miss-16         2.772n ± 0%   2.371n ± 0%  -14.48% (p=0.000 n=10)
SimpleSequenceSeek/n=2/hit_first-16    3.570n ± 0%   2.405n ± 1%  -32.62% (p=0.000 n=10)
SimpleSequenceSeek/n=2/hit_mid-16      3.762n ± 0%   4.088n ± 0%   +8.68% (p=0.000 n=10)
SimpleSequenceSeek/n=2/hit_last-16     3.765n ± 0%   4.081n ± 0%   +8.38% (p=0.000 n=10)
SimpleSequenceSeek/n=2/miss-16         2.772n ± 0%   2.970n ± 0%   +7.16% (p=0.000 n=10)
SimpleSequenceSeek/n=4/hit_first-16    4.351n ± 0%   2.389n ± 1%  -45.08% (p=0.000 n=10)
SimpleSequenceSeek/n=4/hit_mid-16      3.768n ± 0%   4.037n ± 0%   +7.15% (p=0.000 n=10)
SimpleSequenceSeek/n=4/hit_last-16     3.766n ± 0%   4.010n ± 0%   +6.48% (p=0.000 n=10)
SimpleSequenceSeek/n=4/miss-16         3.364n ± 0%   3.748n ± 0%  +11.40% (p=0.000 n=10)
SimpleSequenceSeek/n=16/hit_first-16   6.281n ± 1%   2.394n ± 0%  -61.89% (p=0.000 n=10)
SimpleSequenceSeek/n=16/hit_mid-16     5.774n ± 0%   5.665n ± 0%   -1.89% (p=0.000 n=10)
SimpleSequenceSeek/n=16/hit_last-16    5.915n ± 1%   5.755n ± 0%   -2.70% (p=0.000 n=10)
SimpleSequenceSeek/n=16/miss-16        5.531n ± 0%   5.221n ± 0%   -5.61% (p=0.000 n=10)
geomean                                3.871n        3.328n       -14.01%

                                     │   old0.txt   │               new.txt               │
```

---- 
Brude-Force search (decided to not go for it):
```
SimpleSequenceSeek/n=4/hit_first-16    4.758n ±  0%    1.883n ± 2%  -60.42% (p=0.000 n=10)
SimpleSequenceSeek/n=4/hit_mid-16      4.000n ±  0%    2.865n ± 1%  -28.36% (p=0.000 n=10)
SimpleSequenceSeek/n=4/hit_last-16     4.163n ±  0%    3.523n ± 2%  -15.38% (p=0.000 n=10)
SimpleSequenceSeek/n=4/miss-16         1.991n ± 10%    1.321n ± 4%  -33.64% (p=0.000 n=10)
SimpleSequenceSeek/n=16/hit_first-16   6.138n ±  0%    1.889n ± 2%  -69.22% (p=0.000 n=10)
SimpleSequenceSeek/n=16/hit_mid-16     5.742n ±  0%    6.240n ± 2%   +8.66% (p=0.000 n=10)
SimpleSequenceSeek/n=16/hit_last-16    5.814n ±  0%   10.425n ± 3%  +79.29% (p=0.000 n=10)
SimpleSequenceSeek/n=16/miss-16        2.000n ±  9%    1.336n ± 8%  -33.22% (p=0.000 n=10)
```
also i did take a look real data distribution on mainnet:
```
	// Real data lengths:
	//   - 70% len=1
	//   - 15% len=2
	//   - ...
	//
	// Real data return `idx`:
	//   - 85% return idx=0 (first element)
	//   - 10% return "not found"
	//   - 5% other lengths
	//
	// As a result: early-check for `max` + full-scan search instead of `sort.Search`
```

Author: AskAlexSharov

db/recsplit/simpleseq/simple_sequence.go

@@ -17,13 +17,15 @@ type SimpleSequence struct {
 	baseNum uint64
 	raw     []byte
 	pos     int
+	count   uint64 //u64-typed pre-calculated `len(raw)/4`
 }
 
 func NewSimpleSequence(baseNum uint64, count uint64) *SimpleSequence {
 	return &SimpleSequence{
 		baseNum: baseNum,
 		raw:     make([]byte, count*4),
 		pos:     0,
+		count:   count,
 	}
 }
 
@@ -37,60 +39,74 @@ func ReadSimpleSequence(baseNum uint64, raw []byte) *SimpleSequence {
 }
 
 func (s *SimpleSequence) Get(i uint64) uint64 {
-	idx := i * 4
-	delta := binary.BigEndian.Uint32(s.raw[idx : idx+4])
-	return s.baseNum + uint64(delta)
+	delta := uint64(binary.BigEndian.Uint32(s.raw[i*4:]))
+	return s.baseNum + delta
 }
 
 func (s *SimpleSequence) Min() uint64 {
-	return s.Get(0)
+	delta := uint64(binary.BigEndian.Uint32(s.raw))
+	return s.baseNum + delta
 }
 
 func (s *SimpleSequence) Max() uint64 {
-	return s.Get(s.Count() - 1)
+	delta := uint64(binary.BigEndian.Uint32(s.raw[len(s.raw)-4:]))
+	return s.baseNum + delta
 }
 
 func (s *SimpleSequence) Count() uint64 {
-	return uint64(len(s.raw) / 4)
+	return s.count
 }
+func (s *SimpleSequence) Empty() bool { return len(s.raw) == 0 }
 
 func (s *SimpleSequence) AddOffset(offset uint64) {
-	binary.BigEndian.PutUint32(s.raw[s.pos*4:(s.pos+1)*4], uint32(offset-s.baseNum))
+	binary.BigEndian.PutUint32(s.raw[s.pos*4:], uint32(offset-s.baseNum))
 	s.pos++
 }
 
 func (s *SimpleSequence) Reset(baseNum uint64, raw []byte) { // no `return parameter` to avoid heap-allocation of `s` object
 	s.baseNum = baseNum
 	s.raw = raw
 	s.pos = len(raw) / 4
+	s.count = uint64(len(raw) / 4)
 }
 
 func (s *SimpleSequence) AppendBytes(buf []byte) []byte {
 	return append(buf, s.raw...)
 }
 
-func (s *SimpleSequence) search(v uint64) (int, bool) {
-	c := s.Count()
-	idx := sort.Search(int(c), func(i int) bool {
-		return s.Get(uint64(i)) >= v
-	})
-
-	if idx >= int(c) {
+func (s *SimpleSequence) search(seek uint64) (idx int, ok bool) {
+	// Real data lengths:
+	//   - 70% len=1
+	//   - 15% len=2
+	//   - ...
+	//
+	// Real data return `idx`:
+	//   - 85% return idx=0 (first element)
+	//   - 10% return "not found"
+	//   - 5% other lengths
+	if seek <= s.Min() { // fast-path for 1-st element hit
+		return 0, true
+	}
+	if s.count == 1 { // if len=1 then nothing left to search
 		return 0, false
 	}
-	return idx, true
-}
-
-func (s *SimpleSequence) reverseSearch(v uint64) (int, bool) {
-	c := s.Count()
-	idx := sort.Search(int(c), func(i int) bool {
-		return s.Get(c-uint64(i)-1) <= v
+	idx = sort.Search(int(s.count), func(i int) bool {
+		return s.Get(uint64(i)) >= seek
 	})
+	return idx, idx < int(s.count)
+}
 
-	if idx >= int(c) {
+func (s *SimpleSequence) reverseSearch(seek uint64) (idx int, ok bool) {
+	if seek >= s.Max() { // fast-path for last element hit
+		return int(s.count) - 1, true
+	}
+	if s.count == 1 { // if len=1 then nothing left to search
 		return 0, false
 	}
-	return int(c) - idx - 1, true
+	idx = sort.Search(int(s.count), func(i int) bool {
+		return s.Get(uint64(i)) > seek
+	}) - 1
+	return idx, idx >= 0
 }
 
 func (s *SimpleSequence) Seek(v uint64) (uint64, bool) {

db/recsplit/simpleseq/simple_sequence_test.go

@@ -1,6 +1,7 @@
 package simpleseq
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -282,3 +283,69 @@ func TestSimpleSequence(t *testing.T) {
 		require.Equal(t, uint64(0), v)
 	})
 }
+
+func TestReadSimpleSequence(t *testing.T) {
+	// Build a sequence via NewSimpleSequence, serialize it, then deserialize via
+	// ReadSimpleSequence (which goes through Reset). Regression test for a bug
+	// where Reset did not update the cached `count` field, causing Count()==0 on
+	// deserialized sequences.
+	orig := NewSimpleSequence(1000, 4)
+	orig.AddOffset(1001)
+	orig.AddOffset(1007)
+	orig.AddOffset(1015)
+	orig.AddOffset(1027)
+
+	raw := orig.AppendBytes(nil)
+	s := ReadSimpleSequence(1000, raw)
+
+	require.Equal(t, uint64(4), s.Count())
+	require.Equal(t, uint64(1001), s.Min())
+	require.Equal(t, uint64(1027), s.Max())
+
+	v, found := s.Seek(1007)
+	require.True(t, found)
+	require.Equal(t, uint64(1007), v)
+
+	v, found = s.Seek(9999)
+	require.False(t, found)
+	require.Equal(t, uint64(0), v)
+}
+
+func makeSequence(n int) *SimpleSequence {
+	base := uint64(1_000_000)
+	s := NewSimpleSequence(base, uint64(n))
+	for i := 0; i < n; i++ {
+		s.AddOffset(base + uint64(i)*7 + 1)
+	}
+	return s
+}
+
+func BenchmarkSimpleSequenceSeek(b *testing.B) {
+	for _, size := range []int{1, 2, 4, 16} {
+		s := makeSequence(size)
+		minV := s.Min()
+		maxV := s.Max()
+		midV := s.Get(uint64(size / 2))
+
+		b.Run(fmt.Sprintf("n=%d/hit_first", size), func(b *testing.B) {
+			for b.Loop() {
+				s.Seek(minV)
+			}
+		})
+		b.Run(fmt.Sprintf("n=%d/hit_mid", size), func(b *testing.B) {
+			for b.Loop() {
+				s.Seek(midV)
+			}
+		})
+		b.Run(fmt.Sprintf("n=%d/hit_last", size), func(b *testing.B) {
+			for b.Loop() {
+				s.Seek(maxV)
+			}
+		})
+		b.Run(fmt.Sprintf("n=%d/miss", size), func(b *testing.B) {
+			for b.Loop() {
+				s.Seek(maxV + 1)
+			}
+		})
+	}
+}