Move Throughput into sc-sysinfo

client/sysinfo/src/lib.rs

@@ -28,7 +28,7 @@ mod sysinfo_linux;
 
 pub use sysinfo::{
 	benchmark_cpu, benchmark_disk_random_writes, benchmark_disk_sequential_writes,
-	benchmark_memory, benchmark_sr25519_verify, gather_hwbench, gather_sysinfo,
+	benchmark_memory, benchmark_sr25519_verify, gather_hwbench, gather_sysinfo, Throughput,
 };
 
 /// The operating system part of the current target triplet.
@@ -44,13 +44,13 @@ pub const TARGET_ENV: &str = include_str!(concat!(env!("OUT_DIR"), "/target_env.
 #[derive(Clone, Debug, serde::Serialize)]
 pub struct HwBench {
 	/// The CPU speed, as measured in how many MB/s it can hash using the BLAKE2b-256 hash.
-	pub cpu_hashrate_score: u64,
+	pub cpu_hashrate_score: Throughput,
 	/// Memory bandwidth in MB/s, calculated by measuring the throughput of `memcpy`.
-	pub memory_memcpy_score: u64,
+	pub memory_memcpy_score: Throughput,
 	/// Sequential disk write speed in MB/s.
-	pub disk_sequential_write_score: Option<u64>,
+	pub disk_sequential_write_score: Option<Throughput>,
 	/// Random disk write speed in MB/s.
-	pub disk_random_write_score: Option<u64>,
+	pub disk_random_write_score: Option<Throughput>,
 }
 
 /// Limit the execution time of a benchmark.

client/sysinfo/src/sysinfo.rs

@@ -21,9 +21,10 @@ use crate::{ExecutionLimit, HwBench};
 use sc_telemetry::SysInfo;
 use sp_core::{sr25519, Pair};
 use sp_io::crypto::sr25519_verify;
-use sp_std::prelude::*;
+use sp_std::{fmt, prelude::*};
 
 use rand::{seq::SliceRandom, Rng, RngCore};
+use serde::{Deserialize, Serialize};
 use std::{
 	fs::File,
 	io::{Seek, SeekFrom, Write},
@@ -32,6 +33,77 @@ use std::{
 	time::{Duration, Instant},
 };
 
+/// Throughput as measured in bytes per second.
+#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]
+pub enum Throughput {
+	/// KiB/s
+	KiBs(f64),
+	/// MiB/s
+	MiBs(f64),
+	/// GiB/s
+	GiBs(f64),
+}
+
+const KIBIBYTE: f64 = 1024.0;
+
+impl Throughput {
+	/// The unit of the metric.
+	pub fn unit(&self) -> &'static str {
+		match self {
+			Self::KiBs(_) => "KiB/s",
+			Self::MiBs(_) => "MiB/s",
+			Self::GiBs(_) => "GiB/s",
+		}
+	}
+
+	/// [`Self`] as number of byte/s.
+	pub fn to_bs(&self) -> f64 {
+		self.to_kibs() * KIBIBYTE
+	}
+
+	/// [`Self`] as number of kibibyte/s.
+	pub fn to_kibs(&self) -> f64 {
+		self.to_mibs() * KIBIBYTE
+	}
+
+	/// [`Self`] as number of mebibyte/s.
+	pub fn to_mibs(&self) -> f64 {
+		self.to_gibs() * KIBIBYTE
+	}
+
+	/// [`Self`] as number of gibibyte/s.
+	pub fn to_gibs(&self) -> f64 {
+		match self {
+			Self::KiBs(k) => *k / (KIBIBYTE * KIBIBYTE),
+			Self::MiBs(m) => *m / KIBIBYTE,
+			Self::GiBs(g) => *g,
+		}
+	}
+
+	/// Normalizes [`Self`] to use the larges unit possible.
+	pub fn normalize(&self) -> Self {
+		let bs = self.to_bs();
+
+		if bs >= KIBIBYTE * KIBIBYTE * KIBIBYTE {
+			Self::GiBs(self.to_gibs())
+		} else if bs >= KIBIBYTE * KIBIBYTE {
+			Self::MiBs(self.to_mibs())
+		} else {
+			Self::KiBs(self.to_kibs())
+		}
+	}
+}
+
+impl fmt::Display for Throughput {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let normalized = self.normalize();
+		match normalized {
+			Self::KiBs(s) | Self::MiBs(s) | Self::GiBs(s) =>
+				write!(f, "{:.2?} {}", s, normalized.unit()),
+		}
+	}
+}
+
 #[inline(always)]
 pub(crate) fn benchmark<E>(
 	name: &str,
@@ -121,7 +193,7 @@ pub const DEFAULT_CPU_EXECUTION_LIMIT: ExecutionLimit =
 	ExecutionLimit::Both { max_iterations: 4 * 1024, max_duration: Duration::from_millis(100) };
 
 // This benchmarks the CPU speed as measured by calculating BLAKE2b-256 hashes, in MB/s.
-pub fn benchmark_cpu(limit: ExecutionLimit) -> f64 {
+pub fn benchmark_cpu(limit: ExecutionLimit) -> Throughput {
 	// In general the results of this benchmark are somewhat sensitive to how much
 	// data we hash at the time. The smaller this is the *less* MB/s we can hash,
 	// the bigger this is the *more* MB/s we can hash, up until a certain point
@@ -148,8 +220,10 @@ pub fn benchmark_cpu(limit: ExecutionLimit) -> f64 {
 		Ok(())
 	};
 
-	benchmark("CPU score", SIZE, limit.max_iterations(), limit.max_duration(), run)
-		.expect("benchmark cannot fail; qed")
+	Throughput::MiBs(
+		benchmark("CPU score", SIZE, limit.max_iterations(), limit.max_duration(), run)
+			.expect("benchmark cannot fail; qed"),
+	)
 }
 
 /// A default [`ExecutionLimit`] that can be used to call [`benchmark_memory`].
@@ -161,7 +235,7 @@ pub const DEFAULT_MEMORY_EXECUTION_LIMIT: ExecutionLimit =
 // It doesn't technically measure the absolute maximum memory bandwidth available,
 // but that's fine, because real code most of the time isn't optimized to take
 // advantage of the full memory bandwidth either.
-pub fn benchmark_memory(limit: ExecutionLimit) -> f64 {
+pub fn benchmark_memory(limit: ExecutionLimit) -> Throughput {
 	// Ideally this should be at least as big as the CPU's L3 cache,
 	// and it should be big enough so that the `memcpy` takes enough
 	// time to be actually measurable.
@@ -196,8 +270,10 @@ pub fn benchmark_memory(limit: ExecutionLimit) -> f64 {
 		Ok(())
 	};
 
-	benchmark("memory score", SIZE, limit.max_iterations(), limit.max_duration(), run)
-		.expect("benchmark cannot fail; qed")
+	Throughput::MiBs(
+		benchmark("memory score", SIZE, limit.max_iterations(), limit.max_duration(), run)
+			.expect("benchmark cannot fail; qed"),
+	)
 }
 
 struct TemporaryFile {
@@ -402,8 +478,8 @@ pub fn benchmark_sr25519_verify(limit: ExecutionLimit) -> f64 {
 pub fn gather_hwbench(scratch_directory: Option<&Path>) -> HwBench {
 	#[allow(unused_mut)]
 	let mut hwbench = HwBench {
-		cpu_hashrate_score: benchmark_cpu(DEFAULT_CPU_EXECUTION_LIMIT) as u64,
-		memory_memcpy_score: benchmark_memory(DEFAULT_MEMORY_EXECUTION_LIMIT) as u64,
+		cpu_hashrate_score: benchmark_cpu(DEFAULT_CPU_EXECUTION_LIMIT),
+		memory_memcpy_score: benchmark_memory(DEFAULT_MEMORY_EXECUTION_LIMIT),
 		disk_sequential_write_score: None,
 		disk_random_write_score: None,
 	};
@@ -412,7 +488,7 @@ pub fn gather_hwbench(scratch_directory: Option<&Path>) -> HwBench {
 		hwbench.disk_sequential_write_score =
 			match benchmark_disk_sequential_writes(DEFAULT_DISK_EXECUTION_LIMIT, scratch_directory)
 			{
-				Ok(score) => Some(score as u64),
+				Ok(score) => Some(Throughput::MiBs(score)),
 				Err(error) => {
 					log::warn!("Failed to run the sequential write disk benchmark: {}", error);
 					None
@@ -421,7 +497,7 @@ pub fn gather_hwbench(scratch_directory: Option<&Path>) -> HwBench {
 
 		hwbench.disk_random_write_score =
 			match benchmark_disk_random_writes(DEFAULT_DISK_EXECUTION_LIMIT, scratch_directory) {
-				Ok(score) => Some(score as u64),
+				Ok(score) => Some(Throughput::MiBs(score)),
 				Err(error) => {
 					log::warn!("Failed to run the random write disk benchmark: {}", error);
 					None
@@ -450,12 +526,12 @@ mod tests {
 
 	#[test]
 	fn test_benchmark_cpu() {
-		assert!(benchmark_cpu(DEFAULT_CPU_EXECUTION_LIMIT) > 0.0);
+		assert!(benchmark_cpu(DEFAULT_CPU_EXECUTION_LIMIT).to_bs() > 0.0);
 	}
 
 	#[test]
 	fn test_benchmark_memory() {
-		assert!(benchmark_memory(DEFAULT_MEMORY_EXECUTION_LIMIT) > 0.0);
+		assert!(benchmark_memory(DEFAULT_MEMORY_EXECUTION_LIMIT).to_bs() > 0.0);
 	}
 
 	#[test]

utils/frame/benchmarking-cli/src/machine/hardware.rs

@@ -18,8 +18,8 @@
 //! Contains types to define hardware requirements.
 
 use lazy_static::lazy_static;
+use sc_sysinfo::Throughput;
 use serde::{Deserialize, Serialize};
-use std::fmt;
 
 lazy_static! {
 	/// The hardware requirements as measured on reference hardware.
@@ -65,17 +65,6 @@ pub enum Metric {
 	DiskRndWrite,
 }
 
-/// Throughput as measured in bytes per second.
-#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]
-pub enum Throughput {
-	/// KiB/s
-	KiBs(f64),
-	/// MiB/s
-	MiBs(f64),
-	/// GiB/s
-	GiBs(f64),
-}
-
 impl Metric {
 	/// The category of the metric.
 	pub fn category(&self) -> &'static str {
@@ -98,66 +87,6 @@ impl Metric {
 	}
 }
 
-const KIBIBYTE: f64 = 1024.0;
-
-impl Throughput {
-	/// The unit of the metric.
-	pub fn unit(&self) -> &'static str {
-		match self {
-			Self::KiBs(_) => "KiB/s",
-			Self::MiBs(_) => "MiB/s",
-			Self::GiBs(_) => "GiB/s",
-		}
-	}
-
-	/// [`Self`] as number of byte/s.
-	pub fn to_bs(&self) -> f64 {
-		self.to_kibs() * KIBIBYTE
-	}
-
-	/// [`Self`] as number of kibibyte/s.
-	pub fn to_kibs(&self) -> f64 {
-		self.to_mibs() * KIBIBYTE
-	}
-
-	/// [`Self`] as number of mebibyte/s.
-	pub fn to_mibs(&self) -> f64 {
-		self.to_gibs() * KIBIBYTE
-	}
-
-	/// [`Self`] as number of gibibyte/s.
-	pub fn to_gibs(&self) -> f64 {
-		match self {
-			Self::KiBs(k) => *k / (KIBIBYTE * KIBIBYTE),
-			Self::MiBs(m) => *m / KIBIBYTE,
-			Self::GiBs(g) => *g,
-		}
-	}
-
-	/// Normalizes [`Self`] to use the larges unit possible.
-	pub fn normalize(&self) -> Self {
-		let bs = self.to_bs();
-
-		if bs >= KIBIBYTE * KIBIBYTE * KIBIBYTE {
-			Self::GiBs(self.to_gibs())
-		} else if bs >= KIBIBYTE * KIBIBYTE {
-			Self::MiBs(self.to_mibs())
-		} else {
-			Self::KiBs(self.to_kibs())
-		}
-	}
-}
-
-impl fmt::Display for Throughput {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		let normalized = self.normalize();
-		match normalized {
-			Self::KiBs(s) | Self::MiBs(s) | Self::GiBs(s) =>
-				write!(f, "{:.2?} {}", s, normalized.unit()),
-		}
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;

utils/frame/benchmarking-cli/src/machine/mod.rs

@@ -30,11 +30,11 @@ use sc_cli::{CliConfiguration, Result, SharedParams};
 use sc_service::Configuration;
 use sc_sysinfo::{
 	benchmark_cpu, benchmark_disk_random_writes, benchmark_disk_sequential_writes,
-	benchmark_memory, benchmark_sr25519_verify, ExecutionLimit,
+	benchmark_memory, benchmark_sr25519_verify, ExecutionLimit, Throughput,
 };
 
 use crate::shared::check_build_profile;
-pub use hardware::{Metric, Requirement, Requirements, Throughput, SUBSTRATE_REFERENCE_HARDWARE};
+pub use hardware::{Metric, Requirement, Requirements, SUBSTRATE_REFERENCE_HARDWARE};
 
 /// Command to benchmark the hardware.
 ///
@@ -128,6 +128,7 @@ impl MachineCmd {
 	/// Benchmarks a specific metric of the hardware and judges the resulting score.
 	fn run_benchmark(&self, requirement: &Requirement, dir: &Path) -> Result<BenchResult> {
 		// Dispatch the concrete function from `sc-sysinfo`.
+
 		let score = self.measure(&requirement.metric, dir)?;
 		let rel_score = score.to_bs() / requirement.minimum.to_bs();
 
@@ -147,9 +148,9 @@ impl MachineCmd {
 		let memory_limit = ExecutionLimit::from_secs_f32(self.memory_duration);
 
 		let score = match metric {
-			Metric::Blake2256 => Throughput::MiBs(benchmark_cpu(hash_limit) as f64),
+			Metric::Blake2256 => benchmark_cpu(hash_limit),
 			Metric::Sr25519Verify => Throughput::MiBs(benchmark_sr25519_verify(verify_limit)),
-			Metric::MemCopy => Throughput::MiBs(benchmark_memory(memory_limit) as f64),
+			Metric::MemCopy => benchmark_memory(memory_limit),
 			Metric::DiskSeqWrite =>
 				Throughput::MiBs(benchmark_disk_sequential_writes(disk_limit, dir)? as f64),
 			Metric::DiskRndWrite =>