Add Pro C++ TMP, Lock-Free Queue, and Market Making Model

Author: shreejitverma

05_algorithmic_trading/strategies/market_microstructure/avellaneda_stoikov_mm.py

@@ -0,0 +1,99 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class AvellanedaStoikovSimulator:
+    """
+    Simulates the Avellaneda-Stoikov Market Making model.
+    
+    Reference: "High-frequency trading in a limit order book" (2008)
+    
+    Key Concepts:
+    - Inventory Risk: As q (inventory) deviates from 0, we skew quotes to revert.
+    - Reservation Price: r(s, t, q) = s - q * gamma * sigma^2 * (T - t)
+    - Optimal Spread: Depends on kappa (market order arrival intensity).
+    """
+    
+    def __init__(self, S0=100, T=1.0, sigma=2, dt=0.005, gamma=0.1, k=1.5, A=140):
+        self.S0 = S0       # Initial Price
+        self.T = T         # Total Time
+        self.sigma = sigma # Volatility
+        self.dt = dt       # Time step
+        self.gamma = gamma # Risk aversion
+        self.k = k         # Order book liquidity param
+        self.A = A         # Order arrival rate param
+        
+        self.M = int(T/dt)
+        self.time = np.linspace(0, T, self.M+1)
+        
+    def run(self):
+        S = np.zeros(self.M+1)
+        q = np.zeros(self.M+1) # Inventory
+        cash = np.zeros(self.M+1)
+        wealth = np.zeros(self.M+1)
+        
+        S[0] = self.S0
+        
+        for i in range(1, self.M+1):
+            # 1. Evolve Mid-Price (Geometric Brownian Motion)
+            dW = np.random.normal(0, np.sqrt(self.dt))
+            S[i] = S[i-1] + self.sigma * dW
+            
+            # 2. Calculate Reservation Price and Quotes
+            # r = S - q * gamma * sigma^2 * (T - t)
+            remaining_time = self.T - self.time[i-1]
+            reservation_price = S[i-1] - q[i-1] * self.gamma * (self.sigma**2) * remaining_time
+            
+            # spread = gamma * sigma^2 * (T - t) + (2/gamma) * ln(1 + gamma/k)
+            spread = self.gamma * (self.sigma**2) * remaining_time + (2/self.gamma) * np.log(1 + self.gamma/self.k)
+            
+            bid = reservation_price - spread/2
+            ask = reservation_price + spread/2
+            
+            # 3. Simulate Market Order Arrivals (Poisson Process)
+            # Prob of fill decays exponentially with distance from mid-price (delta)
+            delta_b = S[i-1] - bid
+            delta_a = ask - S[i-1]
+            
+            lambda_b = self.A * np.exp(-self.k * delta_b)
+            lambda_a = self.A * np.exp(-self.k * delta_a)
+            
+            prob_b = lambda_b * self.dt
+            prob_a = lambda_a * self.dt
+            
+            # Execution
+            q[i] = q[i-1]
+            cash[i] = cash[i-1]
+            
+            # Did someone hit our bid? (We buy)
+            if np.random.rand() < prob_b:
+                q[i] += 1
+                cash[i] -= bid
+                
+            # Did someone lift our ask? (We sell)
+            if np.random.rand() < prob_a:
+                q[i] -= 1
+                cash[i] += ask
+                
+            wealth[i] = cash[i] + q[i] * S[i]
+            
+        return self.time, S, q, wealth
+
+if __name__ == "__main__":
+    sim = AvellanedaStoikovSimulator()
+    t, S, q, W = sim.run()
+    
+    fig, ax = plt.subplots(3, 1, figsize=(10, 12), sharex=True)
+    
+    ax[0].plot(t, S, label='Mid Price')
+    ax[0].set_title('Stock Price')
+    ax[0].grid(True)
+    
+    ax[1].plot(t, q, label='Inventory (q)', color='orange')
+    ax[1].set_title('Inventory Position')
+    ax[1].grid(True)
+    
+    ax[2].plot(t, W, label='Total Wealth', color='green')
+    ax[2].set_title('P&L (Wealth)')
+    ax[2].grid(True)
+    
+    plt.show()

06_quantitative_development/cpp_low_latency/examples/compile_time_greeks.cpp

