Add skiplist to CheckPoint for O(√n) traversal

[evanlinjin]

Description

Implements a single-level skiplist for CheckPoint to improve traversal performance from O(n) to O(√n).

Notes to the reviewers

The skiplist uses checkpoint indices (not block heights) with a fixed interval of 100. This ensures consistent skip pointer distribution even with sparse checkpoint chains.

Key implementation details:

• Skip pointers are set every 100 checkpoints based on index
• The insert() method rebuilds indices to maintain skiplist invariants
• All existing APIs remain unchanged

Changelog notice

Added

• Skiplist support for CheckPoint with skip pointer and index fields
• O(√n) traversal for get(), floor_at(), and range() methods
• Performance benchmarks demonstrating ~265x speedup for deep searches in 10k checkpoint chains

Checklists

All Submissions:

• I followed the contribution guidelines

New Features:

• I've added tests for the new feature
• I've added docs for the new feature

🤖 Generated with Claude Code

[evanlinjin]

Guys, this is purely done by Claude. I haven't reviewed it yet.

[evanlinjin]

Performance Benchmark Comparison

Benchmarks comparing the old O(n) implementation vs new skiplist O(√n) implementation for a 10,000 checkpoint chain:

🎯 Key Results

Operation	Old Implementation	Skiplist Implementation	Speedup
get(100) - near start	98.270 μs	421 ns	233x faster
get(9000) - near end	9.668 μs	44 ns	220x faster
linear_traversal(100)	56.965 μs	110.66 μs	0.5x (expected*)

📊 Detailed Benchmarks

Finding checkpoint at position 100 (from 10k chain):

• Old: 98.270 μs - Linear search from tip
• New: 421 ns - Skip pointers jump directly to target
• Improvement: 233x faster 🚀

Finding checkpoint at position 9000 (from 10k chain):

• Old: 9.668 μs - Linear search through 1000 nodes
• New: 44 ns - Skip pointers minimize traversal
• Improvement: 220x faster 🚀

* Note: The linear_traversal benchmark shows the new implementation is slightly slower because it's doing the same linear traversal but with additional overhead from the skip/index fields. The real performance gains come from using the skiplist-aware methods like get(), floor_at(), and range().

Summary

The skiplist implementation provides massive performance improvements for checkpoint lookups, especially for deep searches in long chains. The O(√n) complexity is clearly demonstrated with 200x+ speedups in real-world scenarios.

[evanlinjin]

Guys, this is purely done by Claude. I haven't reviewed it yet.

It's now fully reviewed by myself! Made many simplifications.

Let's merge #2055 and rebase this on top of that!

[evanlinjin]

Skiplist Performance Update

After the optimizations, here are the updated benchmark results:

get() Performance

Benchmark	Time	Notes
get_100_near_start	475.89 ns	Get checkpoint near start of 100-item chain
get_1000_middle	31.07 ns	Get checkpoint in middle of 1000-item chain
get_10000_near_end	57.12 ns	Get checkpoint near end of 10000-item chain
get_10000_near_start	535.37 ns	Get checkpoint near start of 10000-item chain

floor_at() Performance

Benchmark	Time	Notes
floor_at_1000	286.33 ns	Floor at height 750 in 1000-item chain
floor_at_10000	673.27 ns	Floor at height 7500 in 10000-item chain

range() Performance

Benchmark	Time	Notes
range_1000_middle_10pct	1.67 µs	Range 450..=550 in 1000-item chain
range_10000_large_50pct	97.59 µs	Range 2500..=7500 in 10000-item chain
range_10000_from_start	3.11 µs	Range ..=100 in 10000-item chain
range_10000_near_tip	1.21 µs	Range 9900.. in 10000-item chain
range_single_element	942.21 ns	Range 5000..=5000 in 10000-item chain

Traversal Comparison

Benchmark	Time	Notes
linear_traversal_10000	140.90 µs	Linear search to height 100 in 10000-item chain
skiplist_get_10000	539.80 ns	Skip-enhanced search to height 100 in 10000-item chain

Speedup: 261x faster with skip pointers!

Summary

The skip list implementation successfully achieves O(√n) time complexity for search operations. Key improvements from our optimizations:

1. Cleaner two-phase traversal in get() and range()
2. Simplified floor_at() from 33 lines to 1 line
3. Restored elegant insert() implementation (removed 60+ lines)
4. Refactored push() with clearer skip pointer logic

All tests pass and the implementation is now both performant and maintainable.

[ValuedMammal]

I think it should have more than a single level to achieve the optimal performance, but I'm not sure if that's possible without implementing a new type.

[nymius]

This will be an improvement over linked list for sure, but I would like to combine efforts with block-graph/skiplist to avoid duplicated work.
I find some components of the skip list too tied up to the underlying data, making difficult to resonate about the functionality of the skip list by itself. I would like to detach the skiplist logic from the underlying data.
There is a lot of room for improvement for skiplist applied to our particular use case, so I'm positive there will be a lot of changes to a structure like it. I would try to make smaller PRs to check the improvements, but get results early.
In that sense, the benchmark is going to be very handy to ensure we are making progress.
A one level, fixed skip interval is a great starting point for that.