耗时统计功能

global/src/delay_time.rs

@@ -0,0 +1,13 @@
+#[derive(Debug)]
+pub struct DelayTime {
+    pub network: i64,
+
+    pub format_start: i64,
+    pub format_end: i64,
+
+    pub quant_start: i64,
+    pub quant_end: i64,
+
+    pub strategy_start: i64,
+    pub strategy_end: i64
+}

global/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod public_params;
 pub mod log_utils;
 pub mod params;
+pub mod delay_time;

src/quant_libs.rs

@@ -8,6 +8,7 @@ use std::sync::atomic::{AtomicBool};
 use std::time::Duration;
 use tokio::sync::{mpsc, Mutex};
 use tracing::{error, info};
+use global::delay_time::DelayTime;
 use global::params::Params;
 use standard::Order;
 use strategy::model::OrderInfo;
@@ -23,16 +24,27 @@ pub async fn init(params: Params, ws_running: Arc<AtomicBool>, running: Arc<Atom
     let (error_sender, mut error_receiver) = mpsc::channel::<Error>(100);
 
     let mut quant_obj = Quant::new(params.exchange.clone(), params.clone(), exchange_params.clone(), order_sender.clone(), error_sender.clone(), running.clone()).await;
+    let delay_time = DelayTime{
+        network: 0,
+        format_start: 0,
+        format_end: 0,
+        quant_start: 0,
+        quant_end: 0,
+        strategy_start: 0,
+        strategy_end: 0,
+    };
     let ref_name = quant_obj.ref_name[0].clone();
     let trade_name = quant_obj.trade_name.clone();
 
     info!("quant初始化……");
     quant_obj.before_trade().await;
     let quant_arc = Arc::new(Mutex::new(quant_obj));
+    let delay_time_lock: Arc<Mutex<DelayTime>> = Arc::new(Mutex::new(delay_time));
+
     // 参考交易所
-    exchange_disguise::run_reference_exchange(ws_running.clone(),params.ref_exchange.get(0).unwrap().clone(), quant_arc.clone(), ref_name, params.ref_pair.clone(), exchange_params.clone()).await;
+    exchange_disguise::run_reference_exchange(ws_running.clone(),params.ref_exchange.get(0).unwrap().clone(), quant_arc.clone(), ref_name, params.ref_pair.clone(), exchange_params.clone(), delay_time_lock.clone()).await;
     // 交易交易所
-    exchange_disguise::run_transactional_exchange(ws_running.clone(), params.exchange, quant_arc.clone(),  trade_name, vec![params.pair.clone()], exchange_params.clone()).await;
+    exchange_disguise::run_transactional_exchange(ws_running.clone(), params.exchange, quant_arc.clone(),  trade_name, vec![params.pair.clone()], exchange_params.clone(), delay_time_lock.clone()).await;
     // 启动定期触发的系统逻辑
     quant::on_timer(quant_arc.clone());
     // 启动策略逻辑
@@ -48,7 +60,7 @@ pub async fn init(params: Params, ws_running: Arc<AtomicBool>, running: Arc<Atom
                 Some(order) => {
                     if order.status != "NULL" {
                         let mut quant = order_handler_quant_arc.lock().await;
-
+                        let mut delay_time_lock_instance = delay_time_lock.lock().await;
                         let order_info = OrderInfo {
                             symbol: "".to_string(),
                             amount: order.amount.abs(),
@@ -64,7 +76,7 @@ pub async fn init(params: Params, ws_running: Arc<AtomicBool>, running: Arc<Atom
                             fee: Default::default(),
                         };
 
-                        quant.update_local_order(order_info.clone());
+                        quant.update_local_order(order_info.clone(), &mut delay_time_lock_instance);
                     }
                 },
                 None => {

strategy/src/exchange_disguise.rs

@@ -3,6 +3,7 @@ use std::str::FromStr;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::time::Duration;
+use chrono::{Utc};
 use rust_decimal::Decimal;
 use serde_json::Value;
 use tokio::spawn;
@@ -15,19 +16,20 @@ use exchanges::binance_swap_ws::{BinanceSubscribeType, BinanceSwapWs, BinanceWsT
 use exchanges::gate_swap_rest::GateSwapRest;
 use exchanges::gate_swap_ws::{GateSubscribeType, GateSwapWs, GateWsType};
 use exchanges::kucoin_swap_ws::{KucoinSubscribeType, KucoinSwapWs, KucoinWsType};
+use global::delay_time::DelayTime;
 use standard::exchange::ExchangeEnum::{BinanceSpot, BinanceSwap, GateSwap, KucoinSwap};
 use standard::SpecialTicker;
 use crate::model::{OrderInfo, OriginalTicker, OriginalTradeBa, OriginalTradeGa};
 use crate::quant::Quant;
 
 // 交易交易所启动
-pub async fn run_transactional_exchange(bool_v1 :Arc<AtomicBool>, exchange_name: String, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
+pub async fn run_transactional_exchange(bool_v1 :Arc<AtomicBool>, exchange_name: String, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>, time_record: Arc<Mutex<DelayTime>>){
     match exchange_name.as_str() {
         "gate_usdt_swap" => {
-            gate_swap_run(bool_v1, 1i8, quant_arc, name, symbols, exchange_params).await;
+            gate_swap_run(bool_v1, time_record, 1i8, quant_arc, name, symbols, exchange_params).await;
         }
         "kucoin_usdt_swap" => {
-            kucoin_swap_run(bool_v1, 1i8, quant_arc, name, symbols, exchange_params).await;
+            kucoin_swap_run(bool_v1, time_record, 1i8, quant_arc, name, symbols, exchange_params).await;
         }
         _ => {
             error!("交易交易所启动失败，参数错误！")
@@ -36,19 +38,19 @@ pub async fn run_transactional_exchange(bool_v1 :Arc<AtomicBool>, exchange_name:
 }
 
 // 参考交易所启动
-pub async fn run_reference_exchange(bool_v1 :Arc<AtomicBool>, exchange_name: String, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
+pub async fn run_reference_exchange(bool_v1 :Arc<AtomicBool>, exchange_name: String, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>, time_record: Arc<Mutex<DelayTime>>){
     match exchange_name.as_str() {
         "binance_usdt_swap" => {
-            reference_binance_swap_run(bool_v1, quant_arc, name, symbols, exchange_params).await;
+            reference_binance_swap_run(bool_v1,time_record, quant_arc, name, symbols, exchange_params).await;
         }
         "binance_usdt_spot" => {
-            reference_binance_spot_run(bool_v1, quant_arc, name, symbols, exchange_params).await;
+            reference_binance_spot_run(bool_v1,time_record, quant_arc, name, symbols, exchange_params).await;
         }
         "gate_usdt_swap" => {
-            gate_swap_run(bool_v1, 0i8, quant_arc, name, symbols, exchange_params).await;
+            gate_swap_run(bool_v1, time_record,0i8, quant_arc, name, symbols, exchange_params).await;
         }
         "kucoin_usdt_swap" => {
-            kucoin_swap_run(bool_v1, 0i8, quant_arc, name, symbols, exchange_params).await;
+            kucoin_swap_run(bool_v1, time_record,0i8, quant_arc, name, symbols, exchange_params).await;
         }
         _ => {
             error!("参考交易所启动失败，参数错误！")
@@ -57,7 +59,7 @@ pub async fn run_reference_exchange(bool_v1 :Arc<AtomicBool>, exchange_name: Str
 }
 
 // 1交易、0参考 gate 合约 启动
-async fn gate_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
+async fn gate_swap_run(bool_v1 :Arc<AtomicBool>, time_record: Arc<Mutex<DelayTime>>, type_num: i8, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
     let (tx, mut rx) = channel(100);
     let mut gate_exc = GateSwapRest::new(false, exchange_params.clone());
     // 获取user_id
@@ -116,11 +118,16 @@ async fn gate_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<Mu
                         continue;
                     }
                     if data.channel == "futures.order_book" {
-                        let depth = standard::gate_handle::handle_special_depth(data);
+                        let mut time_delay = time_record.lock().await;
+                        time_delay.network = data.time.clone();
+                        time_delay.format_start = Utc::now().timestamp_micros();
+                        let depth = standard::handle_info::HandleSwapInfo::handle_special_depth(GateSwap, data);
+                        time_delay.format_end = Utc::now().timestamp_micros();
                         {
                             let mut quant = bot_arc_clone.lock().await;
+                            time_delay.quant_start = Utc::now().timestamp_micros();
                             quant._update_ticker(depth.ticker.clone(), depth.name.clone());
-                            quant._update_depth(depth.depth.clone(), depth.name.clone());
+                            quant._update_depth(depth.depth.clone(), depth.name.clone(), &mut time_delay);
                             quant.local_depths.insert(depth.name, depth.depth);
                         }
                     } else if data.channel == "futures.balances" {
@@ -130,6 +137,9 @@ async fn gate_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<Mu
                             quant.update_equity(account);
                         }
                     } else if data.channel == "futures.orders" {
+                        let mut time_delay = time_record.lock().await;
+                        time_delay.network = data.time.clone();
+                        time_delay.format_start = Utc::now().timestamp_micros();
                         let orders = standard::handle_info::HandleSwapInfo::handle_order(GateSwap, data.clone(), multiplier.clone());
                         let mut order_infos:Vec<OrderInfo> = Vec::new();
                         for order in orders.order {
@@ -149,9 +159,11 @@ async fn gate_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<Mu
                             };
                             order_infos.push(order_info);
                         }
+                        time_delay.format_end = Utc::now().timestamp_micros();
                         {
                             let mut quant = bot_arc_clone.lock().await;
-                            quant.update_order(order_infos);
+                            time_delay.quant_start = Utc::now().timestamp_micros();
+                            quant.update_order(order_infos, &mut time_delay);
                         }
                     } else if data.channel == "futures.positions" {
                         let positions = standard::handle_info::HandleSwapInfo::handle_position(GateSwap,data, multiplier.clone());
@@ -189,7 +201,7 @@ async fn gate_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<Mu
 }
 
 // 1交易、0参考 kucoin 合约 启动
-async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
+async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>, time_record : Arc<Mutex<DelayTime>>, type_num: i8, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
     let (tx, mut rx) = channel(100);
     let symbols_clone = symbols.clone();
     let mut symbol_arr = Vec::new();
@@ -235,11 +247,16 @@ async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<
                         continue;
                     }
                     if data.channel == "level2" {
+                        let mut time_delay = time_record.lock().await;
+                        time_delay.network = data.time.clone();
+                        time_delay.format_start = Utc::now().timestamp_micros();
                         let depth = standard::handle_info::HandleSwapInfo::handle_special_depth(KucoinSwap,data);
+                        time_delay.format_end = Utc::now().timestamp_micros();
                         {
                             let mut quant = bot_arc_clone.lock().await;
+                            time_delay.quant_start = Utc::now().timestamp_micros();
                             quant._update_ticker(depth.ticker.clone(), depth.name.clone());
-                            quant._update_depth(depth.depth.clone(), depth.name.clone());
+                            quant._update_depth(depth.depth.clone(), depth.name.clone(), &mut time_delay);
                             quant.local_depths.insert(depth.name, depth.depth);
                         }
                     } else if data.channel == "tickerV2" {
@@ -256,6 +273,9 @@ async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<
                             quant.update_equity(account);
                         }
                     } else if data.channel == "symbolOrderChange" {
+                        let mut time_delay = time_record.lock().await;
+                        time_delay.network = data.time.clone();
+                        time_delay.format_start = Utc::now().timestamp_micros();
                         let orders = standard::handle_info::HandleSwapInfo::handle_order(KucoinSwap, data.clone(), multiplier);
                         let mut order_infos:Vec<OrderInfo> = Vec::new();
                         for order in orders.order {
@@ -278,9 +298,11 @@ async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<
                             };
                             order_infos.push(order_info);
                         }
+                        time_delay.format_end = Utc::now().timestamp_micros();
                         {
                             let mut quant = bot_arc_clone.lock().await;
-                            quant.update_order(order_infos);
+                            time_delay.quant_start = Utc::now().timestamp_micros();
+                            quant.update_order(order_infos, &mut time_delay);
                         }
                     } else if data.channel == "position.change" {
                         let positions = standard::handle_info::HandleSwapInfo::handle_position(KucoinSwap,data, multiplier);
@@ -318,7 +340,7 @@ async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>, type_num: i8, quant_arc: Arc<
 }
 
 // 参考 币安 现货 启动
-async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
+async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>, time_record : Arc<Mutex<DelayTime>>, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
     let (tx, mut rx) = channel(100);
     spawn(async move {
         let mut ba_exc = BinanceSpotWs::new_label(name, false, exchange_params, BinanceSpotWsType::PublicAndPrivate, tx);
@@ -362,17 +384,22 @@ async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>, quant_arc: Arc<Mut
                             quant.max_buy_min_sell_cache.insert(data.label, vec![max_buy, min_sell]);
                         }
                     } else if data.channel == "bookTicker" {
+                        let mut time_delay = time_record.lock().await;
+                        time_delay.network = data.time.clone();
+                        time_delay.format_start = Utc::now().timestamp_micros();
                         let ticker: OriginalTicker = serde_json::from_str(data.data.as_str()).unwrap();
+                        time_delay.format_end = Utc::now().timestamp_micros();
                         if ticker.u > update_flag_u {
                             {
                                 let mut quant = bot_arc_clone.lock().await;
+                                time_delay.quant_start = Utc::now().timestamp_micros();
                                 quant._update_ticker(SpecialTicker{
                                     sell: ticker.a.clone(),
                                     buy: ticker.b.clone(),
                                     mid_price: Default::default(),
                                 }, data.label.clone());
                                 let depth = vec![ticker.b, ticker.B, ticker.a, ticker.A];
-                                quant._update_depth(depth.clone(), data.label.clone());
+                                quant._update_depth(depth.clone(), data.label.clone(), &mut time_delay);
                                 quant.local_depths.insert(data.label.clone(), depth);
                             }
                         } else {
@@ -383,11 +410,16 @@ async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>, quant_arc: Arc<Mut
                         let v: Value = serde_json::from_str(data.data.clone().as_str()).unwrap();
                         let u = v["lastUpdateId"].as_i64().unwrap();
                         if u > update_flag_u {
+                            let mut time_delay = time_record.lock().await;
+                            time_delay.network = data.time.clone();
+                            time_delay.format_start = Utc::now().timestamp_micros();
                             let depth = standard::handle_info::HandleSwapInfo::handle_special_depth(BinanceSpot, data);
+                            time_delay.format_end = Utc::now().timestamp_micros();
                             {
                                 let mut quant = bot_arc_clone.lock().await;
+                                time_delay.quant_start = Utc::now().timestamp_micros();
                                 quant._update_ticker(depth.ticker.clone(), depth.name.clone());
-                                quant._update_depth(depth.depth.clone(), depth.name.clone());
+                                quant._update_depth(depth.depth.clone(), depth.name.clone(), &mut time_delay);
                                 quant.local_depths.insert(depth.name, depth.depth);
                             }
 
@@ -409,7 +441,7 @@ async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>, quant_arc: Arc<Mut
 
 
 // 参考 币安 合约 启动
-async fn reference_binance_swap_run(bool_v1 :Arc<AtomicBool>, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
+async fn reference_binance_swap_run(bool_v1 :Arc<AtomicBool>, time_record : Arc<Mutex<DelayTime>>, quant_arc: Arc<Mutex<Quant>>, name: String, symbols: Vec<String>, exchange_params: BTreeMap<String, String>){
     let (tx, mut rx) = channel(100);
     spawn( async move {
         let mut ba_exc = BinanceSwapWs::new_label(name, false, exchange_params, BinanceWsType::PublicAndPrivate, tx);
@@ -452,17 +484,22 @@ async fn reference_binance_swap_run(bool_v1 :Arc<AtomicBool>, quant_arc: Arc<Mut
                             quant.max_buy_min_sell_cache.insert(data.label, vec![max_buy, min_sell]);
                         }
                     } else if data.channel == "bookTicker" {
+                        let mut time_delay = time_record.lock().await;
+                        time_delay.network = data.time.clone();
+                        time_delay.format_start = Utc::now().timestamp_micros();
                         let ticker: OriginalTicker = serde_json::from_str(data.data.as_str()).unwrap();
+                        time_delay.format_end = Utc::now().timestamp_micros();
                         if ticker.u > update_flag_u {
                             {
                                 let mut quant = bot_arc_clone.lock().await;
+                                time_delay.quant_start = Utc::now().timestamp_micros();
                                 quant._update_ticker(SpecialTicker{
                                     sell: ticker.a.clone(),
                                     buy: ticker.b.clone(),
                                     mid_price: Default::default(),
                                 }, data.label.clone());
                                 let depth = vec![ticker.b, ticker.B, ticker.a, ticker.A];
-                                quant._update_depth(depth.clone(), data.label.clone());
+                                quant._update_depth(depth.clone(), data.label.clone(), &mut time_delay);
                                 quant.local_depths.insert(data.label.clone(), depth);
                             }
                         } else {
@@ -473,11 +510,16 @@ async fn reference_binance_swap_run(bool_v1 :Arc<AtomicBool>, quant_arc: Arc<Mut
                         let v: Value = serde_json::from_str(data.data.clone().as_str()).unwrap();
                         let u = v["u"].as_i64().unwrap();
                         if u > update_flag_u {
+                            let mut time_delay = time_record.lock().await;
+                            time_delay.network = data.time.clone();
+                            time_delay.format_start = Utc::now().timestamp_micros();
                             let depth = standard::handle_info::HandleSwapInfo::handle_special_depth(BinanceSwap, data);
+                            time_delay.format_end = Utc::now().timestamp_micros();
                             {
                                 let mut quant = bot_arc_clone.lock().await;
+                                time_delay.quant_start = Utc::now().timestamp_micros();
                                 quant._update_ticker(depth.ticker.clone(), depth.name.clone());
-                                quant._update_depth(depth.depth.clone(), depth.name.clone());
+                                quant._update_depth(depth.depth.clone(), depth.name.clone(), &mut time_delay);
                                 quant.local_depths.insert(depth.name, depth.depth);
                             }
                         } else {

strategy/src/quant.rs

@@ -11,10 +11,11 @@ use rust_decimal::prelude::{ToPrimitive};
 use rust_decimal_macros::dec;
 use tokio::spawn;
 use tokio::sync::mpsc::{Receiver, Sender};
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, MutexGuard};
 use tokio::task::JoinHandle;
 use tokio::time::sleep;
 use tracing::{debug, error, info, warn};
+use global::delay_time::DelayTime;
 use global::params::Params;
 use global::public_params::{ASK_PRICE_INDEX, BID_PRICE_INDEX, LENGTH};
 use standard::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, SpecialTicker, Ticker};
@@ -264,7 +265,7 @@ impl Quant {
         return quant_obj;
     }
 
-    pub async fn handle_signals(quant_arc: Arc<Mutex<Quant>>, mut rx: Receiver<Order>) {
+    pub async fn handle_signals(quant_arc: Arc<Mutex<Quant>>, mut rx: Receiver<Order>, time_record: Arc<Mutex<DelayTime>>) {
         spawn(async move{
             loop {
                 sleep(Duration::from_millis(1)).await;
@@ -293,8 +294,9 @@ impl Quant {
                                 local_order_info.client_id = val.custom_id;
                             }
                             let mut bot = quant_arc.lock().await;
+                            let mut time_delay = time_record.lock().await;
                             // 写入本地订单缓存
-                            bot.update_local_order(local_order_info);
+                            bot.update_local_order(local_order_info, &mut time_delay);
                         }
                     },
                     Err(e) => {
@@ -305,13 +307,13 @@ impl Quant {
             }
         });
     }
-    pub fn update_order(&mut self, data: Vec<OrderInfo>){
+    pub fn update_order(&mut self, data: Vec<OrderInfo>, time_record: &mut MutexGuard<DelayTime>){
         for order in data {
-            self.update_local_order(order);
+            self.update_local_order(order, time_record);
         }
     }
 
-    pub fn update_local_order(&mut self, data: OrderInfo) {
+    pub fn update_local_order(&mut self, data: OrderInfo, time_record: &mut MutexGuard<DelayTime>) {
         if data.filled != Decimal::ZERO {
             info!("接收到订单信息①：{:?}", data);
         }
@@ -495,11 +497,14 @@ impl Quant {
                         // 触发策略挂单逻辑
                         // 更新策略时间
                         self.strategy.local_time = Utc::now().timestamp_millis();
+                        time_record.strategy_start = Utc::now().timestamp_micros();
                         let order = self.strategy.on_time(&self.trade_msg);
+                        time_record.strategy_end = Utc::now().timestamp_micros();
                         // 记录指令触发信息
                         if order.is_not_empty() {
                             // info!("触发onOrder");
                             self._update_local_orders(&order);
+                            time_record.quant_end = Utc::now().timestamp_micros();
                             //交易所处理订单信号
                             let mut platform_rest_fb = self.platform_rest.clone_box();
                             // info!("订单指令：{:?}", order);
@@ -570,7 +575,7 @@ impl Quant {
         self.ready = 1
     }
 
-    pub fn _update_depth(&mut self, depth: Vec<Decimal>, name :String) {
+    pub fn _update_depth(&mut self, depth: Vec<Decimal>, name :String, time_record: &mut MutexGuard<DelayTime>) {
         // 要从回调传入的深度信息中获取data.name
         let market_update_interval_key = name.clone();
         let market_update_time_key = name.clone();
@@ -624,12 +629,15 @@ impl Quant {
                 // 触发事件撤单逻辑
                 // 更新策略时间
                 self.strategy.local_time = Utc::now().timestamp_millis();
+
+                time_record.strategy_start = Utc::now().timestamp_micros();
                 // 产生交易信号
                 let orders = self.strategy.on_time(&self.trade_msg);
+                time_record.strategy_end = Utc::now().timestamp_micros();
                 if orders.is_not_empty() {
                     debug!("触发onTick");
                     self._update_local_orders(&orders);
-
+                    time_record.quant_end = Utc::now().timestamp_micros();
                     //异步交易所处理订单信号
                     let mut platform_rest_fb = self.platform_rest.clone_box();
                     // info!("订单指令：{:?}", orders);