orderpulse 0.1.0__tar.gz

orderpulse-0.1.0/Cargo.lock

@@ -0,0 +1,190 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "OrderPluse"
+version = "0.1.0"
+dependencies = [
+ "memmap2",
+ "pyo3",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "memmap2"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

orderpulse-0.1.0/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "OrderPluse"
+version = "0.1.0"
+edition = "2021"
+readme = "README.md"
+
+
+
+[lib]
+name = "fastorderbook"
+crate-type = ["cdylib"]
+
+
+
+[dependencies]
+memmap2 = "0.9"
+
+pyo3 = { version = "0.22", features = ["extension-module"] }

orderpulse-0.1.0/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: OrderPulse
+Version: 0.1.0
+Requires-Python: >=3.9

orderpulse-0.1.0/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from myrustlib!")
+
+
+if __name__ == "__main__":
+    main()

orderpulse-0.1.0/pyproject.toml

@@ -0,0 +1,8 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "OrderPulse"
+version = "0.1.0"
+requires-python = ">=3.9"

orderpulse-0.1.0/src/lib.rs

@@ -0,0 +1,147 @@
+use pyo3::prelude::*;
+
+mod structure;
+mod read_trd_ord_only;
+mod tsc;
+
+use read_trd_ord_only::read_messages;
+use structure::Message;
+
+
+
+#[pyfunction]
+fn total_messages(path: String) -> PyResult<usize> {
+
+    let messages = read_messages(&path)
+        .map_err(|e| {
+            pyo3::exceptions::PyRuntimeError::new_err(
+                e.to_string()
+            )
+        })?;
+
+    Ok(messages.len())
+}
+
+
+
+#[pyfunction]
+fn total_trades(path: String) -> PyResult<usize> {
+
+    let messages = read_messages(&path)
+        .map_err(|e| {
+            pyo3::exceptions::PyRuntimeError::new_err(
+                e.to_string()
+            )
+        })?;
+
+    let mut count = 0;
+
+    for msg in messages {
+
+        match msg {
+
+            Message::Trade(_) => {
+                count += 1;
+            }
+
+            _ => {}
+        }
+    }
+
+    Ok(count)
+}
+
+
+
+#[pyfunction]
+fn total_orders(path: String) -> PyResult<usize> {
+
+    let messages = read_messages(&path)
+        .map_err(|e| {
+            pyo3::exceptions::PyRuntimeError::new_err(
+                e.to_string()
+            )
+        })?;
+
+    let mut count = 0;
+
+    for msg in messages {
+
+        match msg {
+
+            Message::Order(_) => {
+                count += 1;
+            }
+
+            _ => {}
+        }
+    }
+
+    Ok(count)
+}
+
+
+
+#[pyfunction]
+fn summary(path: String) -> PyResult<(usize, usize, usize)> {
+
+    let messages = read_messages(&path)
+        .map_err(|e| {
+            pyo3::exceptions::PyRuntimeError::new_err(
+                e.to_string()
+            )
+        })?;
+
+    let total_messages = messages.len();
+
+    let mut total_trades = 0;
+    let mut total_orders = 0;
+
+    for msg in messages {
+
+        match msg {
+
+            Message::Trade(_) => {
+                total_trades += 1;
+            }
+
+            Message::Order(_) => {
+                total_orders += 1;
+            }
+
+        }
+    }
+
+    Ok((
+        total_messages,
+        total_trades,
+        total_orders
+    ))
+}
+
+
+
+#[pymodule]
+fn fastorderbook(
+    _py: Python,
+    m: &Bound<PyModule>
+) -> PyResult<()> {
+
+    m.add_function(
+        wrap_pyfunction!(total_messages, m)?
+    )?;
+
+    m.add_function(
+        wrap_pyfunction!(total_trades, m)?
+    )?;
+
+    m.add_function(
+        wrap_pyfunction!(total_orders, m)?
+    )?;
+
+    m.add_function(
+        wrap_pyfunction!(summary, m)?
+    )?;
+
+    Ok(())
+}

orderpulse-0.1.0/src/main.rs

@@ -0,0 +1,240 @@
+use std::collections::HashSet;
+use std::io::{Error, ErrorKind};
+use std::io::Result;
+use std::mem::size_of;
+use std::path::Path;
+use std::time::Instant;
+
+mod structure;
+mod read_trd_ord_only;
+mod orderbook;
+
+use crate::orderbook::OrderBookManager;
+use crate::read_trd_ord_only::read_messages;
+use crate::structure::{Message, OrderPacket, TradePacket};
+use orderbook_processing::{clobber, cycle_end, cycle_start, Harness};
+
+fn main() -> Result<()> {
+    let _trade_size = size_of::<TradePacket>();
+    let _order_size = size_of::<OrderPacket>();
+
+    let args: Vec<String> = std::env::args().collect();
+    const DEFAULT_PATH: &str = "/nas/50.30/NSE_CM/Feed_CM_StreamID_2_10_10_2026.bin";
+    let path = if args.len() > 1 {
+        &args[1]
+    } else {
+        DEFAULT_PATH
+    };
+
+    if !Path::new(path).exists() {
+        return Err(Error::new(
+            ErrorKind::NotFound,
+            format!(
+                "Input file not found: {}. Pass a valid file path as arg1. Default path: {}",
+                path, DEFAULT_PATH
+            ),
+        ));
+    }
+
+    let filter_token: Option<u32> = if args.len() > 2 {
+        Some(args[2].parse().map_err(|e| {
+            Error::new(
+                ErrorKind::InvalidInput,
+                format!("Invalid token '{}': {}", args[2], e),
+            )
+        })?)
+    } else {
+        None
+    };
+
+    let max_messages: Option<usize> = if args.len() > 3 {
+        Some(args[3].parse().map_err(|e| {
+            Error::new(
+                ErrorKind::InvalidInput,
+                format!("Invalid max_messages '{}': {}", args[3], e),
+            )
+        })?)
+    } else {
+        None
+    };
+
+    let skip_bench = std::env::var("LOB_SKIP_BENCH")
+        .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
+        .unwrap_or(false);
+
+    eprintln!("processing file: {}", path);
+    if let Some(token) = filter_token {
+        eprintln!("Filtering for token: {}", token);
+    }
+    if let Some(limit) = max_messages {
+        eprintln!("Max messages to process: {}", limit);
+    }
+    if skip_bench {
+        eprintln!("Benchmark phase disabled via LOB_SKIP_BENCH");
+    }
+
+    eprintln!("\nread_messages");
+    let timer1 = Instant::now();
+    let messages = read_messages(path)?;
+    let read_time = timer1.elapsed();
+    eprintln!("Duration: {:.2?}", read_time);
+
+    // Collect token statistics for diagnostics
+    let mut order_tokens: HashSet<u32> = HashSet::new();
+    let mut trade_tokens: HashSet<i32> = HashSet::new();
+    for msg in &messages {
+        match msg {
+            Message::Order(order) => { order_tokens.insert(order.ord.token); }
+            Message::Trade(trade) => { trade_tokens.insert(trade.trd.token); }
+        }
+    }
+
+    eprintln!("\nfilter_messages");
+    let timer2 = Instant::now();
+    let mut filtered_messages: Vec<Message> = if let Some(filter) = filter_token {
+        let mut out = Vec::with_capacity(messages.len() / 4);
+        for msg in messages {
+            match &msg {
+                Message::Order(order) => {
+                    if order.ord.token == filter {
+                        out.push(msg);
+                    }
+                }
+                Message::Trade(trade) => {
+                    if trade.trd.token as u32 == filter {
+                        out.push(msg);
+                    }
+                }
+            }
+        }
+        out
+    } else {
+        messages
+    };
+    let filter_time = timer2.elapsed();
+
+    if let Some(limit) = max_messages {
+        if filtered_messages.len() > limit {
+            filtered_messages.truncate(limit);
+        }
+    }
+
+    eprintln!("Duration: {:.2?}", filter_time);
+    eprintln!("Total filtered messages: {}", filtered_messages.len());
+
+    if filtered_messages.is_empty() {
+        eprintln!("No filtered messages to process. Exiting.");
+        return Ok(());
+    }
+
+    eprintln!("\ninitialize_manager");
+    let timer3 = Instant::now();
+    let mut manager = OrderBookManager::new();
+    let init_time = timer3.elapsed();
+    eprintln!("initialize_manager duration: {:.2?}", init_time);
+
+    println!(
+        "local_ts,exch_ts,mid_price,\
+bid_price_0,bid_qty_0,ask_price_0,ask_qty_0,\
+bid_price_1,bid_qty_1,ask_price_1,ask_qty_1,\
+bid_price_2,bid_qty_2,ask_price_2,ask_qty_2,\
+bid_price_3,bid_qty_3,ask_price_3,ask_qty_3,\
+bid_price_4,bid_qty_4,ask_price_4,ask_qty_4"
+    );
+
+    eprintln!("\nprocess_all_messages");
+    let timer4 = Instant::now();
+
+    let mut message_count: u64 = 0;
+    let mut order_count: u64 = 0;
+    let mut trade_count: u64 = 0;
+
+    for message in &filtered_messages {
+        message_count += 1;
+        match message {
+            Message::Order(order) => {
+                order_count += 1;
+                manager.process_order_message(order);
+
+                let token = order.ord.token;
+                if let Some((mid_price, mut bids, mut asks)) = manager.get_top_levels(token, 5) {
+                    while bids.len() < 5 { bids.push((0,0)); }
+                    while asks.len() < 5 { asks.push((0,0)); }
+                    // Copy packed struct fields into aligned local variables
+                    let local_ts = order.local_ts;
+                    let exch_ts = order.ord.exch_ts;
+                    println!(
+                        "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}, {}",
+                        local_ts,
+                        exch_ts,
+                        mid_price,
+                        bids[0].0, bids[0].1, asks[0].0, asks[0].1,
+                        bids[1].0, bids[1].1, asks[1].0, asks[1].1,
+                        bids[2].0, bids[2].1, asks[2].0, asks[2].1,
+                        bids[3].0, bids[3].1, asks[3].0, asks[3].1,
+                        bids[4].0, bids[4].1, asks[4].0, asks[4].1
+                    );
+                }
+            }
+            Message::Trade(trade) => {
+                trade_count += 1;
+                manager.process_trade_message(trade);
+
+                let token = trade.trd.token as u32;
+                if let Some((mid_price, mut bids, mut asks)) = manager.get_top_levels(token, 5) {
+                    while bids.len() < 5 { bids.push((0,0)); }
+                    while asks.len() < 5 { asks.push((0,0)); }
+                    // Copy packed struct fields into aligned local variables
+                    let local_ts = trade.local_ts;
+                    let exch_ts = trade.trd.exch_ts;
+                   println!(
+                         "{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{}",
+    local_ts, exch_ts, mid_price,
+    bids[0].0, bids[0].1, asks[0].0, asks[0].1,
+    bids[1].0, bids[1].1, asks[1].0, asks[1].1,
+    bids[2].0, bids[2].1, asks[2].0, asks[2].1,
+    bids[3].0, bids[3].1, asks[3].0, asks[3].1,
+    bids[4].0, bids[4].1, asks[4].0, asks[4].1
+);
+                }
+            }
+        }
+    }
+
+    let process_time = timer4.elapsed();
+    eprintln!("Duration: {:.2?}", process_time);
+    eprintln!(
+        "Processed messages: total={}, orders={}, trades={}",
+        message_count, order_count, trade_count
+    );
+
+    if skip_bench {
+        return Ok(());
+    }
+
+    let mut harness = Harness::new();
+    let filtered_messages_clone = filtered_messages.clone();
+    harness.add_benchmark(
+        "BM_RustOrderBook",
+        filtered_messages_clone.len() as u64,
+        move |iterations| -> u64 {
+            let mut total_cycles: u64 = 0;
+            for _ in 0..iterations {
+                let mut book = OrderBookManager::new();
+                let start = cycle_start();
+                clobber();
+                filtered_messages_clone.iter().for_each(|message| {
+                    match message {
+                        Message::Order(order) => { book.process_order_message(order); }
+                        Message::Trade(trade) => { book.process_trade_message(trade); }
+                    }
+                });
+                let end = cycle_end();
+                total_cycles = total_cycles.saturating_add(end.saturating_sub(start));
+            }
+            total_cycles
+        },
+        21,
+    );
+    std::process::exit(harness.run());
+}

orderpulse-0.1.0/src/orderbook.rs

@@ -0,0 +1,356 @@
+use rustc_hash::FxHashMap;
+use crate::structure::{OrderPacket, TradePacket};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Side {
+    Buy,
+    Sell,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct Order {
+    side: Side,
+    price: u32,
+    qty: u32,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct PriceLevel {
+    pub price: u32,
+    pub total_qty: u64,
+}
+
+const DEFAULT_PRICE_TICK_SIZE: u32 = 1;
+const INITIAL_DPR_WINDOW_WIDTH: u32 = 20_000;
+
+#[derive(Debug)]
+pub(crate) struct OrderBook {
+    orders: FxHashMap<u64, Order>,
+    tick_size: u32,
+    dpr_min: u32,
+    dpr_max: u32,
+    bid_levels: Vec<u64>,
+    ask_levels: Vec<u64>,
+}
+
+impl OrderBook {
+    #[inline]
+    fn new(first_seen_price: u32) -> Self {
+        let mut orders = FxHashMap::default();
+        orders.reserve(100_000);
+
+        let tick_size = DEFAULT_PRICE_TICK_SIZE;
+        let initial_half_window = INITIAL_DPR_WINDOW_WIDTH / 2;
+
+        let mut dpr_min = first_seen_price.saturating_sub(initial_half_window);
+        let mut dpr_max = first_seen_price.saturating_add(initial_half_window);
+
+        dpr_min = (dpr_min / tick_size) * tick_size;
+        dpr_max = if dpr_max % tick_size == 0 {
+            dpr_max
+        } else {
+            ((dpr_max / tick_size) + 1) * tick_size
+        };
+
+        if dpr_max < dpr_min {
+            dpr_max = dpr_min;
+        }
+
+        let levels = ((dpr_max - dpr_min) / tick_size + 1) as usize;
+        Self {
+            orders,
+            tick_size,
+            dpr_min,
+            dpr_max,
+            bid_levels: vec![0u64; levels],
+            ask_levels: vec![0u64; levels],
+        }
+    }
+
+    #[inline(always)]
+    fn in_range(&self, price: u32) -> bool {
+        price >= self.dpr_min && price <= self.dpr_max
+    }
+
+    #[inline(always)]
+    fn idx(&self, price: u32) -> usize {
+        ((price - self.dpr_min) / self.tick_size) as usize
+    }
+
+    #[inline(always)]
+    fn align_down_to_tick(&self, p: u32) -> u32 {
+        (p / self.tick_size) * self.tick_size
+    }
+
+    #[inline(always)]
+    fn round_up_to_10(p: u32) -> u32 {
+        if p % 10 == 0 {
+            p
+        } else {
+            p + (10 - (p % 10))
+        }
+    }
+
+    fn load_new_dpr_settings(&mut self, price: u32) {
+        let old_min = self.dpr_min;
+        let mut new_min = self.dpr_min;
+        let mut new_max = self.dpr_max;
+
+        if price >= new_max {
+            new_max = price.saturating_add(price / 4);
+            new_max = Self::round_up_to_10(new_max);
+            new_max = self.align_down_to_tick(new_max);
+        } else if price < new_min {
+            new_min = price.saturating_sub(price / 4);
+            let diff = old_min.saturating_sub(new_min);
+            new_min = new_min.saturating_sub(diff % 10);
+            new_min = self.align_down_to_tick(new_min);
+            if new_min == 0 {
+                new_min = self.tick_size;
+            }
+        } else {
+            return;
+        }
+
+        if new_max < new_min {
+            new_max = new_min;
+        }
+
+        let new_levels = ((new_max - new_min) / self.tick_size + 1) as usize;
+        let mut new_bid = vec![0u64; new_levels];
+        let mut new_ask = vec![0u64; new_levels];
+
+        for old_i in 0..self.bid_levels.len() {
+            let abs_price = old_min + (old_i as u32 * self.tick_size);
+            if abs_price < new_min || abs_price > new_max {
+                continue;
+            }
+            let new_i = ((abs_price - new_min) / self.tick_size) as usize;
+            new_bid[new_i] = self.bid_levels[old_i];
+            new_ask[new_i] = self.ask_levels[old_i];
+        }
+
+        self.dpr_min = new_min;
+        self.dpr_max = new_max;
+        self.bid_levels = new_bid;
+        self.ask_levels = new_ask;
+    }
+
+    #[inline(always)]
+    fn ensure_price(&mut self, price: u32) {
+        if !self.in_range(price) {
+            self.load_new_dpr_settings(price);
+        }
+    }
+
+    #[inline(always)]
+    fn add_order(&mut self, order_id: u64, side: Side, price: u32, qty: u32) {
+        if qty == 0 {
+            return;
+        }
+        self.ensure_price(price);
+        if !self.in_range(price) {
+            return;
+        }
+        let i = self.idx(price);
+        self.orders.insert(order_id, Order { side, price, qty });
+
+        unsafe {
+            match side {
+                Side::Buy => *self.bid_levels.get_unchecked_mut(i) += qty as u64,
+                Side::Sell => *self.ask_levels.get_unchecked_mut(i) += qty as u64,
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn reduce_order(&mut self, order_id: u64, qty: u32) {
+        let (side, price, traded, remaining_qty) = {
+            let order = match self.orders.get_mut(&order_id) {
+                Some(o) => o,
+                None => return,
+            };
+            let traded = qty.min(order.qty);
+            order.qty -= traded;
+            (order.side, order.price, traded, order.qty)
+        };
+        if traded > 0 && self.in_range(price) {
+            let i = self.idx(price);
+            unsafe {
+                match side {
+                    Side::Buy => *self.bid_levels.get_unchecked_mut(i) -= traded as u64,
+                    Side::Sell => *self.ask_levels.get_unchecked_mut(i) -= traded as u64,
+                }
+            }
+        }
+        if remaining_qty == 0 {
+            self.orders.remove(&order_id);
+        }
+    }
+
+    #[inline(always)]
+    fn cancel_order(&mut self, order_id: u64) {
+        let order = match self.orders.remove(&order_id) {
+            Some(o) => o,
+            None => return,
+        };
+        if self.in_range(order.price) {
+            let i = self.idx(order.price);
+            unsafe {
+                match order.side {
+                    Side::Buy => *self.bid_levels.get_unchecked_mut(i) -= order.qty as u64,
+                    Side::Sell => *self.ask_levels.get_unchecked_mut(i) -= order.qty as u64,
+                }
+            }
+        }
+    }
+
+    #[inline(always)]
+    fn modify_order(&mut self, order_id: u64, side: Side, new_price: u32, new_qty: u32) {
+        self.cancel_order(order_id);
+        self.add_order(order_id, side, new_price, new_qty);
+    }
+
+    #[inline(always)]
+    pub(crate) fn bid_levels(&self) -> &[u64] {
+        &self.bid_levels
+    }
+
+    #[inline(always)]
+    pub(crate) fn ask_levels(&self) -> &[u64] {
+        &self.ask_levels
+    }
+}
+
+pub struct OrderBookManager {
+    books: FxHashMap<u32, OrderBook>,
+}
+
+impl OrderBookManager {
+    pub fn reset(&mut self) {
+        self.books.clear();
+    }
+
+    #[inline]
+    pub fn new() -> Self {
+        let mut books = FxHashMap::default();
+        books.reserve(20_000);
+        Self { books }
+    }
+
+    #[inline(always)]
+    fn book_mut(&mut self, token: u32, first_seen_price: u32) -> &mut OrderBook {
+        self.books
+            .entry(token)
+            .or_insert_with(|| OrderBook::new(first_seen_price))
+    }
+
+    #[inline(always)]
+    pub fn add_order(&mut self, token: u32, order_id: u64, side: Side, price: u32, qty: u32) {
+         self.book_mut(token, price).add_order(order_id, side, price, qty);
+    }
+
+    #[inline(always)]
+    pub fn reduce_order(&mut self, token: u32, order_id: u64, qty: u32) {
+        if let Some(book) = self.books.get_mut(&token) {
+            book.reduce_order(order_id, qty);
+        }
+    }
+
+    #[inline(always)]
+    pub fn cancel_order(&mut self, token: u32, order_id: u64) {
+        if let Some(book) = self.books.get_mut(&token) {
+            book.cancel_order(order_id);
+        }
+    }
+
+    #[inline(always)]
+    pub fn modify_order(
+        &mut self,
+        token: u32,
+        order_id: u64,
+        new_price: u32,
+        new_qty: u32,
+        side: Side,
+    ) {
+        self.book_mut(token, new_price)
+            .modify_order(order_id, side, new_price, new_qty);
+    }
+
+    #[inline(always)]
+    pub(crate) fn get_book(&self, token: u32) -> Option<&OrderBook> {
+        self.books.get(&token)
+    }
+
+    #[inline(always)]
+    pub fn process_order_message(&mut self, order: &OrderPacket) {
+        let token = order.ord.token;
+        let order_id = order.ord.order_id;
+        let price = order.ord.price;
+        let qty = order.ord.quantity;
+        let order_type = order.ord.order_type;
+        let msg_type = order.ord.msg_type;
+
+        let side = if order_type == b'B' {
+            Side::Buy
+        } else {
+            Side::Sell
+        };
+
+        match msg_type {
+            b'N' => self.add_order(token, order_id, side, price, qty),
+            b'M' => self.modify_order(token, order_id, price, qty, side),
+            b'X' => self.cancel_order(token, order_id),
+            _ => {}
+        }
+    }
+
+    #[inline(always)]
+    pub fn process_trade_message(&mut self, trade: &TradePacket) {
+        let token = trade.trd.token as u32;
+        let buy_order_id = trade.trd.buy_order_id;
+        let sell_order_id = trade.trd.sell_order_id;
+        let qty = trade.trd.trade_quantity.max(0) as u32;
+
+        self.reduce_order(token, buy_order_id, qty);
+        self.reduce_order(token, sell_order_id, qty);
+    }
+
+    /// Return `mid_price`, `Vec` of top N bid levels, `Vec` of top N ask levels, for a given token.
+    /// Each `Vec` element is `(price, qty)`, ordered best-to-worst.
+    pub fn get_top_levels(
+        &self,
+        token: u32,
+        levels: usize,
+    ) -> Option<(u32, Vec<(u32, u64)>, Vec<(u32, u64)>)> {
+        let book = self.books.get(&token)?;
+        let mut bids = Vec::new();
+        let mut asks = Vec::new();
+        // Bids: iterate highest to lowest price (right to left)
+        for (i, &qty) in book.bid_levels.iter().enumerate().rev() {
+            if qty > 0 {
+                let price = book.dpr_min + (i as u32) * book.tick_size;
+                bids.push((price, qty));
+            }
+            if bids.len() >= levels {
+                break;
+            }
+        }
+        // Asks: iterate lowest to highest price (left to right)
+        for (i, &qty) in book.ask_levels.iter().enumerate() {
+            if qty > 0 {
+                let price = book.dpr_min + (i as u32) * book.tick_size;
+                asks.push((price, qty));
+            }
+            if asks.len() >= levels {
+                break;
+            }
+        }
+        let mid_price = if let (Some((b, _)), Some((a, _))) = (bids.first(), asks.first()) {
+            (b + a) / 2
+        } else {
+            0
+        };
+        Some((mid_price, bids, asks))
+    }
+}

orderpulse-0.1.0/src/read_trd_ord_only.rs

@@ -0,0 +1,90 @@
+use std::fs::File;
+use std::io::Result;
+use std::mem::size_of;
+
+use memmap2::Mmap;
+
+use crate::structure::{Message, OrderPacket, PeekStructure, TradePacket};
+
+#[inline]
+pub fn read_messages(path: &str) -> Result<Vec<Message>> {
+    let file = File::open(path)?;
+    let mmap = unsafe { Mmap::map(&file)? };
+    let buf = &mmap[..];
+
+    // Heuristic capacity to reduce reallocs.
+    let estimated_msg_count = buf.len() / size_of::<OrderPacket>();
+    let mut messages = Vec::with_capacity(estimated_msg_count);
+
+    let mut i: usize = 0;
+    while i < buf.len() {
+        // skip spaces
+        while i < buf.len() && buf[i] == b' ' {
+            i += 1;
+        }
+
+        if i + size_of::<PeekStructure>() > buf.len() {
+            break;
+        }
+
+        let peek_buf = &buf[i..i + size_of::<PeekStructure>()];
+        let peek_struct: PeekStructure =
+            unsafe { std::ptr::read_unaligned(peek_buf.as_ptr() as *const _) };
+
+        match peek_struct.msg_type {
+            b'T' => {
+                if i + size_of::<TradePacket>() > buf.len() {
+                    break;
+                }
+
+                let trade_buf = &buf[i..i + size_of::<TradePacket>()];
+                let mut trade_packet: TradePacket =
+                    unsafe { std::ptr::read_unaligned(trade_buf.as_ptr() as *const _) };
+
+                // endian fixups
+                trade_packet.hdr.msg_len = u16::from_le(trade_packet.hdr.msg_len);
+                trade_packet.hdr.stream_id = u16::from_le(trade_packet.hdr.stream_id);
+                trade_packet.hdr.seq_no = u32::from_le(trade_packet.hdr.seq_no);
+
+                trade_packet.trd.exch_ts = u64::from_le(trade_packet.trd.exch_ts);
+                trade_packet.trd.buy_order_id = u64::from_le(trade_packet.trd.buy_order_id);
+                trade_packet.trd.sell_order_id = u64::from_le(trade_packet.trd.sell_order_id);
+                trade_packet.trd.token = i32::from_le(trade_packet.trd.token);
+                trade_packet.trd.trade_price = i32::from_le(trade_packet.trd.trade_price);
+                trade_packet.trd.trade_quantity = i32::from_le(trade_packet.trd.trade_quantity);
+
+                messages.push(Message::Trade(trade_packet));
+                i += size_of::<TradePacket>();
+            }
+            b'N' | b'M' | b'X' => {
+                if i + size_of::<OrderPacket>() > buf.len() {
+                    break;
+                }
+
+                let order_buf = &buf[i..i + size_of::<OrderPacket>()];
+                let mut order_packet: OrderPacket =
+                    unsafe { std::ptr::read_unaligned(order_buf.as_ptr() as *const _) };
+
+                // endian fixups
+                order_packet.hdr.msg_len = u16::from_le(order_packet.hdr.msg_len);
+                order_packet.hdr.stream_id = u16::from_le(order_packet.hdr.stream_id);
+                order_packet.hdr.seq_no = u32::from_le(order_packet.hdr.seq_no);
+
+                order_packet.ord.exch_ts = u64::from_le(order_packet.ord.exch_ts);
+                order_packet.ord.order_id = u64::from_le(order_packet.ord.order_id);
+                order_packet.ord.token = u32::from_le(order_packet.ord.token);
+                order_packet.ord.price = u32::from_le(order_packet.ord.price);
+                order_packet.ord.quantity = u32::from_le(order_packet.ord.quantity);
+
+                messages.push(Message::Order(order_packet));
+                i += size_of::<OrderPacket>();
+            }
+            _ => {
+                // resync
+                i += 1;
+            }
+        }
+    }
+
+    Ok(messages)
+}

orderpulse-0.1.0/src/structure.rs

@@ -0,0 +1,62 @@
+#[repr(C, packed)]
+#[derive(Clone, Copy, Debug)]
+pub struct StreamHeader {
+    pub msg_len: u16,
+    pub stream_id: u16,
+    pub seq_no: u32,
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, Debug)]
+pub struct PeekStructure {
+    pub global_header: StreamHeader,
+    pub msg_type: u8,
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, Debug)]
+pub struct OrderMessage {
+    pub msg_type: u8,
+    pub exch_ts: u64,
+    pub order_id: u64,
+    pub token: u32,
+    pub order_type: u8,
+    pub price: u32,
+    pub quantity: u32,
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, Debug)]
+pub struct TradeMessage {
+    pub msg_type: u8,
+    pub exch_ts: u64,
+    pub buy_order_id: u64,
+    pub sell_order_id: u64,
+    pub token: i32,
+    pub trade_price: i32,
+    pub trade_quantity: i32,
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, Debug)]
+pub struct OrderPacket {
+    pub hdr: StreamHeader,
+    pub ord: OrderMessage,
+    pub local_ts: u64,
+    pub flags: bool,
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, Debug)]
+pub struct TradePacket {
+    pub hdr: StreamHeader,
+    pub trd: TradeMessage,
+    pub local_ts: u64,
+    pub flags: bool, 
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum Message {
+    Order(OrderPacket),
+    Trade(TradePacket),
+}

orderpulse-0.1.0/src/tsc.rs

@@ -0,0 +1,47 @@
+#[cfg(target_arch = "x86_64")]
+use core::arch::x86_64::{__cpuid, __rdtscp, _rdtsc};
+
+#[cfg(target_arch = "x86_64")]
+#[inline]
+pub fn cycle_start() -> u64 {
+    unsafe {
+        __cpuid(0);
+        _rdtsc() as u64
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+#[inline]
+pub fn cycle_end() -> u64 {
+    unsafe {
+        let mut _aux: u32 = 0;
+        let tsc = __rdtscp(&mut _aux);
+        __cpuid(0);
+        tsc
+    }
+}
+
+#[cfg(target_arch = "aarch64")]
+#[inline]
+pub fn cycle_start() -> u64 {
+    let val: u64;
+    unsafe {
+        core::arch::asm!("mrs {}, cntvct_el0", out(reg) val);
+    }
+    val
+}
+#[cfg(target_arch = "aarch64")]
+#[inline]
+pub fn cycle_end() -> u64 { cycle_start() }
+
+#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+#[inline]
+pub fn cycle_start() -> u64 {
+    use std::time::Instant;
+    static START: std::sync::OnceLock<Instant> = std::sync::OnceLock::new();
+    let start = START.get_or_init(Instant::now);
+    start.elapsed().as_nanos() as u64
+}
+#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+#[inline]
+pub fn cycle_end() -> u64 { cycle_start() }

orderpulse-0.1.0/uv.lock

@@ -0,0 +1,39 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "maturin"
+version = "1.13.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/39/16/b284a7bc4af3dd87717c784278c1b8cb18606ad1f6f7a671c47bfd9c3df0/maturin-1.13.1.tar.gz", hash = "sha256:9a87ff3b8e4d1c6eac33ebfe8e261e8236516d98d45c0323550621819b5a1a2f", size = 340369, upload-time = "2026-04-09T15:14:07.026Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/4d/a23fc95be881aa8c7a6ea353410417872e4d7065df03d7f3db8f0dbed4a7/maturin-1.13.1-py3-none-linux_armv6l.whl", hash = "sha256:416e4e01cb88b798e606ee43929df897e42c1647b722ef68283816cca99a8742", size = 10102444, upload-time = "2026-04-09T15:13:48.393Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/1e/65c385d65bae95cf04895d52f39dbed8b1453ae55da2903d252ade40a774/maturin-1.13.1-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:72888e87819ce546d0d2df900e4b385e4ef299077d92ee37b48923a5602dae94", size = 19576043, upload-time = "2026-04-09T15:14:08.685Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/13/f6bc868d0bfecd9314870b97f530a167e31f7878ac4945c78245c6eef69c/maturin-1.13.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:98b5fcf1a186c217830a8295ecc2989c6b1cf50945417adfc15252107b9475b7", size = 10117339, upload-time = "2026-04-09T15:13:40.559Z" },
+    { url = "https://files.pythonhosted.org/packages/51/58/279e081305c11c1c1c4fccacf77df8959646c5d4de7a57ec7e787653e270/maturin-1.13.1-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:3da18cccf2f683c0977bff9146a0908d6ffce836d600665736ac01679f588cb9", size = 10139689, upload-time = "2026-04-09T15:13:38.291Z" },
+    { url = "https://files.pythonhosted.org/packages/00/94/69391af5396c6aab723932240803f49e5f3de3dd7c57d32f02d237a0ce32/maturin-1.13.1-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:6b1e5916a253243e8f5f9e847b62bbc98420eec48c9ce2e2e8724c6da89d359b", size = 10551141, upload-time = "2026-04-09T15:13:42.887Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/bf/4edac2667b49e3733438062ae416413b8fc8d42e1bd499ba15e1fb02fc55/maturin-1.13.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:dc91031e0619c1e28730279ef9ee5f106c9b9ec806b013f888676b242f892eb7", size = 9983094, upload-time = "2026-04-09T15:13:56.868Z" },
+    { url = "https://files.pythonhosted.org/packages/79/94/a6d651cfe8fc6bf2e892c90e3cdbb25c06d81c9115140d03ea1a68a97575/maturin-1.13.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:001741c6cff56aa8ea59a0d78ae990c0550d0e3e82b00b683eedb4158a8ef7e6", size = 9949980, upload-time = "2026-04-09T15:13:59.185Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d1/82c067464f848e38af9910bce55eb54302b1c1284a279d515dbfcf5994f5/maturin-1.13.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:01c845825c917c07c1d0b2c9032c59c16a7d383d1e649a46481d3e5693c2750f", size = 13186276, upload-time = "2026-04-09T15:13:45.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f4/25367baf1025580f047f9b37598bb3fadc416e24536afd4f28e190335c73/maturin-1.13.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f69093ed4a0e6464e52a7fc26d714f859ce15630ec8070743398c6bf41f38a9e", size = 10891837, upload-time = "2026-04-09T15:13:35.68Z" },
+    { url = "https://files.pythonhosted.org/packages/af/be/caafad8ce74974b7deafdf144d12f758993dfea4c66c9905b138f51a7792/maturin-1.13.1-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:c1490584f3c70af45466ee99065b49e6657ebdccac6b10571bb44681309c9396", size = 10351032, upload-time = "2026-04-09T15:14:01.632Z" },
+    { url = "https://files.pythonhosted.org/packages/66/0e/970a721d27cfa410e8bfa0a1e32e6ef52cb8169692110a5fdabe1af3f570/maturin-1.13.1-py3-none-win32.whl", hash = "sha256:c6a720b252c99de072922dbe4432ab19662b6f80045b0355fec23bdfccb450da", size = 8855465, upload-time = "2026-04-09T15:13:51.122Z" },
+    { url = "https://files.pythonhosted.org/packages/88/70/7c1e0d65fa147d5479055a171541c82b8cdfc1c825d85a82240470f14176/maturin-1.13.1-py3-none-win_amd64.whl", hash = "sha256:a2017d2281203d0c6570240e7d746564d766d756105823b7de68bda6ae722711", size = 10230471, upload-time = "2026-04-09T15:13:53.89Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/2a/afe0193b673a79ffd2e01ad999511b7e9e6b49af02bb3759d82a78c3043d/maturin-1.13.1-py3-none-win_arm64.whl", hash = "sha256:2839024dcd65776abb4759e5bca29941971e095574162a4d335191da4be9ff24", size = 8905575, upload-time = "2026-04-09T15:14:03.891Z" },
+]
+
+[[package]]
+name = "myrustlib"
+version = "0.1.0"
+source = { virtual = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "maturin" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [{ name = "maturin", specifier = ">=1.13.1" }]