chore: add benchmarks for varied forms of lookups

CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+- [2142](https://github.com/FuelLabs/fuel-core/pull/2142): Added benchmarks for varied forms of db lookups to assist in optimizations.
+
 ## [Version 0.35.0]
 
 ### Added

benches/Cargo.toml

@@ -34,6 +34,7 @@ p256 = { version = "0.13", default-features = false, features = [
   "digest",
   "ecdsa",
 ] }
+postcard = { workspace = true }
 primitive-types = { workspace = true, default-features = false }
 quanta = "0.12"
 rand = { workspace = true }
@@ -66,3 +67,7 @@ name = "block_target_gas"
 [[bench]]
 harness = false
 name = "transaction_throughput"
+
+[[bench]]
+harness = false
+name = "db_lookup_times"

benches/benches/db_lookup_times.rs

@@ -0,0 +1,96 @@
+use crate::db_lookup_times_utils::{
+    matrix::matrix,
+    utils::{
+        get_full_block,
+        get_random_block_height,
+        multi_get_block,
+        open_db,
+        open_raw_rocksdb,
+    },
+};
+use criterion::{
+    criterion_group,
+    criterion_main,
+    Criterion,
+};
+use db_lookup_times_utils::seed::{
+    seed_compressed_blocks_and_transactions_matrix,
+    seed_full_block_matrix,
+};
+use fuel_core_storage::transactional::AtomicView;
+use rand::thread_rng;
+
+mod db_lookup_times_utils;
+
+pub fn header_and_tx_lookup(c: &mut Criterion) {
+    let method = "header_and_tx";
+    let mut rng = thread_rng();
+
+    seed_compressed_blocks_and_transactions_matrix(method);
+    let mut group = c.benchmark_group(method);
+
+    for (block_count, tx_count) in matrix() {
+        let database = open_db(block_count, tx_count, method);
+        let view = database.latest_view().unwrap();
+        group.bench_function(format!("{block_count}/{tx_count}"), |b| {
+            b.iter(|| {
+                let height = get_random_block_height(&mut rng, block_count);
+                let block = view.get_full_block(&height);
+                assert!(block.is_ok());
+                assert!(block.unwrap().is_some());
+            });
+        });
+    }
+
+    group.finish();
+}
+
+pub fn multi_get_lookup(c: &mut Criterion) {
+    let method = "multi_get";
+    let mut rng = thread_rng();
+
+    seed_compressed_blocks_and_transactions_matrix(method);
+    let mut group = c.benchmark_group(method);
+
+    for (block_count, tx_count) in matrix() {
+        let database = open_raw_rocksdb(block_count, tx_count, method);
+        group.bench_function(format!("{block_count}/{tx_count}"), |b| {
+            b.iter(|| {
+                let height = get_random_block_height(&mut rng, block_count);
+                assert!(multi_get_block(&database, height).is_ok());
+            });
+        });
+    }
+
+    group.finish();
+}
+
+pub fn full_block_lookup(c: &mut Criterion) {
+    let method = "full_block";
+    let mut rng = thread_rng();
+
+    seed_full_block_matrix();
+    let mut group = c.benchmark_group(method);
+
+    for (block_count, tx_count) in matrix() {
+        let database = open_db(block_count, tx_count, method);
+        let view = database.latest_view().unwrap();
+        group.bench_function(format!("{block_count}/{tx_count}"), |b| {
+            b.iter(|| {
+                let height = get_random_block_height(&mut rng, block_count);
+                let full_block = get_full_block(&view, &height);
+                assert!(full_block.is_ok());
+                assert!(full_block.unwrap().is_some());
+            });
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().sample_size(100_000).measurement_time(std::time::Duration::from_secs(100));
+    targets = header_and_tx_lookup, multi_get_lookup, full_block_lookup
+}
+criterion_main!(benches);

benches/benches/db_lookup_times_utils/matrix.rs

@@ -0,0 +1,11 @@
+pub const BLOCK_COUNT_MATRIX: [u32; 2] = [10, 100];
+pub const TX_COUNT_MATRIX: [u32; 2] = [100, 1000];
+
+// todo: we can make this lazy loaded
+pub fn matrix() -> impl Iterator<Item = (u32, u32)> {
+    BLOCK_COUNT_MATRIX.iter().flat_map(|&block_count| {
+        TX_COUNT_MATRIX
+            .iter()
+            .map(move |&tx_count| (block_count, tx_count))
+    })
+}

benches/benches/db_lookup_times_utils/mod.rs

@@ -0,0 +1,3 @@
+pub mod matrix;
+pub mod seed;
+pub mod utils;

benches/benches/db_lookup_times_utils/seed.rs

@@ -0,0 +1,153 @@
+use crate::db_lookup_times_utils::{
+    matrix::matrix,
+    utils::{
+        chain_id,
+        open_raw_rocksdb,
+    },
+};
+use fuel_core::{
+    database::database_description::on_chain::OnChain,
+    state::rocks_db::RocksDb,
+};
+use fuel_core_storage::{
+    column::Column,
+    kv_store::{
+        KeyValueMutate,
+        Value,
+    },
+};
+use fuel_core_types::{
+    blockchain::{
+        block::{
+            Block,
+            PartialFuelBlock,
+        },
+        header::{
+            ConsensusHeader,
+            PartialBlockHeader,
+        },
+        primitives::Empty,
+    },
+    fuel_tx::{
+        Transaction,
+        UniqueIdentifier,
+    },
+    fuel_types::BlockHeight,
+};
+
+pub fn seed_compressed_blocks_and_transactions_matrix(method: &str) {
+    for (block_count, tx_count) in matrix() {
+        let mut database = open_raw_rocksdb(block_count, tx_count, method);
+        let _ =
+            seed_compressed_blocks_and_transactions(&mut database, block_count, tx_count);
+    }
+}
+
+pub fn seed_full_block_matrix() {
+    for (block_count, tx_count) in matrix() {
+        let mut database = open_raw_rocksdb(block_count, tx_count, "full_block");
+        seed_full_blocks(&mut database, block_count, tx_count);
+    }
+}
+
+fn generate_bench_block(height: u32, tx_count: u32) -> Block {
+    let header = PartialBlockHeader {
+        application: Default::default(),
+        consensus: ConsensusHeader::<Empty> {
+            height: BlockHeight::from(height),
+            ..Default::default()
+        },
+    };
+    let txes = generate_bench_transactions(tx_count);
+    let block = PartialFuelBlock::new(header, txes);
+    block.generate(&[], Default::default()).unwrap()
+}
+
+fn generate_bench_transactions(tx_count: u32) -> Vec<Transaction> {
+    let mut txes = vec![];
+    for _ in 0..tx_count {
+        txes.push(Transaction::default_test_tx());
+    }
+    txes
+}
+
+fn height_key(block_height: u32) -> Vec<u8> {
+    BlockHeight::from(block_height).to_bytes().to_vec()
+}
+
+fn insert_compressed_block(
+    database: &mut RocksDb<OnChain>,
+    height: u32,
+    tx_count: u32,
+) -> Block {
+    let block = generate_bench_block(height, tx_count);
+
+    let compressed_block = block.compress(&chain_id());
+    let height_key = height_key(height);
+
+    let raw_compressed_block = postcard::to_allocvec(&compressed_block).unwrap().to_vec();
+    let raw_transactions = block
+        .transactions()
+        .iter()
+        .map(|tx| {
+            (
+                tx.id(&chain_id()),
+                postcard::to_allocvec(tx).unwrap().to_vec(),
+            )
+        })
+        .collect::<Vec<_>>();
+
+    // 1. insert into CompressedBlocks table
+    database
+        .put(
+            height_key.as_slice(),
+            Column::FuelBlocks,
+            Value::new(raw_compressed_block),
+        )
+        .unwrap();
+    // 2. insert into Transactions table
+    for (tx_id, tx) in raw_transactions {
+        database
+            .put(tx_id.as_slice(), Column::Transactions, Value::new(tx))
+            .unwrap();
+    }
+
+    block
+}
+
+fn insert_full_block(database: &mut RocksDb<OnChain>, height: u32, tx_count: u32) {
+    let block = insert_compressed_block(database, height, tx_count);
+
+    let height_key = height_key(height);
+    let raw_full_block = postcard::to_allocvec(&block).unwrap().to_vec();
+
+    // 3. insert into FullFuelBlocks table
+    database
+        .put(
+            height_key.as_slice(),
+            Column::FullFuelBlocks,
+            Value::new(raw_full_block),
+        )
+        .unwrap();
+}
+
+fn seed_compressed_blocks_and_transactions(
+    database: &mut RocksDb<OnChain>,
+    block_count: u32,
+    tx_count: u32,
+) -> Vec<Block> {
+    let mut blocks = vec![];
+    for block_number in 0..block_count {
+        blocks.push(insert_compressed_block(database, block_number, tx_count));
+    }
+    blocks
+}
+
+fn seed_full_blocks(database: &mut RocksDb<OnChain>, block_count: u32, tx_count: u32) {
+    // we seed compressed blocks and transactions to not affect individual
+    // lookup times
+
+    for block_number in 0..block_count {
+        insert_full_block(database, block_number, tx_count);
+    }
+}