lfest 0.138.3

A leveraged perpetual futures exchange for simulated trading and backtesting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! Benchmark regarding order book implementation.

#![allow(
    unused_crate_dependencies,
    missing_docs,
    reason = "Benchmarks don't use all dev-dependencies"
)]

use std::{
    hint::black_box,
    num::NonZeroU16,
};

use criterion::{
    BenchmarkId,
    Criterion,
    Throughput,
    criterion_group,
    criterion_main,
};
use lfest::{
    prelude::*,
    test_fee_maker,
};
use rand::{
    RngExt,
    SeedableRng,
};

fn criterion_benchmark(c: &mut Criterion) {
    let mut group = c.benchmark_group("OrderBook");

    let mut rng = rand::rngs::SmallRng::seed_from_u64(0);

    for n in 1..100 {
        group.throughput(Throughput::Elements(n));
        group.bench_with_input(BenchmarkId::new("try_insert_order", n), &n, |b, _| {
            let orders = Vec::from_iter((0..n).map(|i| {
                let meta = ExchangeOrderMeta::new(i.into(), (i as i64).into());
                let order = LimitOrder::new(
                    Side::Buy,
                    QuoteCurrency::<i64, 5>::new(rng.random_range(50..200), 0),
                    BaseCurrency::new(rng.random_range(1..100), 2),
                )
                .unwrap();
                order.into_pending(meta)
            }));
            b.iter_with_setup(
                || {
                    Account::new(
                        Balances::new(QuoteCurrency::new(1000, 0)),
                        NonZeroU16::new(n as u16).unwrap(),
                        const_decimal::Decimal::ONE,
                        *test_fee_maker().as_ref(),
                    )
                },
                |mut ob| {
                    for order in orders.iter() {
                        ob.try_insert_order(black_box(order.clone()))
                            .expect("Can insert");
                    }
                },
            )
        });
    }
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);