In algorithmic trading, speed, correctness and efficiency are paramount, and utilizing multithreading can significantly enhance the performance of trading systems. Rust, with its focus on safety, concurrency, and performance, provides a powerful language for building high-performance trading systems. Rust's ownership and borrowing system helps enforce thread safety at compile time. In this article, we will see multithreading in Rust in the context of an algorithmic trading application. Multiple threads can process market data concurrently, enabling faster signal generation and ultimately reducing the latency and increasing the overall throughput of the trading system. Trading systems can be extremely complex however on a high level, it has three components.
Market data feed: Simulated or real-time market data stream.
Signal generation: Analysis of market data to generate trading signals.
Order execution: Placement and execution of trading orders.
In a simple example of this system, we need at least three separate threads to handle simulating market data, signal generation, and order execution, allowing the trading system to react swiftly to market conditions.
Market Data Simulation
For the sake of simplicity for this blog, let's just simulate a single stock. A common way to represent an order book is by using a struct. Here's an example of a basic struct for an order book:
#[derive(Debug)]
struct Quote {
symbol: String,
bids: (f64, u32),
asks: (f64, u32),
}
#[derive(Debug)]
struct Order {
symbol: String,
quantity: i32,
price: f64,
order_type: String,
}
In this example, the Quote
struct has fields: bids
and asks
. Each field holds tuples representing the best price levels and quantities. You can further enhance the Quote
to hold the vector for bids and asks e.g. bids: Vec<(f64, u32)>
.
fn simulate_market_data() -> Quote {
let normal = rand_distr::Normal::new(0.0, 1.0).unwrap();
let z = normal.sample(&mut rand::thread_rng());
let st = 100.0;
let risk_free_rate = 0.05;
let volatility = 0.2;
let dt = 1.0/252.0;
let bidprice = st*exp(((risk_free_rate - 0.5 * volatility.powi(2)) * dt)+volatility * dt.sqrt()*z);
let askprice = bidprice + 0.05;
// Generate random quantity
let mut rng = rand::thread_rng();
let bid_quantity = rng.gen_range(100..1000);
let ask_quantity = rng.gen_range(100..1000);
let quote = OrderBook {
symbol: "SPY".to_string(),
bids: (bidprice, bid_quantity),
asks: (askprice, ask_quantity),
};
return quote
}
In this example, the simulate_market_data
function generates random market data and returns Quote.
Channels for inter-thread communication
Channel provides a built-in communication mechanism for inter-thread data exchange. It handles synchronization internally, reducing the likelihood of synchronization errors.
fn market_data(tx: mpsc::Sender<Quote>) {
loop {
// Generate market data
let order_data = simulate_market_data();
// Send market data to the main thread
tx.send(order_data).expect("Failed to send market data");
// Pause the execution for one millisecond
thread::sleep(Duration::from_millis(1));
}
}
We will run the market_data
function in a separate thread and repeatedly generates market data using simulate_market_data
. It sends the generated market data to the main thread via a channel (tx
) and wait for one millisecond to send another order data.
Spawn threads
fn main() {
// Create channels for inter-thread communication
let (tx, rx) = mpsc::channel();
let (tx_order, rx_order) = mpsc::channel();
// Spawn a thread for market data simulation
thread::spawn(move || {
market_data(tx);
});
// Receive and process market data in the separate thread
thread::spawn(move || {
signal_generation(rx,tx_order);
});
thread::spawn(move || {
order_management(rx_order);
});
loop{}
}
In the main
function, two channels are created for inter-thread communication using mpsc::channel()
. Then, three separate threads are spawned using thread::spawn
, where the market_data, signal_generation and order_management
functions are executed. The main thread continuously receives market data from the channel using rx.recv()
. Upon receiving market data, it can process it according to the requirements.
Signal generation and order management
fn signal_generation(rx: mpsc::Receiver<Quote>,tx_order: mpsc::Sender<Order>){
while let Ok(data) = rx.recv() {
// Process market data
println!("Received market data: {:?}", data);
let bid_price = data.bids.0;
let ask_price = data.asks.0;
if bid_price<100.0{
println!("Place BUY Order");
let order = Order {
symbol: data.symbol,
quantity: 1,
price: bid_price,
order_type: "LMT".to_string(),
};
tx_order.send(order).expect("Failed to send order");
}
else if ask_price>100.0 {
println!("Place SELL Order");
let order = Order {
symbol: data.symbol,
quantity: 1,
price: ask_price,
order_type: "LMT".to_string(),
};
tx_order.send(order).expect("Failed to send order");
};
}
}
Here we are using two channels one for receiving Quotes and another for sending orders.
fn order_management(rx:mpsc::Receiver<Order>){
while let Ok(data) = rx.recv() {
// Process Orders
println!("Received order: {:?}", data);
}
}
Other considerations
You can use Mutex as well. Ideally, use mutexes to protect shared data and coordinate access to critical sections. You may have multi-step operations that involve multiple threads collaborating to complete a task then Mutexes can be used to coordinate the execution of these operations, ensuring that threads wait for their turn and follow a specific order or synchronization protocol.
Additionally, other synchronization primitives like RwLock, Atomic types, or even higher-level abstractions like message queues or publish-subscribe systems are useful depending on the specific requirements.
Resources
Here is an excellent video by Jon Gjengset to learn more about channels.
And here is another great resource to learn multithreading in Rust, probably the BEST Book on concurrency by Mara Bos. Excellent Read. Thank you, Mara.
There are a few Rust-specific tools like flamegraph
that can help identify bottlenecks and areas for optimization while using multithreading. Flamegraphs are used to visualize where time is being spent.
Hope this is helpful!