From 366fe8a024a999b9d9ed293e642844fb0fb1d0ea Mon Sep 17 00:00:00 2001 From: Godmode Galactus Date: Thu, 6 Apr 2023 19:06:48 +0200 Subject: [PATCH] fixing metrics with diff of data --- src/stats.rs | 418 ++++++++++++++++++++++++++++++++------------------- 1 file changed, 263 insertions(+), 155 deletions(-) diff --git a/src/stats.rs b/src/stats.rs index 1954365..0f36848 100644 --- a/src/stats.rs +++ b/src/stats.rs @@ -1,4 +1,5 @@ use std::{ + sync::Mutex, sync::{ atomic::{AtomicU64, Ordering}, Arc, @@ -10,8 +11,74 @@ use crate::states::{KeeperInstruction, TransactionConfirmRecord}; use solana_metrics::datapoint_info; use tokio::task::JoinHandle; +// Non atomic version of counters +#[derive(Clone, Default, Debug, Copy)] +struct NACounters { + num_confirmed_txs: u64, + num_error_txs: u64, + num_timeout_txs: u64, + num_successful: u64, + num_sent: u64, + + // sent transasctions + num_market_makers_txs: u64, + num_consume_events_txs: u64, + num_cache_price_txs: u64, + num_update_and_cache_quote_bank_txs: u64, + num_update_root_banks_txs: u64, + num_cache_root_banks_txs: u64, + num_update_perp_cache_txs: u64, + num_update_funding_txs: u64, + + // successful transasctions + succ_market_makers_txs: u64, + succ_consume_events_txs: u64, + succ_cache_price_txs: u64, + succ_update_and_cache_quote_bank_txs: u64, + succ_update_root_banks_txs: u64, + succ_cache_root_banks_txs: u64, + succ_update_perp_cache_txs: u64, + succ_update_funding_txs: u64, +} + +impl NACounters { + pub fn diff(&self, other: &NACounters) -> NACounters { + NACounters { + num_confirmed_txs: self.num_confirmed_txs - other.num_confirmed_txs, + num_error_txs: self.num_error_txs - other.num_error_txs, + num_timeout_txs: self.num_timeout_txs - other.num_timeout_txs, + num_successful: self.num_successful - other.num_successful, + num_sent: self.num_sent - other.num_sent, + num_market_makers_txs: self.num_market_makers_txs - other.num_market_makers_txs, + num_consume_events_txs: self.num_consume_events_txs - other.num_consume_events_txs, + num_cache_price_txs: self.num_cache_price_txs - other.num_cache_price_txs, + num_update_and_cache_quote_bank_txs: self.num_update_and_cache_quote_bank_txs + - other.num_update_and_cache_quote_bank_txs, + num_update_root_banks_txs: self.num_update_root_banks_txs + - other.num_update_root_banks_txs, + num_cache_root_banks_txs: self.num_cache_root_banks_txs + - other.num_cache_root_banks_txs, + num_update_perp_cache_txs: self.num_update_perp_cache_txs + - other.num_update_perp_cache_txs, + num_update_funding_txs: self.num_update_funding_txs - other.num_update_funding_txs, + succ_market_makers_txs: self.succ_market_makers_txs - other.succ_market_makers_txs, + succ_consume_events_txs: self.succ_consume_events_txs - other.succ_consume_events_txs, + succ_cache_price_txs: self.succ_cache_price_txs - other.succ_cache_price_txs, + succ_update_and_cache_quote_bank_txs: self.succ_update_and_cache_quote_bank_txs + - other.succ_update_and_cache_quote_bank_txs, + succ_update_root_banks_txs: self.succ_update_root_banks_txs + - other.succ_update_root_banks_txs, + succ_cache_root_banks_txs: self.succ_cache_root_banks_txs + - other.succ_cache_root_banks_txs, + succ_update_perp_cache_txs: self.succ_update_perp_cache_txs + - other.succ_update_perp_cache_txs, + succ_update_funding_txs: self.succ_update_funding_txs - other.succ_update_funding_txs, + } + } +} + #[derive(Default, Clone, Debug)] -pub struct Counters { +struct Counters { num_confirmed_txs: Arc, num_error_txs: Arc, num_timeout_txs: Arc, @@ -39,10 +106,47 @@ pub struct Counters { succ_update_funding_txs: Arc, } +impl Counters { + pub fn to_na_counters(&self) -> NACounters { + NACounters { + num_confirmed_txs: self.num_confirmed_txs.load(Ordering::Relaxed), + num_error_txs: self.num_error_txs.load(Ordering::Relaxed), + num_timeout_txs: self.num_timeout_txs.load(Ordering::Relaxed), + num_successful: self.num_successful.load(Ordering::Relaxed), + num_sent: self.num_sent.load(Ordering::Relaxed), + + // sent transasctions + num_market_makers_txs: self.num_market_makers_txs.load(Ordering::Relaxed), + num_consume_events_txs: self.num_consume_events_txs.load(Ordering::Relaxed), + num_cache_price_txs: self.num_cache_price_txs.load(Ordering::Relaxed), + num_update_and_cache_quote_bank_txs: self + .num_update_and_cache_quote_bank_txs + .load(Ordering::Relaxed), + num_update_root_banks_txs: self.num_update_root_banks_txs.load(Ordering::Relaxed), + num_cache_root_banks_txs: self.num_cache_root_banks_txs.load(Ordering::Relaxed), + num_update_perp_cache_txs: self.num_update_perp_cache_txs.load(Ordering::Relaxed), + num_update_funding_txs: self.num_update_funding_txs.load(Ordering::Relaxed), + + // successful transasctions + succ_market_makers_txs: self.succ_market_makers_txs.load(Ordering::Relaxed), + succ_consume_events_txs: self.succ_consume_events_txs.load(Ordering::Relaxed), + succ_cache_price_txs: self.succ_cache_price_txs.load(Ordering::Relaxed), + succ_update_and_cache_quote_bank_txs: self + .succ_update_and_cache_quote_bank_txs + .load(Ordering::Relaxed), + succ_update_root_banks_txs: self.succ_update_root_banks_txs.load(Ordering::Relaxed), + succ_cache_root_banks_txs: self.succ_cache_root_banks_txs.load(Ordering::Relaxed), + succ_update_perp_cache_txs: self.succ_update_perp_cache_txs.load(Ordering::Relaxed), + succ_update_funding_txs: self.succ_update_funding_txs.load(Ordering::Relaxed), + } + } +} + #[derive(Debug, Clone)] pub struct MangoSimulationStats { recv_limit: usize, counters: Counters, + previous_counters: Arc>, instant: Instant, } @@ -57,6 +161,7 @@ impl MangoSimulationStats { recv_limit: nb_market_makers * quotes_per_second * nb_markets_per_mm * duration_in_sec, counters: Counters::default(), instant: Instant::now(), + previous_counters: Arc::new(Mutex::new(NACounters::default())), } } @@ -158,199 +263,202 @@ impl MangoSimulationStats { } pub fn report(&mut self, is_final: bool, name: &'static str) { - let num_sent = self.counters.num_sent.load(Ordering::Relaxed); - let num_confirmed_txs = self.counters.num_confirmed_txs.load(Ordering::Relaxed); - let num_successful = self.counters.num_successful.load(Ordering::Relaxed); - let num_error_txs = self.counters.num_error_txs.load(Ordering::Relaxed); - let num_timeout_txs = self.counters.num_timeout_txs.load(Ordering::Relaxed); let time_diff = std::time::Instant::now() - self.instant; - - let num_market_makers_txs = self.counters.num_market_makers_txs.load(Ordering::Relaxed); - let num_consume_events_txs = self.counters.num_consume_events_txs.load(Ordering::Relaxed); - let num_cache_price_txs = self.counters.num_cache_price_txs.load(Ordering::Relaxed); - let num_update_and_cache_quote_bank_txs = self - .counters - .num_update_and_cache_quote_bank_txs - .load(Ordering::Relaxed); - let num_update_root_banks_txs = self - .counters - .num_update_root_banks_txs - .load(Ordering::Relaxed); - let num_cache_root_banks_txs = self - .counters - .num_cache_root_banks_txs - .load(Ordering::Relaxed); - let num_update_perp_cache_txs = self - .counters - .num_update_perp_cache_txs - .load(Ordering::Relaxed); - let num_update_funding_txs = self.counters.num_update_funding_txs.load(Ordering::Relaxed); - - let succ_market_makers_txs = self.counters.succ_market_makers_txs.load(Ordering::Relaxed); - let succ_consume_events_txs = self - .counters - .succ_consume_events_txs - .load(Ordering::Relaxed); - let succ_cache_price_txs = self.counters.succ_cache_price_txs.load(Ordering::Relaxed); - let succ_update_and_cache_quote_bank_txs = self - .counters - .succ_update_and_cache_quote_bank_txs - .load(Ordering::Relaxed); - let succ_update_root_banks_txs = self - .counters - .succ_update_root_banks_txs - .load(Ordering::Relaxed); - let succ_cache_root_banks_txs = self - .counters - .succ_cache_root_banks_txs - .load(Ordering::Relaxed); - let succ_update_perp_cache_txs = self - .counters - .succ_update_perp_cache_txs - .load(Ordering::Relaxed); - let succ_update_funding_txs = self - .counters - .succ_update_funding_txs - .load(Ordering::Relaxed); + let counters = self.counters.to_na_counters(); + let diff = { + let mut prev_counter_lock = self.previous_counters.lock().unwrap(); + let diff = counters.diff(&prev_counter_lock); + *prev_counter_lock = counters; + diff + }; println!("\n\n{} at {} secs", name, time_diff.as_secs()); if !is_final { - println!("Recently sent transactions could not yet be confirmed and would be confirmed shortly.\n"); + println!("Recently sent transactions could not yet be confirmed and would be confirmed shortly.\n + diff is wrt previous report"); } println!( "Number of expected marker making transactions : {}", self.recv_limit ); println!( - "Number of transactions sent : {} (including keeper)", - num_sent + "Number of transactions Sent:({}) (including keeper) (Diff:({}))", + counters.num_sent, diff.num_sent, ); println!( - "Market Maker transactions : Sent {}, Successful {}", - num_market_makers_txs, succ_market_makers_txs + "Market Maker transactions : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_market_makers_txs, + counters.succ_market_makers_txs, + diff.num_market_makers_txs, + diff.succ_market_makers_txs, ); println!( - "Keeper Cosume Events : Sent {}, Successful {}", - num_consume_events_txs, succ_consume_events_txs + "Keeper Cosume Events : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_consume_events_txs, + counters.succ_consume_events_txs, + diff.num_consume_events_txs, + diff.succ_consume_events_txs ); println!( - "Keeper Cache Price : Sent {}, Successful {}", - num_cache_price_txs, succ_cache_price_txs + "Keeper Cache Price : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_cache_price_txs, + counters.succ_cache_price_txs, + diff.num_cache_price_txs, + diff.succ_cache_price_txs ); println!( - "Keeper Update and Cache Quote Bank : Sent {}, Successful {}", - num_update_and_cache_quote_bank_txs, succ_update_and_cache_quote_bank_txs + "Keeper Update and Cache Quote Bank : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_update_and_cache_quote_bank_txs, counters.succ_update_and_cache_quote_bank_txs, diff.num_update_and_cache_quote_bank_txs, diff.succ_update_and_cache_quote_bank_txs ); println!( - "Keeper Update Root Banks : Sent {}, Successful {}", - num_update_root_banks_txs, succ_update_root_banks_txs + "Keeper Update Root Banks : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_update_root_banks_txs, + counters.succ_update_root_banks_txs, + diff.num_update_root_banks_txs, + diff.succ_update_root_banks_txs ); println!( - "Keeper Cache Root Banks : Sent {}, Successful {}", - num_cache_root_banks_txs, succ_cache_root_banks_txs + "Keeper Cache Root Banks : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_cache_root_banks_txs, + counters.succ_cache_root_banks_txs, + diff.num_cache_root_banks_txs, + diff.succ_cache_root_banks_txs ); println!( - "Keeper Update Perp Cache : Sent {}, Successful {}", - num_update_perp_cache_txs, succ_update_perp_cache_txs + "Keeper Update Perp Cache : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_update_perp_cache_txs, + counters.succ_update_perp_cache_txs, + diff.num_update_perp_cache_txs, + diff.succ_update_perp_cache_txs ); println!( - "Keeper Update Funding : Sent {}, Successful {}", - num_update_funding_txs, succ_update_funding_txs + "Keeper Update Funding : Sent({}), Successful({}) (Diff : Sent({}), Successful({}))", + counters.num_update_funding_txs, + counters.succ_update_funding_txs, + diff.num_update_funding_txs, + diff.succ_update_funding_txs ); println!( "Transactions confirmed {}%", - (num_confirmed_txs * 100).checked_div(num_sent).unwrap_or(0) + (counters.num_confirmed_txs * 100) + .checked_div(counters.num_sent) + .unwrap_or(0) ); println!( "Transactions successful {}%", - (num_successful * 100).checked_div(num_sent).unwrap_or(0) + (counters.num_successful * 100) + .checked_div(counters.num_sent) + .unwrap_or(0) ); println!( "Transactions timed out {}%", - (num_timeout_txs * 100).checked_div(num_sent).unwrap_or(0) + (counters.num_timeout_txs * 100) + .checked_div(counters.num_sent) + .unwrap_or(0) ); println!("\n\n"); - datapoint_info!( - name, - ("recv_limit", self.recv_limit, i64), - ("num_txs_sent", num_sent, i64), - ("num_confirmed_txs", num_confirmed_txs, i64), - ("num_successful_txs", num_successful, i64), - ("num_error_txs", num_error_txs, i64), - ("num_timeout_txs", num_timeout_txs, i64), - ( - "percent_confirmed_txs", - (num_confirmed_txs * 100).checked_div(num_sent).unwrap_or(0), - f64 - ), - ( - "percent_successful_txs", - (num_confirmed_txs * 100).checked_div(num_sent).unwrap_or(0), - f64 - ), - ( - "percent_error_txs", - (num_error_txs * 100).checked_div(num_sent).unwrap_or(0), - f64 - ), - ( - "percent_timeout_txs", - (num_timeout_txs * 100).checked_div(num_sent).unwrap_or(0), - f64 - ), - ("keeper_consume_events_sent", num_consume_events_txs, i64), - ( - "keeper_consume_events_success", - succ_consume_events_txs, - i64 - ), - ("keeper_cache_price_sent", num_cache_price_txs, i64), - ("keeper_cache_price_success", succ_cache_price_txs, i64), - ( - "keeper_update_and_cache_qb_sent", - num_update_and_cache_quote_bank_txs, - i64 - ), - ( - "keeper_update_and_cache_qb_succ", - succ_update_and_cache_quote_bank_txs, - i64 - ), - ( - "keeper_update_root_banks_sent", - num_update_root_banks_txs, - i64 - ), - ( - "keeper_update_root_banks_succ", - succ_update_root_banks_txs, - i64 - ), - ( - "keeper_cache_root_banks_sent", - num_cache_root_banks_txs, - i64 - ), - ( - "keeper_cache_root_banks_succ", - succ_cache_root_banks_txs, - i64 - ), - ( - "keeper_update_perp_cache_sent", - num_update_perp_cache_txs, - i64 - ), - ( - "keeper_update_perp_cache_succ", - succ_update_perp_cache_txs, - i64 - ), - ("keeper_update_funding_sent", num_update_funding_txs, i64), - ("keeper_update_funding_succ", succ_update_funding_txs, i64), - ); + if !is_final { + datapoint_info!( + name, + ("num_txs_sent", diff.num_sent, i64), + ("num_confirmed_txs", diff.num_confirmed_txs, i64), + ("num_successful_txs", diff.num_successful, i64), + ("num_error_txs", diff.num_error_txs, i64), + ("num_timeout_txs", diff.num_timeout_txs, i64), + ( + "percent_confirmed_txs", + (diff.num_confirmed_txs * 100) + .checked_div(diff.num_sent) + .unwrap_or(0), + f64 + ), + ( + "percent_successful_txs", + (diff.num_confirmed_txs * 100) + .checked_div(diff.num_sent) + .unwrap_or(0), + f64 + ), + ( + "percent_error_txs", + (diff.num_error_txs * 100) + .checked_div(diff.num_sent) + .unwrap_or(0), + f64 + ), + ( + "percent_timeout_txs", + (diff.num_timeout_txs * 100) + .checked_div(diff.num_sent) + .unwrap_or(0), + f64 + ), + ( + "keeper_consume_events_sent", + diff.num_consume_events_txs, + i64 + ), + ( + "keeper_consume_events_success", + diff.succ_consume_events_txs, + i64 + ), + ("keeper_cache_price_sent", diff.num_cache_price_txs, i64), + ("keeper_cache_price_success", diff.succ_cache_price_txs, i64), + ( + "keeper_update_and_cache_qb_sent", + diff.num_update_and_cache_quote_bank_txs, + i64 + ), + ( + "keeper_update_and_cache_qb_succ", + diff.succ_update_and_cache_quote_bank_txs, + i64 + ), + ( + "keeper_update_root_banks_sent", + diff.num_update_root_banks_txs, + i64 + ), + ( + "keeper_update_root_banks_succ", + diff.succ_update_root_banks_txs, + i64 + ), + ( + "keeper_cache_root_banks_sent", + diff.num_cache_root_banks_txs, + i64 + ), + ( + "keeper_cache_root_banks_succ", + diff.succ_cache_root_banks_txs, + i64 + ), + ( + "keeper_update_perp_cache_sent", + diff.num_update_perp_cache_txs, + i64 + ), + ( + "keeper_update_perp_cache_succ", + diff.succ_update_perp_cache_txs, + i64 + ), + ( + "keeper_update_funding_sent", + diff.num_update_funding_txs, + i64 + ), + ( + "keeper_update_funding_succ", + diff.succ_update_funding_txs, + i64 + ), + ); + } } }