Compare commits

..

15 Commits

Author SHA1 Message Date
Gregory Ballantine
a6f6994c2b Added runtime req for iperf3
Some checks failed
ci/woodpecker/push/woodpecker Pipeline failed
2024-01-28 19:59:31 -05:00
a4e0f27ddb Version bump to v0.4.0
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
ci/woodpecker/tag/woodpecker Pipeline was successful
2022-09-05 13:06:02 -04:00
f9de9ef93c Renamed the 'ping' test to the 'latency' test to more accurately reflect the test; Added the '-i' flag to the jitter and latency tests to set the ping interval timing
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-09-05 13:05:32 -04:00
3169c11cc5 Version bump to v0.3.3
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
ci/woodpecker/tag/woodpecker Pipeline was successful
2022-09-05 12:31:47 -04:00
d4d3e37e8d Completed the network bandwidth test function using iperf3; adjusted Cargo.toml a bit to allow patch updates for dependencies
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-09-05 12:31:18 -04:00
7b7150886a Made the Steam game download function work for both Windows and Linux
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-22 13:47:49 -04:00
4aa3eddc91 Added scaffolding for a few game benchmarks - they currently just make sure the game is installed via Steam, nothing else
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-22 13:45:16 -04:00
8a7d8c1860 Version bump to v0.3.2
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
ci/woodpecker/tag/woodpecker Pipeline was successful
2022-08-17 18:49:12 -04:00
39ce86d2c3 Fixed the network ping and jitter tests to run on Windows
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-17 18:48:07 -04:00
88be1ad2ba Added the scaffolding for the jitter test. Now just need to perform the proper calculations.
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-17 18:39:53 -04:00
7555a2a3a7 Version bump to v0.3.1
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
ci/woodpecker/tag/woodpecker Pipeline was successful
2022-08-17 18:05:41 -04:00
9cd88d923d Changed the parameter for the network ping test
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-17 18:03:48 -04:00
6fdc52b320 Updated the network bandwidth arguments to be more consistent with the disk command arguments
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-17 18:01:14 -04:00
f9ca8beaad Fixed the tempfile flags for some of the disk commands
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-17 17:58:04 -04:00
132a0ee501 Added a runtime parameter to the CPU stress test to automatically limit how long it runs
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
2022-08-17 15:28:11 -04:00
7 changed files with 199 additions and 66 deletions

View File

@ -1,7 +1,7 @@
[package] [package]
name = "hardware-tests" name = "hardware-tests"
description = "Bit Goblin PC hardware test suite." description = "Bit Goblin PC hardware test suite."
version = "0.3.0" version = "0.4.0"
edition = "2021" edition = "2021"
readme = "README.md" readme = "README.md"
license = "BSD 2-Clause" license = "BSD 2-Clause"
@ -12,9 +12,9 @@ name = "bgbench"
path = "src/main.rs" path = "src/main.rs"
[dependencies] [dependencies]
chrono = "0.4.20" chrono = "0.4"
clap = { version = "3.2.16", features = ["derive"] } clap = { version = "3.2", features = ["derive"] }
sysinfo = "0.25.1" sysinfo = "0.25"
[package.metadata.deb] [package.metadata.deb]
depends = "fio" depends = "fio"

View File

@ -13,7 +13,8 @@ Currently there is no installation method other than downloading the provided re
Simply run the tool with `./bgbench` and you'll be presented with the available subcommands. Simply run the tool with `./bgbench` and you'll be presented with the available subcommands.
### Runtime requirements: ### Runtime requirements:
* disk - requires `fio`. * `disk` - requires `fio`.
* `network bandwidth` - requires `iperf3`
## Building ## Building

36
src/benchmarks/games.rs Normal file
View File

@ -0,0 +1,36 @@
use std::process::Command;
pub fn run_civ6_ai_benchmark() {
// make sure CS:GO is installed via Steam
download_game_steam(289070);
}
// run the CS:GO benchmark (using benchmark file from PTS)
pub fn run_csgo_benchmark() {
// make sure CS:GO is installed via Steam
download_game_steam(730);
}
pub fn run_demd_benchmark() {
// make sure CS:GO is installed via Steam
download_game_steam(337000);
}
fn download_game_steam(game_id: u32) {
let mut steam_path = "steam";
if cfg!(windows) {
steam_path = "C:\\Program Files (x86)\\Steam\\steam.exe";
}
// first we need to make sure CS:GO is installed via Steam
let install_output = Command::new(steam_path)
.arg(format!("steam://install/{}", game_id))
.output()
.expect("Failed to execute command");
// check that the command succeeded
assert!(install_output.status.success());
// print the test's output
println!("{}", String::from_utf8_lossy(&install_output.stdout));
}

