BitGoblin/hardware-tests
1
0
Fork 0
Code Issues 7 Pull Requests Projects Releases 11 Wiki Activity

Compare commits

base: BitGoblin:master
Branches Tags
BitGoblin:master
BitGoblin:rust
BitGoblin:go
BitGoblin:v0.4.0
BitGoblin:v0.3.3
BitGoblin:v0.3.2
BitGoblin:v0.3.1
BitGoblin:v0.3.0
BitGoblin:v0.2.4
BitGoblin:v0.2.3
BitGoblin:v0.2.2
BitGoblin:v0.2.1
BitGoblin:v0.2.0
BitGoblin:v0.1.0
..
compare: BitGoblin:v0.3.0
Branches Tags
BitGoblin:master
BitGoblin:rust
BitGoblin:go
BitGoblin:v0.4.0
BitGoblin:v0.3.3
BitGoblin:v0.3.2
BitGoblin:v0.3.1
BitGoblin:v0.3.0
BitGoblin:v0.2.4
BitGoblin:v0.2.3
BitGoblin:v0.2.2
BitGoblin:v0.2.1
BitGoblin:v0.2.0
BitGoblin:v0.1.0

No commits in common. "master" and "v0.3.0" have entirely different histories.
master ... v0.3.0

7 changed files with 66 additions and 199 deletions
Show Stats Expand all files Collapse all files

8
Cargo.toml
View File

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

3
README.md
View File

@ -13,8 +13,7 @@ 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.
### Runtime requirements:
* `disk` - requires `fio`.
* `network bandwidth` - requires `iperf3`
* disk - requires `fio`.
## Building

36
src/benchmarks/games.rs
View File

@ -1,36 +0,0 @@
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));
}

1
src/benchmarks/mod.rs
View File

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

86
src/benchmarks/network.rs
View File

@ -1,61 +1,16 @@
use std::process;
use chrono::prelude::*;
use std::{fs,process};
use crate::text;
// ping a host
pub fn latency_test(address: &str, count: &u16, interval: &u16) {
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;
pub fn ping_host(host: &str, count: &u16) {
println!("Pinging host {}, {} times.", host, count);
// 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()
.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))
.arg(host)
.arg(format!("-c {}", count))
.output()
.expect("Failed to execute command");
@ -71,20 +26,23 @@ pub fn jitter_test(address: &str, count: &u16, interval: &u16) {
}
// timed file copy test to guage bandwidth speeds
pub fn bandwidth_test(host: &str) {
println!("Testing network bandwidth using iperf; connecting to {}.", host);
println!("{}", host);
pub fn bandwidth_test(download: &str, output: &str) {
println!("Testing network bandwidth by downloading {}.", download);
let output = process::Command::new("iperf3")
.arg("-c")
.arg(host)
.output()
.expect("Failed to execute command");
// get start time so we can track how long it takes to complete
let start_time = Utc::now();
// check that the command succeeded
assert!(output.status.success());
// do the download
// grab and print the command's results
let results_raw = &String::from_utf8_lossy(&output.stdout);
println!("{}", results_raw);
// get finish time
let finish_time = Utc::now();
// compute time to complete
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),
}
}

93
src/main.rs
View File

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

16
src/stress/cpu.rs
View File

@ -1,8 +1,7 @@
use std::{thread, time};
use std::process::exit;
use std::thread;
use sysinfo::{System,SystemExt};
pub fn cpu_stress_math(runtime: u16, threads: usize) {
pub fn cpu_stress_math(threads: usize) {
// fetch system information
let mut sys = System::new_all();
sys.refresh_all();
@ -16,17 +15,14 @@ pub fn cpu_stress_math(runtime: u16, threads: usize) {
println!("Using specified thread count of {}", num_threads);
}
for i in 0..num_threads {
println!("Spawning thread number {}", i + 1);
for i in 1..num_threads {
println!("Spawning thread number {}", i);
thread::spawn (|| {
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);
println!("Using main as last thread");
worker();
}
fn worker() {