Struct Speed 

pub struct Speed { /* private fields */ }

Structure to define a transaction flow speed

use tokio::time::Instant;
use std::time::Duration;
use prosa::event::speed::Speed;
use std::thread::sleep;

const SLEEP_DURATION: Duration = Duration::from_millis(40);
const TPS: f64 = 25.0;
let mut speed = Speed::new(5);

// Send transactions
speed.time();
speed.time();
sleep(SLEEP_DURATION);
speed.time();
sleep(SLEEP_DURATION);
speed.time();
sleep(SLEEP_DURATION);
speed.time();
sleep(SLEEP_DURATION);

// Replace the first transaction time (size > 5)
speed.time();
let mut duration = speed.get_duration(TPS);     // 40 miliseconds for the duration to keep the same TPS rate
(25..=44).contains(&duration.as_millis());
sleep(SLEEP_DURATION);

let mean_duration = speed.get_mean_duration();  // 40 miliseconds between each transactions
(25..=44).contains(&mean_duration.as_millis());
let speed_tps = speed.get_speed().round();      // 25 TPS
assert_eq!(TPS, speed_tps);
duration = speed.get_duration(TPS);             // 0 miliseconds for the duration to keep the same TPS rate
assert!(duration.as_millis() <= 4);

Implementations

impl Speed

pub fn new(size_for_average: u16) -> Speed

Create a new speed using a number of desired samples (5 minimum)

pub fn time_event(&mut self, instant: Instant)

Add an event instant

pub fn time(&mut self)

Add an event at the current instant time

pub fn get_last_event(&self) -> Option<&Instant>

Get the last event instant value or None if empty

pub fn get_mean_duration(&self) -> Duration

Getter of the mean time between transaction

pub fn get_speed(&self) -> f64

Getter of the current speed of transaction flow

pub fn get_duration_overhead( &self, tps: f64, overhead: Option<Duration>, ) -> Duration

Returns the duration to wait since the last event to achieve the target TPS (Transactions Per Second). Includes a small overhead to ensure a conservative duration and avoid overwhelming a remote system. If TPS is not positive or finite, returns Duration::MAX. Returns Duration::ZERO if the calculated duration is negative.

pub fn get_duration(&self, tps: f64) -> Duration

Returns the duration to wait since the last event to achieve the target TPS (Transactions Per Second). If TPS is not positive or finite, returns Duration::MAX. Returns Duration::ZERO if the calculated duration is negative.

Trait Implementations

impl Clone for Speed

fn clone(&self) -> Speed

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Speed

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Speed

fn default() -> Self

Default speed with a sample size of 15

impl Display for Speed

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Speed

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Speed

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.