use futures::prelude::*;
use std::time::Duration;
mod sysinfo;
#[cfg(target_os = "linux")]
mod sysinfo_linux;
pub use sysinfo::{
benchmark_cpu, benchmark_cpu_parallelism, benchmark_disk_random_writes,
benchmark_disk_sequential_writes, benchmark_memory, benchmark_sr25519_verify, gather_hwbench,
gather_sysinfo, serialize_throughput, serialize_throughput_option, Metric, Requirement,
Requirements, Throughput,
};
pub const TARGET_OS: &str = include_str!(concat!(env!("OUT_DIR"), "/target_os.txt"));
pub const TARGET_ARCH: &str = include_str!(concat!(env!("OUT_DIR"), "/target_arch.txt"));
pub const TARGET_ENV: &str = include_str!(concat!(env!("OUT_DIR"), "/target_env.txt"));
#[derive(Clone, Debug, serde::Serialize)]
pub struct HwBench {
#[serde(serialize_with = "serialize_throughput")]
pub cpu_hashrate_score: Throughput,
#[serde(serialize_with = "serialize_throughput")]
pub parallel_cpu_hashrate_score: Throughput,
pub parallel_cpu_cores: usize,
#[serde(serialize_with = "serialize_throughput")]
pub memory_memcpy_score: Throughput,
#[serde(
serialize_with = "serialize_throughput_option",
skip_serializing_if = "Option::is_none"
)]
pub disk_sequential_write_score: Option<Throughput>,
#[serde(
serialize_with = "serialize_throughput_option",
skip_serializing_if = "Option::is_none"
)]
pub disk_random_write_score: Option<Throughput>,
}
#[derive(Copy, Clone, Debug)]
pub enum ExecutionLimit {
MaxDuration(Duration),
MaxIterations(usize),
Both { max_iterations: usize, max_duration: Duration },
}
impl ExecutionLimit {
pub fn from_secs_f32(secs: f32) -> Self {
Self::MaxDuration(Duration::from_secs_f32(secs))
}
pub fn max_duration(&self) -> Duration {
match self {
Self::MaxDuration(d) => *d,
Self::Both { max_duration, .. } => *max_duration,
_ => Duration::from_secs(u64::MAX),
}
}
pub fn max_iterations(&self) -> usize {
match self {
Self::MaxIterations(d) => *d,
Self::Both { max_iterations, .. } => *max_iterations,
_ => usize::MAX,
}
}
}
pub fn print_sysinfo(sysinfo: &sc_telemetry::SysInfo) {
log::info!("๐ป Operating system: {}", TARGET_OS);
log::info!("๐ป CPU architecture: {}", TARGET_ARCH);
if !TARGET_ENV.is_empty() {
log::info!("๐ป Target environment: {}", TARGET_ENV);
}
if let Some(ref cpu) = sysinfo.cpu {
log::info!("๐ป CPU: {}", cpu);
}
if let Some(core_count) = sysinfo.core_count {
log::info!("๐ป CPU cores: {}", core_count);
}
if let Some(memory) = sysinfo.memory {
log::info!("๐ป Memory: {}MB", memory / (1024 * 1024));
}
if let Some(ref linux_kernel) = sysinfo.linux_kernel {
log::info!("๐ป Kernel: {}", linux_kernel);
}
if let Some(ref linux_distro) = sysinfo.linux_distro {
log::info!("๐ป Linux distribution: {}", linux_distro);
}
if let Some(is_virtual_machine) = sysinfo.is_virtual_machine {
log::info!("๐ป Virtual machine: {}", if is_virtual_machine { "yes" } else { "no" });
}
}
pub fn print_hwbench(hwbench: &HwBench) {
log::info!(
"๐ CPU single core score: {}, parallelism score: {} with expected cores: {}",
hwbench.cpu_hashrate_score,
hwbench.parallel_cpu_hashrate_score,
hwbench.parallel_cpu_cores,
);
log::info!("๐ Memory score: {}", hwbench.memory_memcpy_score);
if let Some(score) = hwbench.disk_sequential_write_score {
log::info!("๐ Disk score (seq. writes): {}", score);
}
if let Some(score) = hwbench.disk_random_write_score {
log::info!("๐ Disk score (rand. writes): {}", score);
}
}
pub fn initialize_hwbench_telemetry(
telemetry_handle: sc_telemetry::TelemetryHandle,
hwbench: HwBench,
) -> impl std::future::Future<Output = ()> {
let mut connect_stream = telemetry_handle.on_connect_stream();
async move {
let payload = serde_json::to_value(&hwbench)
.expect("the `HwBench` can always be serialized into a JSON object; qed");
let mut payload = match payload {
serde_json::Value::Object(map) => map,
_ => unreachable!("the `HwBench` always serializes into a JSON object; qed"),
};
payload.insert("msg".into(), "sysinfo.hwbench".into());
while connect_stream.next().await.is_some() {
telemetry_handle.send_telemetry(sc_telemetry::SUBSTRATE_INFO, payload.clone());
}
}
}