120 lines
4.6 KiB
Rust
120 lines
4.6 KiB
Rust
#![feature(test)]
|
|
|
|
extern crate test;
|
|
extern crate zebra_chain;
|
|
extern crate zebra_miner;
|
|
extern crate zebra_primitives;
|
|
extern crate zebra_serialization as ser;
|
|
|
|
#[cfg(test)]
|
|
mod benchmarks {
|
|
use super::chain::{OutPoint, Transaction, TransactionInput};
|
|
use super::miner::{MemoryPool, MemoryPoolOrderingStrategy};
|
|
use super::primitives::bytes::Bytes;
|
|
use super::test::Bencher;
|
|
use std::collections::VecDeque;
|
|
|
|
fn prepare_independent_transactions(n: usize) -> VecDeque<Transaction> {
|
|
(0..n)
|
|
.map(|nonce| Transaction {
|
|
version: nonce as i32,
|
|
inputs: vec![],
|
|
outputs: vec![],
|
|
lock_time: 0,
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn prepare_dependent_transactions(n: usize) -> VecDeque<Transaction> {
|
|
let previous_transaction: Transaction = "00000000000164000000000000000000000000".into();
|
|
let mut previous_transaction_hash = previous_transaction.hash();
|
|
let mut result = VecDeque::new();
|
|
result.push_back(previous_transaction);
|
|
result.extend((0..n).map(|_nonce| {
|
|
let transaction = Transaction {
|
|
version: 0,
|
|
inputs: vec![TransactionInput {
|
|
previous_output: OutPoint {
|
|
hash: previous_transaction_hash.clone(),
|
|
index: 0,
|
|
},
|
|
script_sig: Bytes::new_with_len(0),
|
|
sequence: 0,
|
|
}],
|
|
outputs: vec![],
|
|
lock_time: 0,
|
|
};
|
|
previous_transaction_hash = transaction.hash();
|
|
transaction
|
|
}));
|
|
result
|
|
}
|
|
|
|
#[bench]
|
|
// test benchmarks::memory_pool_insert_independent_transactions ... bench: 1,455 ns/iter (+/- 12)
|
|
fn memory_pool_insert_independent_transactions(b: &mut Bencher) {
|
|
let iterations = 100;
|
|
let mut pool = MemoryPool::new();
|
|
let mut transactions = prepare_independent_transactions(iterations);
|
|
b.bench_n(iterations as u64, |b| {
|
|
b.iter(|| pool.insert_verified(transactions.pop_front().unwrap().into()))
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
// test benchmarks::memory_pool_insert_descendant_transaction ... bench: 7,834 ns/iter (+/- 288)
|
|
fn memory_pool_insert_descendant_transaction(b: &mut Bencher) {
|
|
let iterations = 100usize;
|
|
let mut pool = MemoryPool::new();
|
|
let mut transactions = prepare_dependent_transactions(iterations);
|
|
pool.insert_verified(transactions.pop_front().unwrap().into());
|
|
|
|
b.bench_n(iterations as u64, |b| {
|
|
b.iter(|| pool.insert_verified(transactions.pop_front().unwrap().into()))
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
// test benchmarks::memory_pool_insert_ancestor_transaction ... bench: 376,067 ns/iter (+/- 11,249)
|
|
// very slow due to weird usage scenario:
|
|
// (1) transactions inserted to memorypool are verified
|
|
// (2) verified => ancestors already verified
|
|
// (3) ancestors verified => they are already in memorypool (not this case) or in database (why inserting to memorypool then)
|
|
fn memory_pool_insert_ancestor_transaction(b: &mut Bencher) {
|
|
let iterations = 100usize;
|
|
let mut pool = MemoryPool::new();
|
|
let mut transactions = prepare_dependent_transactions(iterations);
|
|
pool.insert_verified(transactions.pop_front().unwrap().into());
|
|
|
|
b.bench_n(iterations as u64, |b| {
|
|
b.iter(|| pool.insert_verified(transactions.pop_back().unwrap().into()))
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
// test benchmarks::memory_pool_remove_independent_in_order ... bench: 460 ns/iter (+/- 47)
|
|
fn memory_pool_remove_independent_in_order(b: &mut Bencher) {
|
|
let iterations = 100;
|
|
let mut pool = MemoryPool::new();
|
|
for transaction in prepare_independent_transactions(iterations) {
|
|
pool.insert_verified(transaction.into())
|
|
}
|
|
b.bench_n(iterations as u64, |b| {
|
|
b.iter(|| pool.remove_with_strategy(MemoryPoolOrderingStrategy::ByTimestamp))
|
|
});
|
|
}
|
|
|
|
#[bench]
|
|
// test benchmarks::memory_pool_remove_dependent_in_order ... bench: 754 ns/iter (+/- 111)
|
|
fn memory_pool_remove_dependent_in_order(b: &mut Bencher) {
|
|
let iterations = 100;
|
|
let mut pool = MemoryPool::new();
|
|
for transaction in prepare_dependent_transactions(iterations) {
|
|
pool.insert_verified(transaction.into())
|
|
}
|
|
b.bench_n(iterations as u64, |b| {
|
|
b.iter(|| pool.remove_with_strategy(MemoryPoolOrderingStrategy::ByTimestamp))
|
|
});
|
|
}
|
|
}
|