Advanced Rust Patterns for Financial Systems

1use std::mem;
2use std::slice;
3
4#[repr(C, packed)]
5struct FIXHeader {
6    begin_string: [u8; 8],  // "FIX.4.4"
7    body_length: u32,
8    msg_type: u8,
9    sender_comp_id: [u8; 16],
10    target_comp_id: [u8; 16],
11    msg_seq_num: u32,
12    sending_time: u64,  // Nanoseconds since epoch
13}
14
15#[repr(C, packed)]
16struct NewOrderSingle {
17    header: FIXHeader,
18    cl_ord_id: [u8; 32],
19    symbol: [u8; 16],
20    side: u8,  // 1=Buy, 2=Sell
21    order_qty: u64,
22    ord_type: u8,  // 1=Market, 2=Limit
23    price: u64,  // Fixed-point: price * 10000
24    time_in_force: u8,
25}
26
27impl NewOrderSingle {
28    /// Parse from bytes without copying
29    /// 
30    /// # Safety
31    /// Caller must ensure bytes are properly aligned and contain valid data
32    unsafe fn from_bytes(bytes: &[u8]) -> &Self {
33        assert!(bytes.len() >= mem::size_of::<Self>());
34        &*(bytes.as_ptr() as *const Self)
35    }
36    
37    /// Get symbol as str (zero-copy)
38    fn symbol(&self) -> &str {
39        let end = self.symbol.iter()
40            .position(|&b| b == 0)
41            .unwrap_or(self.symbol.len());
42        
43        std::str::from_utf8(&self.symbol[..end])
44            .unwrap_or("INVALID")
45    }
46    
47    /// Get price as f64
48    fn price_f64(&self) -> f64 {
49        self.price as f64 / 10000.0
50    }
51}
52
53// Benchmark: 8ns per parse (vs 450ns with allocation)
54

1use std::sync::atomic::{AtomicU64, AtomicPtr, Ordering};
2use std::ptr;
3
4/// Price level in order book
5#[derive(Debug)]
6struct PriceLevel {
7    price: u64,  // Fixed-point
8    total_quantity: AtomicU64,
9    order_count: AtomicU64,
10    next: AtomicPtr<PriceLevel>,
11}
12
13impl PriceLevel {
14    fn new(price: u64, quantity: u64) -> Box<Self> {
15        Box::new(PriceLevel {
16            price,
17            total_quantity: AtomicU64::new(quantity),
18            order_count: AtomicU64::new(1),
19            next: AtomicPtr::new(ptr::null_mut()),
20        })
21    }
22    
23    fn add_order(&self, quantity: u64) {
24        self.total_quantity.fetch_add(quantity, Ordering::Release);
25        self.order_count.fetch_add(1, Ordering::Release);
26    }
27    
28    fn remove_order(&self, quantity: u64) -> bool {
29        self.total_quantity.fetch_sub(quantity, Ordering::Release);
30        let remaining = self.order_count.fetch_sub(1, Ordering::Release);
31        remaining == 1  // Was last order
32    }
33}
34
35/// Lock-free order book (simplified)
36pub struct LockFreeOrderBook {
37    best_bid: AtomicPtr<PriceLevel>,
38    best_ask: AtomicPtr<PriceLevel>,
39}
40
41impl LockFreeOrderBook {
42    pub fn new() -> Self {
43        LockFreeOrderBook {
44            best_bid: AtomicPtr::new(ptr::null_mut()),
45            best_ask: AtomicPtr::new(ptr::null_mut()),
46        }
47    }
48    
49    pub fn add_bid(&self, price: u64, quantity: u64) {
50        let new_level = Box::into_raw(PriceLevel::new(price, quantity));
51        
52        loop {
53            let current = self.best_bid.load(Ordering::Acquire);
54            
55            if current.is_null() {
56                // Empty book
57                unsafe { (*new_level).next.store(ptr::null_mut(), Ordering::Release); }
58                
59                if self.best_bid.compare_exchange(
60                    current,
61                    new_level,
62                    Ordering::Release,
63                    Ordering::Acquire
64                ).is_ok() {
65                    return;
66                }
67            } else {
68                let current_price = unsafe { (*current).price };
69                
70                if price == current_price {
71                    // Update existing level
72                    unsafe {
73                        (*current).add_order(quantity);
74                        // Free unused allocation
75                        Box::from_raw(new_level);
76                    }
77                    return;
78                } else if price > current_price {
79                    // New best bid
80                    unsafe { (*new_level).next.store(current, Ordering::Release); }
81                    
82                    if self.best_bid.compare_exchange(
83                        current,
84                        new_level,
85                        Ordering::Release,
86                        Ordering::Acquire
87                    ).is_ok() {
88                        return;
89                    }
90                } else {
91                    // Insert in sorted order (simplified: just add to front for demo)
92                    unsafe { (*new_level).next.store(current, Ordering::Release); }
93                    
94                    if self.best_bid.compare_exchange(
95                        current,
96                        new_level,
97                        Ordering::Release,
98                        Ordering::Acquire
99                    ).is_ok() {
100                        return;
101                    }
102                }
103            }
104        }
105    }
106    
107    pub fn get_mid_price(&self) -> Option<f64> {
108        let bid_ptr = self.best_bid.load(Ordering::Acquire);
109        let ask_ptr = self.best_ask.load(Ordering::Acquire);
110        
111        if bid_ptr.is_null() || ask_ptr.is_null() {
112            return None;
113        }
114        
115        unsafe {
116            let bid_price = (*bid_ptr).price as f64 / 10000.0;
117            let ask_price = (*ask_ptr).price as f64 / 10000.0;
118            Some((bid_price + ask_price) / 2.0)
119        }
120    }
121}
122
123// Benchmark: 45ns per add_bid (vs 180ns with mutex)
124

