feat(perf): HFT memory array & compiler optimizations

Author: randomfunction

.github/workflows/pipeline.yml

@@ -17,7 +17,7 @@ jobs:
         languages: cpp
 
     - run: |
-        g++ -o engine_test main.cpp
+        g++ -O3 -march=native -flto -o engine_test main.cpp
         ./engine_test --test
         
     - uses: github/codeql-action/analyze@v3

Dockerfile

@@ -2,6 +2,6 @@ FROM ubuntu:22.04
 RUN apt-get update && apt-get install -y g++
 WORKDIR /app
 COPY main.cpp .
-RUN g++ -o engine main.cpp
+RUN g++ -O3 -march=native -flto -o engine main.cpp
 USER 1001
 CMD ["./engine"]

engine_test.exe

@@ -1,49 +1,74 @@
 #include <iostream>
-#include <queue>
 #include <vector>
 #include <cassert>
 #include <thread>
 #include <chrono>
 #include <string>
+#include <cstdint>
+#include <algorithm>
 
-struct Order {
+// Phase 4: Cache Line Optimization
+// 64-byte alignment and tightly packed variables.
+// Fits perfectly into L1 cache lines.
+struct alignas(64) Order {
     double price;
-    int quantity;
+    uint32_t quantity;
     bool is_buy;
 };
 
-struct CompareBuy {
-    bool operator()(const Order& a, const Order& b) { return a.price < b.price; }
+// Phase 4 & Phase 2: Align arrays to cache lines 
+struct alignas(64) LevelData {
+    uint32_t buy_quantity = 0;
+    uint32_t sell_quantity = 0;
 };
 
-struct CompareSell {
-    bool operator()(const Order& a, const Order& b) { return a.price > b.price; }
-};
+// Phase 2 & 3: O(1) Array with Pre-allocated Memory
+constexpr size_t MAX_PRICE_LEVELS = 1000000;
 
 class OrderBook {
-    std::priority_queue<Order, std::vector<Order>, CompareBuy> buys;
-    std::priority_queue<Order, std::vector<Order>, CompareSell> sells;
-    int trades_executed = 0;
+    // Phase 2: Reserving this once keeps dynamic allocations OUT of the trading path
+    std::vector<LevelData> book;
+    uint32_t trades_executed = 0;
+
+    int max_buy_price = 0;
+    int min_sell_price = static_cast<int>(MAX_PRICE_LEVELS);
 
 public:
+    OrderBook() {
+        book.resize(MAX_PRICE_LEVELS);
+    }
+
     void addOrder(const Order& order) {
-        if (order.is_buy) buys.push(order);
-        else sells.push(order);
+        // Phase 3: Array Index represents price level (O(1) access)
+        int price_index = static_cast<int>(order.price * 100);
+        
+        if (order.is_buy) {
+            book[price_index].buy_quantity += order.quantity;
+            if (price_index > max_buy_price) max_buy_price = price_index;
+        } else {
+            book[price_index].sell_quantity += order.quantity;
+            if (price_index < min_sell_price) min_sell_price = price_index;
+        }
         match();
     }
 
     void match() {
-        while (!buys.empty() && !sells.empty() && buys.top().price >= sells.top().price) {
-            Order b = buys.top(); buys.pop();
-            Order s = sells.top(); sells.pop();
-            int traded = std::min(b.quantity, s.quantity);
+        while (max_buy_price >= min_sell_price) {
+            while (max_buy_price >= 0 && book[max_buy_price].buy_quantity == 0) {
+                max_buy_price--;
+            }
+            while (min_sell_price < static_cast<int>(MAX_PRICE_LEVELS) && book[min_sell_price].sell_quantity == 0) {
+                min_sell_price++;
+            }
+            
+            if (max_buy_price < min_sell_price || max_buy_price < 0 || min_sell_price >= static_cast<int>(MAX_PRICE_LEVELS)) {
+                break;
+            }
 
-            b.quantity -= traded;
-            s.quantity -= traded;
+            uint32_t traded = std::min(book[max_buy_price].buy_quantity, book[min_sell_price].sell_quantity);
+            book[max_buy_price].buy_quantity -= traded;
+            book[min_sell_price].sell_quantity -= traded;
             trades_executed++;
-
-            if (b.quantity > 0) buys.push(b);
-            if (s.quantity > 0) sells.push(s);
         }
     }