Rust for Financial Systems: Beyond Memory Safety

1use crossbeam::epoch::{self, Atomic, Owned};
2use std::sync::atomic::Ordering;
3use std::cmp::Ordering as CmpOrdering;
4
5#[derive(Clone)]
6struct Order {
7    price: u64,      // Fixed-point price (e.g., cents)
8    quantity: u32,
9    order_id: u64,
10}
11
12struct OrderBook {
13    bids: Atomic<Node>,  // Best bid at head
14    asks: Atomic<Node>,  // Best ask at head
15}
16
17struct Node {
18    order: Order,
19    next: Atomic<Node>,
20}
21
22impl OrderBook {
23    fn new() -> Self {
24        OrderBook {
25            bids: Atomic::null(),
26            asks: Atomic::null(),
27        }
28    }
29
30    fn insert_bid(&self, order: Order) {
31        let guard = epoch::pin();
32        loop {
33            let head = self.bids.load(Ordering::Acquire, &guard);
34            let new_node = Owned::new(Node {
35                order: order.clone(),
36                next: Atomic::from(head),
37            });
38            
39            match self.bids.compare_exchange(
40                head,
41                new_node,
42                Ordering::Release,
43                Ordering::Acquire,
44                &guard,
45            ) {
46                Ok(_) => break,
47                Err(e) => {
48                    // Retry with updated head
49                    continue;
50                }
51            }
52        }
53    }
54
55    fn best_bid(&self) -> Option<Order> {
56        let guard = epoch::pin();
57        let head = self.bids.load(Ordering::Acquire, &guard);
58        unsafe { head.as_ref() }.map(|node| node.order.clone())
59    }
60}
61

1use nom::{
2    bytes::complete::{tag, take_until},
3    character::complete::digit1,
4    sequence::tuple,
5    IResult,
6};
7
8#[derive(Debug)]
9struct FixMessage<'a> {
10    msg_type: &'a [u8],
11    sender: &'a [u8],
12    target: &'a [u8],
13    body: &'a [u8],
14}
15
16fn parse_fix_field(input: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
17    let (input, (tag_num, _, value, _)) = tuple((
18        digit1,
19        tag(b"="),
20        take_until(&b"\x01"[..]),
21        tag(b"\x01"),
22    ))(input)?;
23    Ok((input, (tag_num, value)))
24}
25
26fn parse_fix_message(input: &[u8]) -> IResult<&[u8], FixMessage> {
27    let mut msg_type = b"";
28    let mut sender = b"";
29    let mut target = b"";
30    let mut remaining = input;
31
32    while !remaining.is_empty() {
33        let (rest, (tag, value)) = parse_fix_field(remaining)?;
34        match tag {
35            b"35" => msg_type = value,
36            b"49" => sender = value,
37            b"56" => target = value,
38            _ => {}
39        }
40        remaining = rest;
41    }
42
43    Ok((remaining, FixMessage {
44        msg_type,
45        sender,
46        target,
47        body: input,
48    }))
49}
50
51// Usage: zero-copy, stack-only parsing
52let msg = b"35=D\x0149=SENDER\x0156=TARGET\x01";
53let (_, parsed) = parse_fix_message(msg).unwrap();
54assert_eq!(parsed.msg_type, b"D");
55

1use std::alloc::{alloc, dealloc, Layout};
2use std::ptr::NonNull;
3
4struct BumpAllocator {
5    buffer: NonNull<u8>,
6    capacity: usize,
7    offset: usize,
8}
9
10impl BumpAllocator {
11    fn new(capacity: usize) -> Self {
12        let layout = Layout::from_size_align(capacity, 64).unwrap();
13        let buffer = unsafe { NonNull::new_unchecked(alloc(layout)) };
14        BumpAllocator {
15            buffer,
16            capacity,
17            offset: 0,
18        }
19    }
20
21    fn allocate<T>(&mut self) -> Option<&mut T> {
22        let size = std::mem::size_of::<T>();
23        let align = std::mem::align_of::<T>();
24        
25        // Align offset
26        let aligned_offset = (self.offset + align - 1) & !(align - 1);
27        
28        if aligned_offset + size > self.capacity {
29            return None;
30        }
31
32        let ptr = unsafe {
33            self.buffer.as_ptr().add(aligned_offset) as *mut T
34        };
35        self.offset = aligned_offset + size;
36        
37        Some(unsafe { &mut *ptr })
38    }
39
40    fn reset(&mut self) {
41        self.offset = 0;
42    }
43}
44
45impl Drop for BumpAllocator {
46    fn drop(&mut self) {
47        let layout = Layout::from_size_align(self.capacity, 64).unwrap();
48        unsafe { dealloc(self.buffer.as_ptr(), layout) };
49    }
50}
51
52// Usage: per-request arena
53let mut arena = BumpAllocator::new(4096);
54let order: &mut Order = arena.allocate().unwrap();
55order.price = 10050;
56// ... process order ...
57arena.reset();  // Reuse for next request
58