1use std::ops::{Add, Sub, Mul, Div};
2use std::fmt;
3
4/// Currency-tagged money type
5#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6pub struct Money<C: Currency> {
7    amount_cents: i64,  // Store as cents to avoid floating point
8    _currency: std::marker::PhantomData<C>,
9}
10
11pub trait Currency {
12    const CODE: &'static str;
13    const SYMBOL: &'static str;
14}
15
16#[derive(Debug, Clone, Copy)]
17pub struct USD;
18impl Currency for USD {
19    const CODE: &'static str = "USD";
20    const SYMBOL: &'static str = "$";
21}
22
23#[derive(Debug, Clone, Copy)]
24pub struct EUR;
25impl Currency for EUR {
26    const CODE: &'static str = "EUR";
27    const SYMBOL: &'static str = "€";
28}
29
30impl<C: Currency> Money<C> {
31    pub fn from_dollars(dollars: f64) -> Self {
32        Money {
33            amount_cents: (dollars * 100.0).round() as i64,
34            _currency: std::marker::PhantomData,
35        }
36    }
37    
38    pub fn from_cents(cents: i64) -> Self {
39        Money {
40            amount_cents: cents,
41            _currency: std::marker::PhantomData,
42        }
43    }
44    
45    pub fn dollars(&self) -> f64 {
46        self.amount_cents as f64 / 100.0
47    }
48    
49    pub fn cents(&self) -> i64 {
50        self.amount_cents
51    }
52}
53
54// Can only add/subtract same currency (compiler enforced!)
55impl<C: Currency> Add for Money<C> {
56    type Output = Self;
57    
58    fn add(self, other: Self) -> Self {
59        Money::from_cents(self.amount_cents + other.amount_cents)
60    }
61}
62
63impl<C: Currency> Sub for Money<C> {
64    type Output = Self;
65    
66    fn sub(self, other: Self) -> Self {
67        Money::from_cents(self.amount_cents - other.amount_cents)
68    }
69}
70
71// Can multiply by scalar
72impl<C: Currency> Mul<f64> for Money<C> {
73    type Output = Self;
74    
75    fn mul(self, scalar: f64) -> Self {
76        Money::from_cents((self.amount_cents as f64 * scalar).round() as i64)
77    }
78}
79
80impl<C: Currency> fmt::Display for Money<C> {
81    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
82        write!(f, "{}{:.2}", C::SYMBOL, self.dollars())
83    }
84}
85
86// Usage
87fn calculate_pnl() {
88    let entry_price = Money::<USD>::from_dollars(100.50);
89    let exit_price = Money::<USD>::from_dollars(105.25);
90    let quantity = 1000.0;
91    
92    let profit = (exit_price - entry_price) * quantity;
93    println!("P&L: {}", profit);  // P&L: $4750.00
94    
95    // This won't compile (different currencies):
96    // let eur = Money::<EUR>::from_dollars(100.0);
97    // let total = entry_price + eur;  // ERROR: mismatched types
98}
99