View File

@ -1,2 +1,3 @@
pub mod disk; pub mod disk;
pub mod games;
pub mod network; pub mod network;

View File

@ -1,16 +1,61 @@
use chrono::prelude::*; use std::process;
use std::{fs,process};
use crate::text; use crate::text;
// ping a host // ping a host
pub fn ping_host(host: &str, count: &u16) { pub fn latency_test(address: &str, count: &u16, interval: &u16) {
println!("Pinging host {}, {} times.", host, count); println!("Pinging host {}, {} times.", address, count);
// if we're on Windows we need to use the -n flag for ping counts
let mut count_arg = "-c";
if cfg!(windows) {
count_arg = "-n";
}
// convert the ping interval to seconds
let interval_secs = *interval as f64 / 1000 as f64;
// run the ping command // run the ping command
let output = process::Command::new("ping") let output = process::Command::new("ping")
.arg(host) .arg(address)
.arg(format!("-c {}", count)) .arg(count_arg)
.arg(format!("{}", count))
.arg("-i")
.arg(format!("{}", interval_secs))
.output()
.expect("Failed to execute command");
// check that the command succeeded
assert!(output.status.success());
// grab the ping results from stdout
let results_raw = &String::from_utf8_lossy(&output.stdout);
let results = text::format::trim_output(results_raw, 4);
for line in results {
println!("{}", line);
}
}
// network jitter test
pub fn jitter_test(address: &str, count: &u16, interval: &u16) {
println!("Pinging host {}, {} times to determine network jitter.", address, count);
// if we're on Windows we need to use the -n flag for ping counts
let mut count_arg = "-c";
if cfg!(windows) {
count_arg = "-n";
}
// convert the ping interval to seconds
let interval_secs = *interval as f64 / 1000 as f64;
// run the ping command
let output = process::Command::new("ping")
.arg(address)
.arg(count_arg)
.arg(format!("{}", count))
.arg("-i")
.arg(format!("{}", interval_secs))
.output() .output()
.expect("Failed to execute command"); .expect("Failed to execute command");
@ -26,23 +71,20 @@ pub fn ping_host(host: &str, count: &u16) {
} }
// timed file copy test to guage bandwidth speeds // timed file copy test to guage bandwidth speeds
pub fn bandwidth_test(download: &str, output: &str) { pub fn bandwidth_test(host: &str) {
println!("Testing network bandwidth by downloading {}.", download); println!("Testing network bandwidth using iperf; connecting to {}.", host);
println!("{}", host);
// get start time so we can track how long it takes to complete let output = process::Command::new("iperf3")
let start_time = Utc::now(); .arg("-c")
.arg(host)
.output()
.expect("Failed to execute command");
// do the download // check that the command succeeded
assert!(output.status.success());
// get finish time // grab and print the command's results
let finish_time = Utc::now(); let results_raw = &String::from_utf8_lossy(&output.stdout);
// compute time to complete println!("{}", results_raw);
let comp_time = finish_time - start_time;
println!("{}", comp_time.num_milliseconds());
// clean up the test file
match fs::remove_file(output) {
Ok(()) => println!("Cleaning up..."),
Err(e) => println!("There was a problem during cleanup - {}", e),
}
} }

View File

@ -23,6 +23,9 @@ enum Commands {
// disk benchmarks subcommand // disk benchmarks subcommand
#[clap(name = "disk", about = "Hard drive and SSD benchmarks.")] #[clap(name = "disk", about = "Hard drive and SSD benchmarks.")]
Disk(Disk), Disk(Disk),
// games benchmarks subcommand
#[clap(name = "games", about = "Benchmark your system with games.")]
Games(Games),
// network benchmarks subcommand // network benchmarks subcommand
#[clap(name = "network", about = "Test various aspects of your network.")] #[clap(name = "network", about = "Test various aspects of your network.")]
Net(Net), Net(Net),
@ -39,7 +42,9 @@ enum CpuCommands {
// CPU stress test subcommand // CPU stress test subcommand
#[clap(name = "stress", about = "Stress test the CPU with math!")] #[clap(name = "stress", about = "Stress test the CPU with math!")]
StressTest { StressTest {
#[clap(short = 't', long, default_value_t = 0, help = "Number of threads to use; defaults to CPU's max thread count.")] #[clap(short = 'r', long, default_value_t = 5, help = "Length of time (in minutes) to run the stress test. Defaults to 5")]
runtime: u16,
#[clap(short = 't', long, default_value_t = 0, help = "Number of threads to use; defaults to CPU's max thread count. Defaults to 0 (automatic)")]
threads: usize, threads: usize,
}, },
} }
@ -55,7 +60,7 @@ enum DiskCommands {
// sequential disk read subcommand // sequential disk read subcommand
#[clap(name = "read_seq", about = "Sequential disk read speed test.")] #[clap(name = "read_seq", about = "Sequential disk read speed test.")]
ReadSeqTest { ReadSeqTest {
#[clap(short = 'f', long, default_value_t = String::from("/tmp/disk-test.tmp"))] #[clap(short = 't', long, default_value_t = String::from("/tmp/disk-test.tmp"))]
tempfile: String, tempfile: String,
#[clap(short = 's', long, default_value_t = 15)] #[clap(short = 's', long, default_value_t = 15)]
size: u8, size: u8,
@ -64,7 +69,7 @@ enum DiskCommands {
// random disk read subcommand // random disk read subcommand
#[clap(name = "read_rand", about = "Random 4K disk read speed test.")] #[clap(name = "read_rand", about = "Random 4K disk read speed test.")]
ReadRandTest { ReadRandTest {
#[clap(short = 'f', long, default_value_t = String::from("/tmp/disk-test.tmp"))] #[clap(short = 't', long, default_value_t = String::from("/tmp/disk-test.tmp"))]
tempfile: String, tempfile: String,
#[clap(short = 's', long, default_value_t = 15)] #[clap(short = 's', long, default_value_t = 15)]
size: u8, size: u8,
@ -89,6 +94,27 @@ enum DiskCommands {
}, },
} }
#[derive(Parser)]
struct Games {
#[structopt(subcommand)]
games_commands: GamesCommands,
}
#[derive(Subcommand)]
enum GamesCommands {
// Civilization 6 AI benchmark subcommand
#[clap(name = "civ6_ai", about = "Run the Civilization 6 AI benchmark via Steam.")]
Civ6AI {},
// CS:GO benchmark subcommand
#[clap(name = "csgo", about = "Run the CS:GO game benchmark via Steam.")]
CSGO {},
// Deus Ex: Mankind Divided benchmark subcommand
#[clap(name = "demd", about = "Run the Deus Ex: Mankind Divided game benchmark via Steam.")]
DEMD {},
}
#[derive(Parser)] #[derive(Parser)]
struct Net { struct Net {
#[structopt(subcommand)] #[structopt(subcommand)]
@ -97,22 +123,33 @@ struct Net {
#[derive(Subcommand)] #[derive(Subcommand)]
enum NetCommands { enum NetCommands {
// ping subcommand // bandwidth test subcommand
#[clap(name = "ping", about = "Ping a host to determine network latency.")] #[clap(name = "bandwidth", about = "Uses iperf to test network bandwidth.")]
Ping { Bandwidth {
#[clap(short = 't', long, default_value_t = String::from("8.8.8.8"))] #[clap(short = 'a', long, required = true)]
host: String, host: String,
#[clap(short = 'c', long, default_value_t = 30)]
count: u16,
}, },
// bandwidth test subcommand // jitter subcommand
#[clap(name = "bandwidth", about = "Downloads a remote file to determine network bandwidth.")] #[clap(name = "jitter", about = "Ping a host to determine network jitter.")]
Bandwidth { Jitter {
#[clap(short = 'd', long, default_value_t = String::from("https://www.bitgoblin.tech/hardware-tests/export-01.mp4"))] #[clap(short = 'a', long, default_value_t = String::from("8.8.8.8"))]
download: String, address: String,
#[clap(short = 'o', long, default_value_t = String::from("./tempfile"))] #[clap(short = 'c', long, default_value_t = 100)]
output: String, count: u16,
#[clap(short = 'i', long, default_value_t = 1000)]
interval: u16,
},
// latency subcommand
#[clap(name = "latency", about = "Ping a host to determine network latency.")]
Latency {
#[clap(short = 'a', long, default_value_t = String::from("8.8.8.8"))]
address: String,
#[clap(short = 'c', long, default_value_t = 100)]
count: u16,
#[clap(short = 'i', long, default_value_t = 1000)]
interval: u16,
}, },
} }
@ -122,7 +159,7 @@ fn main() {
// map subcommands back to the main command // map subcommands back to the main command
match &cli.command { match &cli.command {
Commands::Cpu(args) => match &args.cpu_commands { Commands::Cpu(args) => match &args.cpu_commands {
CpuCommands::StressTest { threads } => stress::cpu::cpu_stress_math(*threads), CpuCommands::StressTest { runtime, threads } => stress::cpu::cpu_stress_math(*runtime, *threads),
}, },
Commands::Disk(args) => match &args.disk_commands { Commands::Disk(args) => match &args.disk_commands {
@ -150,19 +187,31 @@ fn main() {
benchmarks::disk::disk_write_rand_test(tempfile, size); benchmarks::disk::disk_write_rand_test(tempfile, size);
} }
}, },
} },
Commands::Games(args) => match &args.games_commands {
GamesCommands::Civ6AI {} => benchmarks::games::run_civ6_ai_benchmark(),
GamesCommands::CSGO {} => benchmarks::games::run_csgo_benchmark(),
GamesCommands::DEMD {} => benchmarks::games::run_demd_benchmark(),
},
Commands::Net(args) => match &args.net_commands { Commands::Net(args) => match &args.net_commands {
NetCommands::Ping { host, count } => { NetCommands::Bandwidth { host } => {
for i in 0..cli.loopcount { for i in 0..cli.loopcount {
println!("Test run number {}.", i + 1); println!("Test run number {}.", i + 1);
benchmarks::network::ping_host(host, count); benchmarks::network::bandwidth_test(host);
} }
}, },
NetCommands::Bandwidth { download, output } => { NetCommands::Jitter { address, count, interval } => {
for i in 0..cli.loopcount { for i in 0..cli.loopcount {
println!("Test run number {}.", i + 1); println!("Test run number {}.", i + 1);
benchmarks::network::bandwidth_test(download, output); benchmarks::network::jitter_test(address, count, interval);
}
},
NetCommands::Latency { address, count, interval } => {
for i in 0..cli.loopcount {
println!("Test run number {}.", i + 1);
benchmarks::network::latency_test(address, count, interval);
} }
}, },
}, },

View File

@ -1,28 +1,32 @@
use std::thread; use std::{thread, time};
use std::process::exit;
use sysinfo::{System,SystemExt}; use sysinfo::{System,SystemExt};
pub fn cpu_stress_math(threads: usize) { pub fn cpu_stress_math(runtime: u16, threads: usize) {
// fetch system information // fetch system information
let mut sys = System::new_all(); let mut sys = System::new_all();
sys.refresh_all(); sys.refresh_all();
let num_cpus = sys.cpus().len(); let num_cpus = sys.cpus().len();
let mut num_threads = threads; let mut num_threads = threads;
if num_threads == 0 { if num_threads == 0 {
println!("Number of threads not specified, defaulting to CPU's thread count of {}.", num_cpus); println!("Number of threads not specified, defaulting to CPU's thread count of {}.", num_cpus);
num_threads = num_cpus; num_threads = num_cpus;
} else { } else {
println!("Using specified thread count of {}", num_threads); println!("Using specified thread count of {}", num_threads);
} }
for i in 1..num_threads { for i in 0..num_threads {
println!("Spawning thread number {}", i); println!("Spawning thread number {}", i + 1);
thread::spawn (|| { thread::spawn (|| {
worker(); worker();
}); });
} }
println!("Using main as last thread");
worker(); println!("Sleeping main thread for the allotted runtime of {} minute(s).", runtime);
let duration = time::Duration::from_secs((runtime * 60).into());
thread::sleep(duration);
exit(0);
} }
fn worker() { fn worker() {