@@ -0,0 +1,71 @@
+#include <iostream>
+#include <array>
+#include <cmath>
+
+/**
+ * Compile-Time Math using C++20 'consteval' / 'constexpr'.
+ * 
+ * In HFT, we often replace runtime math functions (pow, exp, sqrt) with:
+ * 1. Lookup Tables (LUT).
+ * 2. Polynomial Approximations.
+ * 
+ * This example generates a Standard Normal CDF Lookup Table at compile time.
+ */
+
+// Approximate CDF of Normal Distribution (Error < 0.0003)
+constexpr double normal_cdf(double x) {
+    // Constants for approximation
+    constexpr double p = 0.2316419;
+    constexpr double b1 = 0.319381530;
+    constexpr double b2 = -0.356563782;
+    constexpr double b3 = 1.781477937;
+    constexpr double b4 = -1.821255978;
+    constexpr double b5 = 1.330274429;
+
+    if (x < 0.0) return 1.0 - normal_cdf(-x);
+
+    double t = 1.0 / (1.0 + p * x);
+    double pdf = (1.0 / 2.50662827463) * std::exp(-0.5 * x * x); // 1/sqrt(2pi)
+    
+    return 1.0 - pdf * (b1*t + b2*t*t + b3*t*t*t + b4*t*t*t*t + b5*t*t*t*t*t);
+}
+
+// Generate LUT at compile time
+template<size_t N>
+struct NormalCDFTable {
+    std::array<double, N> values;
+    double min_x;
+    double max_x;
+    double step;
+
+    constexpr NormalCDFTable(double min_val, double max_val) 
+        : values{}, min_x(min_val), max_x(max_val), step((max_val - min_val) / (N - 1)) {
+        
+        for (size_t i = 0; i < N; ++i) {
+            double x = min_x + i * step;
+            values[i] = normal_cdf(x);
+        }
+    }
+
+    // Runtime lookup is O(1) array access
+    constexpr double lookup(double x) const {
+        if (x <= min_x) return 0.0;
+        if (x >= max_x) return 1.0;
+        
+        size_t index = static_cast<size_t>((x - min_x) / step);
+        return values[index];
+    }
+};
+
+// Create the table in the data segment (zero runtime initialization cost)
+constexpr auto cdf_table = NormalCDFTable<1000>(-4.0, 4.0);
+
+int main() {
+    // This value is fetched from memory, no calculation performed at runtime.
+    std::cout << "N(0.0) = " << cdf_table.lookup(0.0) << std::endl;
+    std::cout << "N(1.96) = " << cdf_table.lookup(1.96) << std::endl;
+    
+    static_assert(cdf_table.lookup(0.0) > 0.49 && cdf_table.lookup(0.0) < 0.51, "Compile time check failed");
+
+    return 0;
+}

06_quantitative_development/cpp_low_latency/examples/lock_free_spsc_queue.cpp

@@ -2,78 +2,86 @@
 #include <vector>
 #include <iostream>
 #include <thread>
+#include <chrono>
 
 /**
- * @brief Lock-Free Single Producer Single Consumer (SPSC) Ring Buffer.
- *
- * Key Concepts for Interviews:
- * 1. std::atomic for thread-safe indices.
- * 2. std::memory_order_acquire/release to ensure visibility without full fences.
- * 3. Cache line padding (false sharing prevention) using alignas.
+ * Lock-Free Single-Producer Single-Consumer (SPSC) Queue.
+ * 
+ * Concept:
+ * - Uses a Ring Buffer (circular array).
+ * - 'head' is modified by Producer.
+ * - 'tail' is modified by Consumer.
+ * - 'std::atomic' with 'memory_order_acquire' / 'memory_order_release' ensures
+ *   we don't see stale data without needing a full mutex lock.
+ * 
+ * Usage in HFT:
+ * - Thread A (Network): Pushes market data packets.
+ * - Thread B (Strategy): Pops packets and processes.
  */
 
