refactor: Recorder and the examples.

rust/examples/algo.rs

@@ -3,8 +3,9 @@ use std::{collections::HashMap, fmt::Debug};
 use hftbacktest::prelude::*;
 use tracing::info;
 
-pub fn gridtrading<Q, MD, I: Interface<Q, MD>>(
+pub fn gridtrading<Q, MD, I, R>(
     hbt: &mut I,
+    recorder: &mut R,
     half_spread: f64,
     grid_interval: f64,
     skew: f64,
@@ -13,13 +14,13 @@ pub fn gridtrading<Q, MD, I: Interface<Q, MD>>(
 where
     Q: Sized + Clone,
     MD: MarketDepth,
+    I: Interface<Q, MD>,
     <I as Interface<Q, MD>>::Error: Debug,
+    R: Recorder,
 {
     let grid_num = 20;
     let max_position = grid_num as f64 * order_qty;
-
     let tick_size = hbt.depth(0).tick_size() as f64;
-    let price_prec = get_precision(tick_size as f32);
 
     // Running interval in nanoseconds
     while hbt.elapse(100_000_000).unwrap() {
@@ -31,14 +32,6 @@ where
             continue;
         }
 
-        info!(
-            time = hbt.current_timestamp(),
-            bid = format!("{:.prec$}", depth.best_bid(), prec = price_prec),
-            ask = format!("{:.prec$}", depth.best_ask(), prec = price_prec),
-            position = position,
-            "Run"
-        );
-
         let mid_price = (depth.best_bid() + depth.best_ask()) as f64 / 2.0;
 
         let normalized_position = position / order_qty;

rust/examples/gridtrading_backtest.rs

@@ -10,6 +10,7 @@ use hftbacktest::{
     },
     prelude::{HashMapMarketDepth, Interface},
 };
+use hftbacktest::backtest::recorder::BacktestRecorder;
 
 mod algo;
 
@@ -46,6 +47,7 @@ fn main() {
     let skew = 0.004;
     let order_qty = 1.0;
 
-    gridtrading(&mut hbt, half_spread, grid_interval, skew, order_qty).unwrap();
+    let mut recorder = BacktestRecorder::new(&hbt);
+    gridtrading(&mut hbt, &mut recorder, half_spread, grid_interval, skew, order_qty).unwrap();
     hbt.close().unwrap();
 }

rust/examples/gridtrading_live.rs

@@ -4,6 +4,7 @@ use hftbacktest::{
     live::Bot,
     prelude::{HashMapMarketDepth, Interface},
 };
+use hftbacktest::live::LoggingRecorder;
 
 mod algo;
 
@@ -41,6 +42,7 @@ fn main() {
     let skew = 0.004;
     let order_qty = 1.0;
 
-    gridtrading(&mut hbt, half_spread, grid_interval, skew, order_qty).unwrap();
+    let mut recorder = LoggingRecorder::new();
+    gridtrading(&mut hbt, &mut recorder, half_spread, grid_interval, skew, order_qty).unwrap();
     hbt.close().unwrap();
 }

rust/src/backtest/evs.rs

@@ -1,5 +1,7 @@
-use std::mem;
-use std::mem::{forget, size_of};
+use std::{
+    mem,
+    mem::{forget, size_of},
+};
 
 #[derive(Clone, Copy)]
 #[repr(C, align(32))]
@@ -31,7 +33,8 @@ fn aligned_vec_i64(count: usize) -> Box<[i64]> {
     forget(aligned);
 
     unsafe {
-        Vec::from_raw_parts(ptr as *mut i64, count, cap * size_of::<Align64>() / 8).into_boxed_slice()
+        Vec::from_raw_parts(ptr as *mut i64, count, cap * size_of::<Align64>() / 8)
+            .into_boxed_slice()
     }
 }
 

rust/src/backtest/recorder.rs

@@ -47,11 +47,16 @@ impl Recorder for BacktestRecorder {
 
 impl BacktestRecorder {
     /// Constructs an instance of `BacktestRecorder`.
-    pub fn new(num_assets: usize) -> Self {
+    pub fn new<Q, MD, I>(hbt: &I) -> Self
+    where
+        Q: Sized + Clone,
+        I: Interface<Q, MD>,
+        MD: MarketDepth,
+    {
         Self {
             values: {
-                let mut vec = Vec::new();
-                for _ in 0..num_assets {
+                let mut vec = Vec::with_capacity(hbt.num_assets());
+                for _ in 0..hbt.num_assets() {
                     vec.push(Vec::new());
                 }
                 vec

rust/src/live/bot.rs

@@ -480,7 +480,8 @@ impl Interface<(), HashMapMarketDepth> for Bot<HashMapMarketDepth> {
 
     #[inline]
     fn state_values(&self, asset_no: usize) -> StateValues {
-        // fixme:
+        // todo: implement the missing fields. Trade values need to be changed to a rolling manner,
+        //       unlike the current Python implementation, to support live trading.
         StateValues {
             position: *self.position.get(asset_no).unwrap_or(&0.0),
             balance: 0.0,

rust/src/live/mod.rs

@@ -2,6 +2,7 @@ mod bot;
 mod recorder;
 
 pub use bot::{Bot, BotBuilder, BotError};
+pub use recorder::LoggingRecorder;
 
 /// Provides asset information for internal use.
 #[derive(Clone)]

rust/src/live/recorder.rs

@@ -1,8 +1,4 @@
-use std::{
-    fs::File,
-    io::{Error, Write},
-    path::Path,
-};
+use std::collections::{hash_map::Entry, HashMap};
 
 use tracing::info;
 
@@ -11,12 +7,15 @@ use crate::{
     prelude::Interface,
     types::{Recorder, StateValues},
 };
+use crate::prelude::get_precision;
 
 /// Provides logging of the live strategy's state values.
-pub struct LiveRecorder;
+pub struct LoggingRecorder {
+    state: HashMap<usize, (f32, StateValues)>,
+}
 
-impl Recorder for LiveRecorder {
-    type Error = Error;
+impl Recorder for LoggingRecorder {
+    type Error = ();
 
     fn record<Q, MD, I>(&mut self, hbt: &mut I) -> Result<(), Self::Error>
     where
@@ -26,17 +25,44 @@ impl Recorder for LiveRecorder {
     {
         for asset_no in 0..hbt.num_assets() {
             let depth = hbt.depth(asset_no);
+            let price_prec = get_precision(depth.tick_size());
             let mid = (depth.best_bid() + depth.best_ask()) / 2.0;
             let state_values = hbt.state_values(asset_no);
-            info!(%mid, ?state_values, "State");
+            let updated = match self.state.entry(asset_no) {
+                Entry::Occupied(mut entry) => {
+                    let (prev_mid, prev_state_values) = entry.get();
+                    if (*prev_mid != mid) || (*prev_state_values != state_values) {
+                        *entry.get_mut() = (mid, state_values.clone());
+                        true
+                    } else {
+                        false
+                    }
+                }
+                Entry::Vacant(entry) => {
+                    entry.insert((mid, state_values.clone()));
+                    true
+                }
+            };
+            if updated {
+                info!(
+                    %asset_no,
+                    %mid,
+                    bid = format!("{:.prec$}", depth.best_bid(), prec = price_prec),
+                    ask = format!("{:.prec$}", depth.best_ask(), prec = price_prec),
+                    ?state_values,
+                    "The state of asset number {asset_no} has been updated."
+                );
+            }
         }
         Ok(())
     }
 }
 
-impl LiveRecorder {
-    /// Constructs an instance of `LiveRecorder`.
+impl LoggingRecorder {
+    /// Constructs an instance of `LoggingRecorder`.
     pub fn new() -> Self {
-        Self {}
+        Self {
+            state: Default::default(),
+        }
     }
 }

rust/src/types.rs

@@ -447,7 +447,7 @@ pub struct OrderResponse {
 }
 
 /// Provides state values.
-#[derive(Debug)]
+#[derive(PartialEq, Clone, Debug)]
 pub struct StateValues {
     pub position: f64,
     pub balance: f64,