Skip to content

Commit

Permalink
remove redundant code
Browse files Browse the repository at this point in the history
  • Loading branch information
@ChillFish8
ChillFish8 committed Jul 31, 2021
1 parent 6a21c14 commit 07ab7d9
Showing 1 changed file with 25 additions and 96 deletions.
121 changes: 25 additions & 96 deletions src/results.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,25 @@ use tokio::time::Duration;

use crate::utils::format_data;

fn get_percentile(request_times: &Vec<Duration>, pct: f64) -> Duration {
let mut len = request_times.len() as f64 * pct;
if len < 1.0 {
len = 1.0;
}

let e = format!("failed to calculate P{} avg latency", (1.0 - pct) * 100f64);
let pct = request_times
.chunks(len as usize)
.next()
.expect(&e);

let total: f64 = pct.iter().map(|dur| dur.as_secs_f64()).sum();

let avg = total / pct.len() as f64;

Duration::from_secs_f64(avg)
}

/// Contains and handles results from the workers
pub struct WorkerResult {
/// The total time taken for each worker.
Expand Down Expand Up @@ -139,122 +158,32 @@ impl WorkerResult {

/// Works out the average latency of the 99.9 percentile.
pub fn p999_avg_latency(&self) -> Duration {
let mut len = self.request_times.len() as f64 * 0.001;
if len < 1.0 {
len = 1.0;
}

let p999 = self
.request_times
.chunks(len as usize)
.next()
.expect("Failed to calculate P99.9 avg latency");

let total: f64 = p999.iter().map(|dur| dur.as_secs_f64()).sum();

let avg = total / p999.len() as f64;

Duration::from_secs_f64(avg)
get_percentile(&self.request_times, 0.001)
}

/// Works out the average latency of the 99 percentile.
pub fn p99_avg_latency(&self) -> Duration {
let mut len = self.request_times.len() as f64 * 0.01;
if len < 1.0 {
len = 1.0;
}

let p99 = self
.request_times
.chunks(len as usize)
.next()
.expect("Failed to calculate P99 avg latency");

let total: f64 = p99.iter().map(|dur| dur.as_secs_f64()).sum();

let avg = total / p99.len() as f64;

Duration::from_secs_f64(avg)
get_percentile(&self.request_times, 0.01)
}

/// Works out the average latency of the 95 percentile.
pub fn p95_avg_latency(&self) -> Duration {
let mut len = self.request_times.len() as f64 * 0.05;
if len < 1.0 {
len = 1.0;
}

let p95 = self
.request_times
.chunks(len as usize)
.next()
.expect("Failed to calculate P95 avg latency");

let total: f64 = p95.iter().map(|dur| dur.as_secs_f64()).sum();

let avg = total / p95.len() as f64;

Duration::from_secs_f64(avg)
get_percentile(&self.request_times, 0.05)
}

/// Works out the average latency of the 90 percentile.
pub fn p90_avg_latency(&self) -> Duration {
let mut len = self.request_times.len() as f64 * 0.10;
if len < 1.0 {
len = 1.0;
}

let p90 = self
.request_times
.chunks(len as usize)
.next()
.expect("Failed to calculate P90 avg latency");

let total: f64 = p90.iter().map(|dur| dur.as_secs_f64()).sum();

let avg = total / p90.len() as f64;

Duration::from_secs_f64(avg)
get_percentile(&self.request_times, 0.1)
}

/// Works out the average latency of the 75 percentile.
pub fn p75_avg_latency(&mut self) -> Duration {
let mut len = self.request_times.len() as f64 * 0.25;
if len < 1.0 {
len = 1.0;
}

let p75 = self
.request_times
.chunks(len as usize)
.next()
.expect("Failed to calculate P75 avg latency");

let total: f64 = p75.iter().map(|dur| dur.as_secs_f64()).sum();

let avg = total / p75.len() as f64;

Duration::from_secs_f64(avg)
get_percentile(&self.request_times, 0.25)
}

/// Works out the average latency of the 50 percentile.
pub fn p50_avg_latency(&mut self) -> Duration {
let mut len = self.request_times.len() / 2;
if len == 0 {
len = 1;
}

let p50 = self
.request_times
.chunks(len)
.next()
.expect("Failed to calculate P50 avg latency");

let total: f64 = p50.iter().map(|dur| dur.as_secs_f64()).sum();

let avg = total / p50.len() as f64;

Duration::from_secs_f64(avg)
get_percentile(&self.request_times, 0.5)
}

pub fn display_latencies(&mut self) {
Expand Down

0 comments on commit 07ab7d9

Please sign in to comment.