datastore: .ef v2 format

Author: battlmonstr

silkworm/db/blocks/headers/header_segment.cpp

@@ -28,8 +28,11 @@ void decode_word_into_header(ByteView word, BlockHeader& header) {
     success_or_throw(decode_result, "decode_word_into_header: rlp::decode error");
 }
 
-void check_sanity_of_header_with_metadata(const BlockHeader& header, datastore::StepRange step_range) {
-    auto block_num_range = db::blocks::kStepToBlockNumConverter.timestamp_range_from_step_range(step_range);
+void check_sanity_of_header_with_metadata(
+    const BlockHeader& header,
+    datastore::StepRange step_range,
+    const datastore::StepToTimestampConverter& step_converter) {
+    auto block_num_range = step_converter.timestamp_range_from_step_range(step_range);
     BlockNum block_from = block_num_range.start;
     BlockNum block_to = block_num_range.end;
     ensure((header.number >= block_from) && (header.number < block_to), [&]() {

silkworm/db/blocks/headers/header_segment.hpp

@@ -13,7 +13,10 @@ namespace silkworm::snapshots {
 
 void encode_word_from_header(Bytes& word, const BlockHeader& header);
 void decode_word_into_header(ByteView word, BlockHeader& header);
-void check_sanity_of_header_with_metadata(const BlockHeader& header, datastore::StepRange step_range);
+void check_sanity_of_header_with_metadata(
+    const BlockHeader& header,
+    datastore::StepRange step_range,
+    const datastore::StepToTimestampConverter& step_converter);
 
 struct HeaderSegmentWordEncoder : public Encoder {
     BlockHeader value;
@@ -39,8 +42,8 @@ struct HeaderSegmentWordDecoder : public Decoder {
         decode_word_into_header(word, value);
     }
 
-    void check_sanity_with_metadata(const SnapshotPath& path) override {
-        check_sanity_of_header_with_metadata(value, path.step_range());
+    void check_sanity_with_metadata(const SnapshotPath& path, const datastore::StepToTimestampConverter& step_converter) override {
+        check_sanity_of_header_with_metadata(value, path.step_range(), step_converter);
     }
 };
 

silkworm/db/datastore/snapshots/btree/btree_index_test.cpp

@@ -101,7 +101,7 @@ TEST_CASE("BTreeIndex", "[snapshots][btree]") {
     const auto [kv_file_path, bt_file_path] = sample_3_keys_kv_and_bt_files(tmp_dir);
 
     // Open the KV and BT index files
-    segment::KVSegmentFileReader kv_segment{kv_file_path, seg::CompressionKind::kNone};
+    segment::KVSegmentFileReader kv_segment{kv_file_path, {}, seg::CompressionKind::kNone};
     BTreeIndex bt_index{bt_file_path};
     bt_index.warmup_if_empty_or_check(kv_segment);
     REQUIRE(bt_index.key_count() == 3);

silkworm/db/datastore/snapshots/common/codec.hpp

@@ -6,6 +6,10 @@
 #include <silkworm/core/common/base.hpp>
 #include <silkworm/core/common/bytes.hpp>
 
+namespace silkworm::datastore {
+struct StepToTimestampConverter;
+}  // namespace silkworm::datastore
+
 namespace silkworm::snapshots {
 
 class SnapshotPath;
@@ -24,7 +28,8 @@ struct Decoder {
     virtual ~Decoder() = default;
     using Word = BytesOrByteView;
     virtual void decode_word(Word& word) = 0;  // this allows word to be moved after decoding
-    virtual void check_sanity_with_metadata(const SnapshotPath& /*path*/) {}
+    virtual void decode_word_with_metadata(const SnapshotPath& /*path*/, const datastore::StepToTimestampConverter& /*step_converter*/) {}
+    virtual void check_sanity_with_metadata(const SnapshotPath& /*path*/, const datastore::StepToTimestampConverter& /*step_converter*/) {}
 };
 
 template <class TDecoder>

silkworm/db/datastore/snapshots/elias_fano/elias_fano_decoder.hpp

@@ -45,29 +45,38 @@
 
 namespace silkworm::snapshots::elias_fano {
 
-EliasFanoList32 EliasFanoList32::from_encoded_data(std::span<const uint8_t> encoded_data) {
-    ensure(encoded_data.size() >= kCountLength + kULength, "EliasFanoList32::from_encoded_data data too short");
+EliasFanoList32 EliasFanoList32::from_encoded_data(BytesOrByteView encoded_data_holder) {
+    std::span<const uint8_t> encoded_data{ByteView{encoded_data_holder}};
+    const uint64_t data_offset = kCountLength + kULength;
+    ensure(encoded_data.size() >= data_offset, "EliasFanoList32::from_encoded_data data too short");
     const uint64_t last = endian::load_big_u64(encoded_data.data());
     const uint64_t u = endian::load_big_u64(encoded_data.subspan(kCountLength).data());
-    const auto remaining_data = encoded_data.subspan(kCountLength + kULength);
-    return EliasFanoList32{last + 1, u - 1, remaining_data};
+    return EliasFanoList32{last + 1, u - 1, data_offset, std::move(encoded_data_holder)};
+}
+
+EliasFanoList32 EliasFanoList32::from_encoded_data(std::span<const uint8_t> encoded_data) {
+    return from_encoded_data(BytesOrByteView{ByteView{encoded_data}});
 }
 
 EliasFanoList32 EliasFanoList32::from_encoded_data(ByteView encoded_data) {
-    return from_encoded_data(std::span<const uint8_t>{encoded_data});
+    return from_encoded_data(BytesOrByteView{encoded_data});
 }
 
 EliasFanoList32 EliasFanoList32::from_encoded_data(Bytes encoded_data) {
-    auto elias_fano_list = from_encoded_data(std::span<const uint8_t>{encoded_data});
-    elias_fano_list.data_holder_ = std::move(encoded_data);
-    return elias_fano_list;
+    return from_encoded_data(BytesOrByteView{std::move(encoded_data)});
 }
 
-EliasFanoList32::EliasFanoList32(uint64_t count, uint64_t max_value, std::span<const uint8_t> encoded_data)
+EliasFanoList32::EliasFanoList32(
+    uint64_t count,
+    uint64_t max_value,
+    uint64_t data_offset,
+    BytesOrByteView data_holder)
     : count_{count},
       u_{max_value + 1},
-      data_{reinterpret_cast<const uint64_t*>(encoded_data.data()), EliasFanoList32::total_words(count, max_value)} {
-    SILKWORM_ASSERT(EliasFanoList32::total_words(count, max_value) * sizeof(uint64_t) <= encoded_data.size());
+      data_offset_{data_offset},
+      total_words_{EliasFanoList32::total_words(count, max_value)},
+      data_holder_{std::move(data_holder)} {
+    SILKWORM_ASSERT(EliasFanoList32::total_words(count, max_value) * sizeof(uint64_t) + data_offset <= ByteView{data_holder_}.size());
     derive_fields();
 }
 
@@ -164,7 +173,8 @@ std::ostream& operator<<(std::ostream& os, const EliasFanoList32& ef) {
     os.write(reinterpret_cast<const char*>(uint64_buffer.data()), sizeof(uint64_t));
     SILK_DEBUG << "[index] written EF upper: " << ef.u_;
 
-    os.write(reinterpret_cast<const char*>(ef.data_.data()), static_cast<std::streamsize>(ef.data_.size() * sizeof(uint64_t)));
+    auto data = ef.data();
+    os.write(reinterpret_cast<const char*>(data.data()), static_cast<std::streamsize>(data.size() * sizeof(uint64_t)));
     return os;
 }
 
@@ -197,9 +207,11 @@ uint64_t EliasFanoList32::derive_fields() {
     uint64_t words_upper_bits = (count_ + (u_ >> l_) + 63) / 64;
     uint64_t jump_words = jump_size_words(count_);
     uint64_t total_words = words_lower_bits + words_upper_bits + jump_words;
-    lower_bits_ = data_.subspan(0, words_lower_bits);
-    upper_bits_ = data_.subspan(words_lower_bits, words_upper_bits);
-    jump_ = data_.subspan(words_lower_bits + words_upper_bits, jump_words);
+
+    auto data = this->data();
+    lower_bits_ = data.subspan(0, words_lower_bits);
+    upper_bits_ = data.subspan(words_lower_bits, words_upper_bits);
+    jump_ = data.subspan(words_lower_bits + words_upper_bits, jump_words);
 
     return total_words;
 }

silkworm/db/datastore/snapshots/elias_fano/elias_fano_decoder_test.cpp

@@ -37,6 +37,8 @@
 #include <span>
 #include <utility>
 
+#include <silkworm/core/common/bytes.hpp>
+
 #include "../common/encoding/sequence.hpp"
 #include "../common/util/iterator/list_iterator.hpp"
 
@@ -47,6 +49,9 @@ class EliasFanoList32 {
   public:
     using value_type = uint64_t;
 
+    //! Create a new 32-bit EF list from the given encoded data (i.e. data plus data header)
+    static EliasFanoList32 from_encoded_data(BytesOrByteView encoded_data_holder);
+
     //! Create a new 32-bit EF list from the given encoded data (i.e. data plus data header)
     static EliasFanoList32 from_encoded_data(std::span<const uint8_t> encoded_data);
 
@@ -60,18 +65,26 @@ class EliasFanoList32 {
     //! Create a new 32-bit EF list from an existing data sequence
     //! \param count
     //! \param max_value
-    //! \param encoded_data the existing data sequence (portion exceeding the total words will be ignored)
-    EliasFanoList32(uint64_t count, uint64_t max_value, std::span<const uint8_t> encoded_data);
+    //! \param data_offset offset in the data_holder to the data sequence
+    //! \param data_holder the data (portion exceeding the total words will be ignored)
+    EliasFanoList32(
+        uint64_t count,
+        uint64_t max_value,
+        uint64_t data_offset,
+        BytesOrByteView data_holder);
 
     size_t size() const { return count_; }
 
     uint64_t max() const { return u_ - 1; }
 
     uint64_t min() const { return at(0); }
 
-    std::span<const uint64_t> data() const { return data_; }
+    std::span<const uint64_t> data() const {
+        const uint64_t* data = reinterpret_cast<const uint64_t*>(ByteView{data_holder_}.data() + data_offset_);
+        return {data, total_words_};
+    }
 
-    size_t encoded_data_size() const { return kCountLength + kULength + data_.size() * sizeof(uint64_t); }
+    size_t encoded_data_size() const { return kCountLength + kULength + total_words_ * sizeof(uint64_t); }
 
     uint64_t at(size_t i) const;
     uint64_t operator[](size_t i) const { return at(i); }
@@ -84,23 +97,17 @@ class EliasFanoList32 {
     friend std::ostream& operator<<(std::ostream& os, const EliasFanoList32& ef);
 
     bool operator==(const EliasFanoList32& other) const {
-        return (count_ == other.count_) && (u_ == other.u_) && std::ranges::equal(data_, other.data_);
+        return (count_ == other.count_) && (u_ == other.u_) && std::ranges::equal(data(), other.data());
     }
 
     static uint64_t total_words(uint64_t count, uint64_t max_value);
     static uint64_t jump_size_words(uint64_t count);
 
-    static EliasFanoList32 empty_list() {
-        return EliasFanoList32{};
-    }
-
     using Iterator = ListIterator<EliasFanoList32, value_type>;
     Iterator begin() const { return Iterator{*this, 0}; }
     Iterator end() const { return Iterator{*this, size()}; }
 
   private:
-    EliasFanoList32() = default;
-
     uint64_t upper(uint64_t c) const;
     uint64_t derive_fields();
 
@@ -115,10 +122,10 @@ class EliasFanoList32 {
     //! The strict upper bound on the EF data points, i.e. max + 1
     uint64_t u_{0};
     uint64_t l_{0};
-    //! Lightweight view over the EF encoded data sequence.
-    std::span<const uint64_t> data_;
-    //! Copy of the EF encoded data sequence when it must be kept for lifetime reasons
-    std::optional<Bytes> data_holder_{};
+    uint64_t data_offset_{0};
+    uint64_t total_words_{0};
+    //! The EF encoded data sequence
+    BytesOrByteView data_holder_{};
 };
 
 //! 32-bit Elias-Fano (EF) list writer that can be used to encode one monotone non-decreasing sequence
@@ -139,9 +146,12 @@ class EliasFanoList32Builder {
 
     EliasFanoList32 as_view() const {
         const auto max_value = u_ - 1;
-        return EliasFanoList32{count_,
-                               max_value,
-                               {reinterpret_cast<const uint8_t*>(data_.data()), EliasFanoList32::total_words(count_, max_value) * sizeof(uint64_t)}};
+        return EliasFanoList32{
+            count_,
+            max_value,
+            0,
+            BytesOrByteView{ByteView{reinterpret_cast<const uint8_t*>(data_.data()), EliasFanoList32::total_words(count_, max_value) * sizeof(uint64_t)}},
+        };
     };
 
     size_t size() const { return count_; }

silkworm/db/datastore/snapshots/elias_fano/elias_fano_list.cpp

@@ -10,6 +10,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
+#include <silkworm/core/common/bytes_to_string.hpp>
 #include <silkworm/core/common/endian.hpp>
 #include <silkworm/core/common/util.hpp>
 
@@ -114,9 +115,7 @@ TEST_CASE("EliasFanoList32", "[silkworm][recsplit][elias_fano]") {
         CHECK(to_hex(ef_bytes) == to_expected_hex(ef_test.offsets.size() - 1, ef_test.expected_u, ef_test.expected_data));
 
         // Decode monotone ascending integer sequence from Elias-Fano representation and compare with original
-        constexpr size_t kParamsSize{2 * sizeof(uint64_t)};  // count + u length in bytes
-        std::span<uint8_t> data{ef_bytes.data() + kParamsSize, ef_bytes.size() - kParamsSize};
-        EliasFanoList32 ef_list_copy{ef_test.offsets.size(), ef_test.expected_u - 1, data};
+        EliasFanoList32 ef_list_copy = EliasFanoList32::from_encoded_data(ef_bytes);
         for (uint64_t i{0}; i < ef_test.offsets.size(); ++i) {
             const uint64_t x = ef_list_copy.at(i);
             CHECK(x == ef_test.offsets[i]);
@@ -152,4 +151,17 @@ TEST_CASE("EliasFanoList32::seek", "[silkworm][recsplit][elias_fano]") {
     CHECK(ef_list.seek(70, true) == SeekResult{offsets.size() - 1, 62});
 }
 
+TEST_CASE("EliasFanoList32::from_encoded_data") {
+    EliasFanoList32Builder expected_list{3, 3};
+    expected_list.add_offset(1);
+    expected_list.add_offset(2);
+    expected_list.add_offset(3);
+    expected_list.build();
+    std::stringstream expected_list_stream;
+    expected_list_stream << expected_list;
+    const Bytes expected_list_bytes = string_to_bytes(expected_list_stream.str());
+
+    CHECK(EliasFanoList32::from_encoded_data(expected_list_bytes) == expected_list.as_view());
+}
+
 }  // namespace silkworm::snapshots::elias_fano

silkworm/db/datastore/snapshots/elias_fano/elias_fano_list.hpp

@@ -40,7 +40,7 @@ struct HistoryRangeByKeysSegmentQuery {
         datastore::Timestamp timestamp,
         bool ascending,
         Bytes key_data,
-        const elias_fano::EliasFanoList32& key_timestamps) const {
+        const InvertedIndexTimestampList& key_timestamps) const {
         SILKWORM_ASSERT(ascending);  // descending is not implemented
 
         // find the first key timestamp within the ts_range
@@ -66,7 +66,7 @@ struct HistoryRangeByKeysSegmentQuery {
         auto ii_reader = entity_.inverted_index.kv_segment_reader<RawDecoder<Bytes>>();
         auto begin_it = offset ? ii_reader.seek(*offset) : ii_reader.end();
 
-        auto lookup_kv_pair_func = [query = *this, timestamp, ascending](std::pair<Bytes&, elias_fano::EliasFanoList32&>&& ii_entry) {
+        auto lookup_kv_pair_func = [query = *this, timestamp, ascending](std::pair<Bytes&, InvertedIndexTimestampList&>&& ii_entry) {
             return query.lookup_kv_pair(timestamp, ascending, std::move(ii_entry.first), ii_entry.second);
         };