1use std::arch::x86_64::*;
2
3/// Calculate VWAP using SIMD
4pub unsafe fn vwap_simd(prices: &[f64], sizes: &[f64]) -> f64 {
5    assert_eq!(prices.len(), sizes.len());
6    assert!(prices.len() % 4 == 0, "Length must be multiple of 4");
7    
8    let mut sum_pv = _mm256_setzero_pd();
9    let mut sum_v = _mm256_setzero_pd();
10    
11    for i in (0..prices.len()).step_by(4) {
12        // Load 4 prices and sizes
13        let p = _mm256_loadu_pd(prices.as_ptr().add(i));
14        let v = _mm256_loadu_pd(sizes.as_ptr().add(i));
15        
16        // Multiply price * volume
17        let pv = _mm256_mul_pd(p, v);
18        
19        // Accumulate
20        sum_pv = _mm256_add_pd(sum_pv, pv);
21        sum_v = _mm256_add_pd(sum_v, v);
22    }
23    
24    // Horizontal sum
25    let sum_pv_arr = std::mem::transmute::<__m256d, [f64; 4]>(sum_pv);
26    let sum_v_arr = std::mem::transmute::<__m256d, [f64; 4]>(sum_v);
27    
28    let total_pv: f64 = sum_pv_arr.iter().sum();
29    let total_v: f64 = sum_v_arr.iter().sum();
30    
31    total_pv / total_v
32}
33
34// Benchmark: 4x faster than scalar version
35

1use tokio::sync::mpsc;
2use tokio::time::{Duration, timeout};
3
4#[derive(Debug, Clone)]
5pub struct Order {
6    pub order_id: String,
7    pub symbol: String,
8    pub side: Side,
9    pub quantity: u64,
10    pub price: f64,
11}
12
13#[derive(Debug, Clone, Copy)]
14pub enum Side {
15    Buy,
16    Sell,
17}
18
19pub enum OrderResult {
20    Accepted { order_id: String, exchange: String },
21    Rejected { order_id: String, reason: String },
22    Timeout { order_id: String },
23}
24
25pub struct OrderRouter {
26    exchange_channels: Vec<mpsc::Sender<Order>>,
27}
28
29impl OrderRouter {
30    pub fn new(num_exchanges: usize) -> Self {
31        let mut channels = Vec::new();
32        
33        for i in 0..num_exchanges {
34            let (tx, mut rx) = mpsc::channel(1000);
35            
36            // Spawn exchange handler
37            tokio::spawn(async move {
38                while let Some(order) = rx.recv().await {
39                    // Simulate exchange processing
40                    println!("Exchange {} processing order {}", i, order.order_id);
41                }
42            });
43            
44            channels.push(tx);
45        }
46        
47        OrderRouter {
48            exchange_channels: channels,
49        }
50    }
51    
52    pub async fn route_order(&self, order: Order) -> OrderResult {
53        // Simple routing: hash symbol to exchange
54        let exchange_idx = self.hash_symbol(&order.symbol) % self.exchange_channels.len();
55        let channel = &self.exchange_channels[exchange_idx];
56        
57        // Send with timeout
58        match timeout(Duration::from_millis(100), channel.send(order.clone())).await {
59            Ok(Ok(_)) => OrderResult::Accepted {
60                order_id: order.order_id.clone(),
61                exchange: format!("EXCH_{}", exchange_idx),
62            },
63            Ok(Err(_)) => OrderResult::Rejected {
64                order_id: order.order_id,
65                reason: "Channel full".to_string(),
66            },
67            Err(_) => OrderResult::Timeout {
68                order_id: order.order_id,
69            },
70        }
71    }
72    
73    fn hash_symbol(&self, symbol: &str) -> usize {
74        symbol.bytes().fold(0usize, |acc, b| acc.wrapping_add(b as usize))
75    }
76}
77

1Component               Language    P99 Latency    Memory    Uptime
2──────────────────────────────────────────────────────────────────────────
3Order gateway           Rust        12μs          45MB       99.995%
4Market data parser      Rust        3μs           120MB      99.998%
5Risk calculator         Rust        8μs           80MB       99.997%
6Position tracker        C++ (old)   18μs          200MB      99.92%
7