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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Benchmark the `update_state` method of `Exchange` for `TradeEvent`
//! TODO: rename this file to `update_state`

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

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

use const_decimal::Decimal;
use criterion::{
    BenchmarkId,
    Criterion,
    criterion_group,
    criterion_main,
};
use lfest::{
    load_trades_from_csv,
    prelude::*,
};

const DECIMALS: u8 = 5;

fn generate_quotes_from_trades(
    trades: &[Trade<i64, DECIMALS, QuoteCurrency<i64, DECIMALS>>],
) -> Vec<Bba<i64, DECIMALS>> {
    Vec::from_iter(trades.iter().map(|trade| Bba {
        bid: trade.price - QuoteCurrency::one(),
        ask: trade.price + QuoteCurrency::one(),
        timestamp_exchange_ns: trade.timestamp_exchange_ns,
    }))
}

fn update_state<I, const D: u8, BaseOrQuote, U>(
    exchange: &mut Exchange<I, D, BaseOrQuote, NoUserOrderId>,
    trades: &[U],
) where
    I: Mon<D>,
    BaseOrQuote: Currency<I, D>,
    BaseOrQuote::PairedCurrency: MarginCurrency<I, D>,
    U: MarketUpdate<I, D, BaseOrQuote> + Clone,
{
    for trade in trades.iter() {
        exchange.update_state(trade).expect("is a valid update");
    }
}

fn criterion_benchmark(c: &mut Criterion) {
    let starting_balance = BaseCurrency::new(1, 0);
    let contract_spec = ContractSpecification::new(
        leverage!(1),
        Decimal::try_from_scaled(5, 1).unwrap(),
        PriceFilter::new(
            None,
            None,
            QuoteCurrency::new(5, 1),
            Decimal::TWO,
            Decimal::try_from_scaled(5, 1).unwrap(),
        )
        .expect("is valid filter"),
        QuantityFilter::new(None, None, QuoteCurrency::one()).expect("is valid filter"),
        Fee::from(Decimal::try_from_scaled(2, 0).unwrap()),
        Fee::from(Decimal::try_from_scaled(6, 0).unwrap()),
    )
    .expect("works");
    let config = Config::new(
        starting_balance,
        NonZeroU16::new(200).unwrap(),
        contract_spec,
        OrderRateLimits::default(),
    )
    .unwrap();
    let mut exchange = Exchange::new(config);

    let trades = load_trades_from_csv("./data/Bitmex_XBTUSD_1M.csv");
    const COUNT: usize = 1_000_000;
    assert_eq!(trades.len(), COUNT);

    let mut group = c.benchmark_group("Exchange");
    group.throughput(criterion::Throughput::Elements(COUNT as u64));
    group.bench_with_input(
        BenchmarkId::new("update_state_trade", COUNT),
        &COUNT,
        |b, _| {
            b.iter(|| {
                update_state::<
                    _,
                    DECIMALS,
                    QuoteCurrency<_, DECIMALS>,
                    Trade<_, DECIMALS, QuoteCurrency<_, DECIMALS>>,
                >(black_box(&mut exchange), black_box(&trades))
            })
        },
    );
    let bbas = generate_quotes_from_trades(&trades);
    group.bench_with_input(
        BenchmarkId::new("update_state_quotes", COUNT),
        &COUNT,
        |b, _n| {
            b.iter(|| {
                update_state::<_, DECIMALS, QuoteCurrency<_, DECIMALS>, Bba<_, DECIMALS>>(
                    black_box(&mut exchange),
                    black_box(&bbas),
                )
            })
        },
    );
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);