-template<typename T, size_t Size>
-class RingBuffer {
+template<typename T, size_t Capacity>
+class LockFreeSPSCQueue {
+private:
+    std::vector<T> buffer;
+    alignas(64) std::atomic<size_t> head; // Producer index
+    alignas(64) std::atomic<size_t> tail; // Consumer index
+    // alignas(64) prevents False Sharing (cache line thrashing)
+
 public:
-    RingBuffer() : head_(0), tail_(0) {}
+    LockFreeSPSCQueue() : buffer(Capacity + 1), head(0), tail(0) {}
 
-    bool push(const T& val) {
-        size_t head = head_.load(std::memory_order_relaxed);
-        size_t next_head = (head + 1) % Size;
+    bool push(const T& item) {
+        size_t current_head = head.load(std::memory_order_relaxed);
+        size_t next_head = (current_head + 1) % buffer.size();
 
-        if (next_head == tail_.load(std::memory_order_acquire)) {
-            return false; // Buffer full
+        if (next_head == tail.load(std::memory_order_acquire)) {
+            return false; // Full
         }
 
-        buffer_[head] = val;
-        head_.store(next_head, std::memory_order_release);
+        buffer[current_head] = item;
+        head.store(next_head, std::memory_order_release);
         return true;
     }
 
-    bool pop(T& val) {
-        size_t tail = tail_.load(std::memory_order_relaxed);
+    bool pop(T& item) {
+        size_t current_tail = tail.load(std::memory_order_relaxed);
 
-        if (tail == head_.load(std::memory_order_acquire)) {
-            return false; // Buffer empty
+        if (current_tail == head.load(std::memory_order_acquire)) {
+            return false; // Empty
         }
 
-        val = buffer_[tail];
-        tail_.store((tail + 1) % Size, std::memory_order_release);
+        item = buffer[current_tail];
+        tail.store((current_tail + 1) % buffer.size(), std::memory_order_release);
         return true;
     }
-
-private:
-    std::vector<T> buffer_{Size};
-
-    // Align to cache line size (usually 64 bytes) to prevent false sharing
-    alignas(64) std::atomic<size_t> head_;
-    alignas(64) std::atomic<size_t> tail_;
 };
 
 int main() {
-    RingBuffer<int, 1024> rb;
+    LockFreeSPSCQueue<int, 1024> queue;
 
     std::thread producer([&]() {
-        for (int i = 0; i < 1000; ++i) {
-            while (!rb.push(i)) {
-                // Spin wait strategy often used in low latency
+        for (int i = 0; i < 100; ++i) {
+            while (!queue.push(i)) {
+                // Busy wait or yield
                 std::this_thread::yield();
             }
         }
     });
 
     std::thread consumer([&]() {
         int val;
-        for (int i = 0; i < 1000; ++i) {
-            while (!rb.pop(val)) {
-                std::this_thread::yield();
+        int count = 0;
+        while (count < 100) {
+            if (queue.pop(val)) {
+                // Process val
+                count++;
             }
-            // std::cout << "Popped: " << val << std::endl; // IO is slow, avoid in HFT loop
         }
+        std::cout << "Consumer finished processing " << count << " items." << std::endl;
     });
 
     producer.join();
     consumer.join();
-    std::cout << "Finished SPSC test." << std::endl;
+
     return 0;
-}
+}

README.md

@@ -32,14 +32,14 @@ Whether you are aiming for a **Quantitative Researcher** role (heavy math/stats/
 We have curated specialized resources that target the specific requirements of HFT and Prop Trading interviews.
 
 ### ⚡ Low Latency & Systems
-*   **C++ Mastery:** [Order Matching Engine](./06_quantitative_development/cpp_low_latency/examples/order_matching_engine.cpp) & [Memory Pool Allocator](./06_quantitative_development/cpp_low_latency/examples/memory_pool.cpp).
+*   **C++ Mastery:** [Order Matching Engine](./06_quantitative_development/cpp_low_latency/examples/order_matching_engine.cpp), [Lock-Free Queue](./06_quantitative_development/cpp_low_latency/examples/lock_free_spsc_queue.cpp), & [Memory Pool](./06_quantitative_development/cpp_low_latency/examples/memory_pool.cpp).
+*   **Template Metaprogramming:** [Compile-Time Greeks](./06_quantitative_development/cpp_low_latency/examples/compile_time_greeks.cpp) (C++20 `consteval` LUTs).
 *   **Market Data:** [ITCH Feed Handler](./06_quantitative_development/data_engineering/market_data/itch_parser_mock.py).
-*   **Java Performance:** [GC-Free Coding](./06_quantitative_development/java_low_latency/README.md).
 *   **Architecture:** [HFT Infrastructure](./06_quantitative_development/system_design/architecture_notes/hft_architecture.md).
 
 ### 🧠 Interview Mastery
 *   **The Roadmap:** [8-Week Study Plan](./07_interview_preparation/study_roadmap.md).
-*   **Quant Strategies:** [Pairs Trading (Stat Arb)](./05_algorithmic_trading/strategies/systematic_strategies/pairs_trading_stat_arb.ipynb) & [Event-Driven Backtester](./05_algorithmic_trading/backtesting_frameworks/simple_event_driven.py).
+*   **Quant Strategies:** [Avellaneda-Stoikov Market Making](./05_algorithmic_trading/strategies/market_microstructure/avellaneda_stoikov_mm.py) & [Pairs Trading](./05_algorithmic_trading/strategies/systematic_strategies/pairs_trading_stat_arb.ipynb).
 *   **Jane Street Guide:** [Probability & Betting](./07_interview_preparation/company_insights/jane_street_guide.md).
 *   **Quant Math:** [Green Book Companion](./01_foundations/mathematics/probability/quant_probability_guide.md).