Delete benchmark

benchmark/bench_matching_engine.cpp

@@ -1,303 +0,0 @@
-// benchmark/bench_matching_engine.cpp
-// Performance benchmark — measures throughput and latency under load
-// Build: cmake --build build --target hft_bench && ./build/hft_bench
-
-#include "core/order_book.hpp"
-#include "core/simulator.hpp"
-#include "core/types.hpp"
-#include "journal/journal.hpp"
-#include <iostream>
-#include <vector>
-#include <chrono>
-#include <random>
-#include <algorithm>
-#include <iomanip>
-#include <cmath>
-#include <numeric>
-
-using namespace hft;
-using Clock = std::chrono::high_resolution_clock;
-
-struct BenchResult {
-    std::string name;
-    int64_t     ops;
-    double      total_us;
-    double      ops_per_sec;
-    double      p50_ns;
-    double      p99_ns;
-    double      p999_ns;
-    double      avg_ns;
-};
-
-static BenchResult run_bench(const std::string& name, int64_t ops,
-                              std::vector<int64_t>& latencies) {
-    std::sort(latencies.begin(), latencies.end());
-    double total_ns = 0;
-    for (auto l : latencies) total_ns += l;
-
-    BenchResult r;
-    r.name        = name;
-    r.ops         = ops;
-    r.total_us    = total_ns / 1000.0;
-    r.ops_per_sec = ops / (total_ns / 1e9);
-    r.avg_ns      = total_ns / ops;
-    r.p50_ns      = latencies[latencies.size() * 50 / 100];
-    r.p99_ns      = latencies[latencies.size() * 99 / 100];
-    r.p999_ns     = latencies[latencies.size() * 999 / 1000];
-    return r;
-}
-
-static void print_result(const BenchResult& r) {
-    std::cout << std::left << std::setw(35) << r.name
-              << std::right
-              << "  ops: " << std::setw(8) << r.ops
-              << "  throughput: " << std::setw(10) << std::fixed << std::setprecision(0) << r.ops_per_sec << " ops/s"
-              << "  avg: " << std::setw(8) << std::setprecision(1) << r.avg_ns << " ns"
-              << "  p50: " << std::setw(8) << r.p50_ns << " ns"
-              << "  p99: " << std::setw(8) << r.p99_ns << " ns"
-              << "  p999: " << std::setw(8) << r.p999_ns << " ns"
-              << "\n";
-}
-
-// ─── Benchmark 1: Order Insert (no match) ───────────────────────────────────
-
-static BenchResult bench_insert_no_match(int n) {
-    OrderBook book("BENCH");
-    std::mt19937 rng(42);
-    std::uniform_int_distribution<int> price_dist(1000, 2000);  // spread out
-    std::uniform_int_distribution<int> qty_dist(100, 1000);
-    std::vector<int64_t> latencies;
-    latencies.reserve(n);
-
-    for (int i = 0; i < n; ++i) {
-        Order o;
-        o.id     = i + 1;
-        o.symbol = "BENCH";
-        o.side   = (i % 2 == 0) ? Side::BUY : Side::SELL;
-        o.type   = OrderType::LIMIT;
-        // Spread prices so no matching occurs (buys low, sells high)
-        o.price  = (o.side == Side::BUY) ? to_price(100.0 + price_dist(rng) * 0.01)
-                                          : to_price(200.0 + price_dist(rng) * 0.01);
-        o.qty    = qty_dist(rng);
-
-        auto t0 = Clock::now();
-        book.add_order(o);
-        auto t1 = Clock::now();
-        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
-    }
-
-    return run_bench("Insert (no match)", n, latencies);
-}
-
-// ─── Benchmark 2: Order Match (aggressive orders) ───────────────────────────
-
-static BenchResult bench_match(int n) {
-    OrderBook book("BENCH");
-    std::mt19937 rng(123);
-    std::uniform_int_distribution<int> qty_dist(50, 200);
-    std::vector<int64_t> latencies;
-    latencies.reserve(n);
-
-    // Pre-populate the book with resting orders
-    for (int i = 0; i < n; ++i) {
-        Order o;
-        o.id     = i + 1;
-        o.symbol = "BENCH";
-        o.side   = Side::SELL;
-        o.type   = OrderType::LIMIT;
-        o.price  = to_price(100.0 + (i % 50) * 0.01);  // 50 price levels
-        o.qty    = qty_dist(rng);
-        book.add_order(o);
-    }
-
-    // Now send aggressive buy orders that match
-    for (int i = 0; i < n; ++i) {
-        Order o;
-        o.id     = n + i + 1;
-        o.symbol = "BENCH";
-        o.side   = Side::BUY;
-        o.type   = OrderType::MARKET;
-        o.price  = 0;
-        o.qty    = 1;  // small qty to match single order partially
-
-        auto t0 = Clock::now();
-        book.add_order(o);
-        auto t1 = Clock::now();
-        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
-    }
-
-    return run_bench("Match (market order)", n, latencies);
-}
-
-// ─── Benchmark 3: Cancel Order ──────────────────────────────────────────────
-
-static BenchResult bench_cancel(int n) {
-    OrderBook book("BENCH");
-    std::mt19937 rng(456);
-    std::uniform_int_distribution<int> price_dist(1, 1000);
-    std::vector<int64_t> latencies;
-    latencies.reserve(n);
-
-    // Insert orders
-    for (int i = 0; i < n; ++i) {
-        Order o;
-        o.id     = i + 1;
-        o.symbol = "BENCH";
-        o.side   = Side::BUY;
-        o.type   = OrderType::LIMIT;
-        o.price  = to_price(100.0 + price_dist(rng) * 0.01);
-        o.qty    = 100;
-        book.add_order(o);
-    }
-
-    // Cancel in random order
-    std::vector<int> ids(n);
-    std::iota(ids.begin(), ids.end(), 1);
-    std::shuffle(ids.begin(), ids.end(), rng);
-
-    for (int id : ids) {
-        auto t0 = Clock::now();
-        book.cancel_order(id);
-        auto t1 = Clock::now();
-        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
-    }
-
-    return run_bench("Cancel (random)", n, latencies);
-}
-
-// ─── Benchmark 4: Snapshot ──────────────────────────────────────────────────
-
-static BenchResult bench_snapshot(int n) {
-    OrderBook book("BENCH");
-
-    // Build a book with many levels
-    for (int i = 0; i < 500; ++i) {
-        Order buy, sell;
-        buy.id     = i * 2 + 1; buy.symbol = "BENCH"; buy.side = Side::BUY;
-        buy.type   = OrderType::LIMIT; buy.price = to_price(100.0 - i * 0.01); buy.qty = 100;
-
-        sell.id    = i * 2 + 2; sell.symbol = "BENCH"; sell.side = Side::SELL;
-        sell.type  = OrderType::LIMIT; sell.price = to_price(101.0 + i * 0.01); sell.qty = 100;
-
-        book.add_order(buy);
-        book.add_order(sell);
-    }
-
-    std::vector<int64_t> latencies;
-    latencies.reserve(n);
-
-    for (int i = 0; i < n; ++i) {
-        auto t0 = Clock::now();
-        auto snap = book.snapshot(10);
-        auto t1 = Clock::now();
-        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
-        (void)snap;
-    }
-
-    return run_bench("Snapshot (10 levels)", n, latencies);
-}
-
-// ─── Benchmark 5: Full Pipeline (submit_order via ExchangeSimulator) ────────
-
-static BenchResult bench_full_pipeline(int n) {
-    RiskLimits limits;
-    limits.max_order_qty = 100000;
-    limits.max_position = 10000000;
-    limits.max_notional_usd = 1e12;
-    limits.max_orders_per_sec = 1000000;
-
-    ExchangeSimulator sim(limits);
-    sim.add_symbol("BENCH");
-
-    std::mt19937 rng(789);
-    std::uniform_int_distribution<int> price_dist(9900, 10100);
-    std::uniform_int_distribution<int> qty_dist(1, 10);
-    std::vector<int64_t> latencies;
-    latencies.reserve(n);
-
-    for (int i = 0; i < n; ++i) {
-        Order o;
-        o.id     = sim.next_order_id();
-        o.symbol = "BENCH";
-        o.side   = (i % 2 == 0) ? Side::BUY : Side::SELL;
-        o.type   = OrderType::LIMIT;
-        o.price  = to_price(price_dist(rng) * 0.01);  // ~99.00 - 101.00
-        o.qty    = qty_dist(rng);
-
-        auto t0 = Clock::now();
-        sim.submit_order(o);
-        auto t1 = Clock::now();
-        latencies.push_back(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
-    }
-
-    return run_bench("Full pipeline (risk+match)", n, latencies);
-}
-
-// ─── Benchmark 6: Backtest Throughput ────────────────────────────────────────
-
-static void bench_backtest_throughput() {
-    std::cout << "\n--- Backtest Throughput ---\n";
-
-    int ticks = 50000;
-    MarketDataParser::Config cfg;
-    cfg.symbol = "BENCH"; cfg.start_price = 100.0;
-    cfg.ticks = ticks; cfg.volatility = 0.001; cfg.seed = 42;
-    auto tick_data = MarketDataParser::generate_synthetic(cfg);
-
-    RiskLimits rl;
-    rl.max_order_qty = 10000;
-    rl.max_position = 1000000;
-    rl.max_notional_usd = 1e12;
-    rl.max_orders_per_sec = 100000;
-
-    auto t0 = Clock::now();
-
-    Backtester bt(rl);
-    bt.add_symbol("BENCH");
-    bt.set_strategy(std::make_unique<MarketMakingStrategy>(5.0, 100));
-    auto result = bt.run(tick_data, false);
-
-    auto t1 = Clock::now();
-    double elapsed_s = std::chrono::duration<double>(t1 - t0).count();
-    double throughput = ticks / elapsed_s;
-
-    std::cout << "  Ticks:       " << ticks << "\n";
-    std::cout << "  Elapsed:     " << std::fixed << std::setprecision(3) << elapsed_s << " s\n";
-    std::cout << "  Throughput:  " << std::setprecision(0) << throughput << " ticks/s\n";
-    std::cout << "  Orders:      " << result.orders_submitted << "\n";
-    std::cout << "  Fills:       " << result.orders_filled << "\n";
-    std::cout << "  Trades:      " << result.trades_count << "\n";
-    std::cout << "  PnL:         " << std::setprecision(2) << result.total_pnl << "\n";
-}
-
-// ─── Main ────────────────────────────────────────────────────────────────────
-
-int main() {
-    std::cout << "\n";
-    std::cout << "╔════════════════════════════════════════════════════���══════════════════════════════════════════════════════════════╗\n";
-    std::cout << "║                              Orderflow Replay Engine — Performance Benchmark                                    ║\n";
-    std::cout << "╚═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝\n\n";
-
-    const int N = 100000;
-
-    std::vector<BenchResult> results;
-    results.push_back(bench_insert_no_match(N));
-    results.push_back(bench_match(N));
-    results.push_back(bench_cancel(N));
-    results.push_back(bench_snapshot(N));
-    results.push_back(bench_full_pipeline(N));
-
-    std::cout << "--- Latency Results (N = " << N << " ops each) ---\n\n";
-    for (auto& r : results) print_result(r);
-
-    bench_backtest_throughput();
-
-    std::cout << "\n--- Memory ---\n";
-    std::cout << "  sizeof(Order):           " << sizeof(Order) << " bytes\n";
-    std::cout << "  sizeof(Trade):           " << sizeof(Trade) << " bytes\n";
-    std::cout << "  sizeof(PriceLevel):      " << sizeof(PriceLevel) << " bytes\n";
-    std::cout << "  sizeof(MarketDataTick):  " << sizeof(MarketDataTick) << " bytes\n";
-
-    std::cout << "\nDone.\n\n";
-    return 0;
-}