1use tokio::net::UdpSocket;
2use tokio::sync::mpsc;
3use std::net::SocketAddr;
4
5#[derive(Debug, Clone)]
6struct MarketData {
7    symbol: [u8; 8],
8    price: u64,
9    quantity: u32,
10    timestamp: u64,
11}
12
13async fn market_data_receiver(
14    addr: SocketAddr,
15    tx: mpsc::Sender<MarketData>,
16) -> Result<(), Box<dyn std::error::Error>> {
17    let socket = UdpSocket::bind(addr).await?;
18    let mut buf = vec![0u8; 1500];
19
20    loop {
21        let (len, _) = socket.recv_from(&mut buf).await?;
22        
23        // Parse binary market data (simplified)
24        if len >= 24 {
25            let data = MarketData {
26                symbol: buf[0..8].try_into().unwrap(),
27                price: u64::from_le_bytes(buf[8..16].try_into().unwrap()),
28                quantity: u32::from_le_bytes(buf[16..20].try_into().unwrap()),
29                timestamp: u64::from_le_bytes(buf[20..28].try_into().unwrap()),
30            };
31            
32            // Non-blocking send
33            let _ = tx.try_send(data);
34        }
35    }
36}
37
38#[tokio::main]
39async fn main() {
40    let (tx, mut rx) = mpsc::channel::<MarketData>(10_000);
41    
42    // Spawn receiver task
43    tokio::spawn(async move {
44        market_data_receiver("0.0.0.0:9000".parse().unwrap(), tx)
45            .await
46            .unwrap();
47    });
48
49    // Process market data
50    while let Some(data) = rx.recv().await {
51        // Update order book, calculate signals, etc.
52        println!("Received: {:?}", data);
53    }
54}
55

1#![feature(portable_simd)]
2use std::simd::f64x4;
3
4fn black_scholes_simd(
5    spot: f64x4,
6    strike: f64x4,
7    rate: f64x4,
8    volatility: f64x4,
9    time: f64x4,
10) -> f64x4 {
11    let sqrt_time = time.sqrt();
12    let d1 = ((spot / strike).ln() + (rate + volatility * volatility * 0.5) * time)
13        / (volatility * sqrt_time);
14    let d2 = d1 - volatility * sqrt_time;
15    
16    // Simplified: actual implementation needs normal CDF
17    let call_price = spot * norm_cdf_simd(d1) - strike * (-rate * time).exp() * norm_cdf_simd(d2);
18    call_price
19}
20
21fn norm_cdf_simd(x: f64x4) -> f64x4 {
22    // Approximation for normal CDF (simplified)
23    let t = f64x4::splat(1.0) / (f64x4::splat(1.0) + f64x4::splat(0.2316419) * x.abs());
24    let poly = t * (f64x4::splat(0.319381530)
25        + t * (f64x4::splat(-0.356563782)
26        + t * (f64x4::splat(1.781477937)
27        + t * (f64x4::splat(-1.821255978)
28        + t * f64x4::splat(1.330274429)))));
29    
30    let result = f64x4::splat(1.0) - poly * (-x * x * f64x4::splat(0.5)).exp() * f64x4::splat(0.3989423);
31    result
32}
33
34// Price 4 options simultaneously
35let spots = f64x4::from_array([100.0, 105.0, 110.0, 115.0]);
36let strikes = f64x4::splat(100.0);
37let rates = f64x4::splat(0.05);
38let vols = f64x4::splat(0.2);
39let times = f64x4::splat(1.0);
40
41let prices = black_scholes_simd(spots, strikes, rates, vols, times);
42

1// C++ header (pricing.hpp)
2// extern "C" {
3//     double calculate_npv(const Trade* trade, const MarketData* market);
4// }
5
6#[repr(C)]
7struct Trade {
8    trade_id: u64,
9    notional: f64,
10    maturity: f64,
11}
12
13#[repr(C)]
14struct MarketData {
15    spot: f64,
16    rate: f64,
17    volatility: f64,
18}
19
20extern "C" {
21    fn calculate_npv(trade: *const Trade, market: *const MarketData) -> f64;
22}
23
24fn price_trade(trade: &Trade, market: &MarketData) -> f64 {
25    unsafe { calculate_npv(trade as *const Trade, market as *const MarketData) }
26}
27
28// Usage
29let trade = Trade {
30    trade_id: 12345,
31    notional: 1_000_000.0,
32    maturity: 1.0,
33};
34let market = MarketData {
35    spot: 100.0,
36    rate: 0.05,
37    volatility: 0.2,
38};
39let npv = price_trade(&trade, &market);
40

1cargo install flamegraph
2cargo flamegraph --bin trading_engine
3

1perf stat -e cache-misses,cache-references ./target/release/trading_engine
2

1use criterion::{black_box, criterion_group, criterion_main, Criterion};
2
3fn benchmark_order_insert(c: &mut Criterion) {
4    let book = OrderBook::new();
5    c.bench_function("insert_bid", |b| {
6        b.iter(|| {
7            book.insert_bid(black_box(Order {
8                price: 10050,
9                quantity: 100,
10                order_id: 1,
11            }))
12        })
13    });
14}
15
16criterion_group!(benches, benchmark_order_insert);
17criterion_main!(benches);
18