#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]

	fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {

		write!(formatter, "Failed checks: ")?;

		for failure in &self.0 {

			write!(

				formatter,

				"{}(expected: {}, found: {}), ",

				failure.metric.name(),

				failure.expected,

				failure.found

			)?

		Ok(())

	}

	pub fn category(&self) -> &'static str {

		match self {

			Self::Sr25519Verify | Self::Blake2256 => "CPU",

			Self::MemCopy => "Memory",

			Self::DiskSeqWrite | Self::DiskRndWrite => "Disk",

	}

	pub fn name(&self) -> &'static str {

		match self {

			Self::Sr25519Verify => "SR25519-Verify",

			Self::Blake2256 => "BLAKE2-256",

			Self::MemCopy => "Copy",

			Self::DiskSeqWrite => "Seq Write",

			Self::DiskRndWrite => "Rnd Write",

	}

	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

		f.write_str(match self {

			Unit::GiBs => "GiBs",

			Unit::MiBs => "MiBs",

			Unit::KiBs => "KiBs",

	}

	pub fn from_kibs(kibs: f64) -> Throughput {

		Throughput(kibs * KIBIBYTE)

	}

	pub fn from_mibs(mibs: f64) -> Throughput {

		Throughput(mibs * MEBIBYTE)

	}

	pub fn from_gibs(gibs: f64) -> Throughput {

		Throughput(gibs * GIBIBYTE)

	}

	pub fn as_bytes(&self) -> f64 {

		self.0

	}

	pub fn as_kibs(&self) -> f64 {

		self.0 / KIBIBYTE

	}

	pub fn as_mibs(&self) -> f64 {

		self.0 / MEBIBYTE

	}

	pub fn as_gibs(&self) -> f64 {

		self.0 / GIBIBYTE

	}

	pub fn normalize(&self) -> (f64, Unit) {

		let bs = self.0;

		if bs >= GIBIBYTE {

			(self.as_gibs(), Unit::GiBs)

		} else if bs >= MEBIBYTE {

			(self.as_mibs(), Unit::MiBs)

			(self.as_kibs(), Unit::KiBs)

	}

	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

		let (value, unit) = self.normalize();

		write!(f, "{:.2?} {}", value, unit)

	}

pub fn serialize_throughput<S>(throughput: &Throughput, serializer: S) -> Result<S::Ok, S::Error>

where

	S: Serializer,

{

	serializer.serialize_u64(throughput.as_mibs() as u64)

}

pub fn serialize_throughput_option<S>(

	maybe_throughput: &Option<Throughput>,

	serializer: S,

) -> Result<S::Ok, S::Error>

where

	S: Serializer,

{

	if let Some(throughput) = maybe_throughput {

		return serializer.serialize_some(&(throughput.as_mibs() as u64))

	}

	serializer.serialize_none()

}

fn serialize_throughput_as_f64<S>(throughput: &Throughput, serializer: S) -> Result<S::Ok, S::Error>

where

	S: Serializer,

{

	serializer.serialize_f64(throughput.as_mibs())

}

	fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {

		formatter.write_str("A value that is a f64.")

	}

	fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>

	where

		E: serde::de::Error,

	{

		Ok(Throughput::from_mibs(value))

	}

fn deserialize_throughput<'de, D>(deserializer: D) -> Result<Throughput, D::Error>

where

	D: Deserializer<'de>,

{

	Ok(deserializer.deserialize_f64(ThroughputVisitor))?

}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]

#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]

pub(crate) fn benchmark<E>(

	name: &str,

	size: usize,

	max_iterations: usize,

	max_duration: Duration,

	mut run: impl FnMut() -> Result<(), E>,

) -> Result<Throughput, E> {

	// Run the benchmark once as a warmup to get the code into the L1 cache.

	run()?;

	let timestamp = Instant::now();

	let mut elapsed = Duration::default();

	let mut count = 0;

	for _ in 0..max_iterations {

		run()?;

		count += 1;

		elapsed = timestamp.elapsed();

		if elapsed >= max_duration {

			break

		}

	let score = Throughput::from_kibs((size * count) as f64 / (elapsed.as_secs_f64() * 1024.0));

	log::trace!(

		"Calculated {} of {} in {} iterations in {}ms",

		name,

		score,

		count,

		elapsed.as_millis()

	Ok(score)

}

pub fn gather_sysinfo() -> SysInfo {

	#[allow(unused_mut)]

	let mut sysinfo = SysInfo {

		cpu: None,

		memory: None,

		core_count: None,

		linux_kernel: None,

		linux_distro: None,

		is_virtual_machine: None,

	};

	#[cfg(target_os = "linux")]

	crate::sysinfo_linux::gather_linux_sysinfo(&mut sysinfo);

	sysinfo

}

fn clobber_slice<T>(slice: &mut [T]) {

	assert!(!slice.is_empty());

	unsafe {

		let value = std::ptr::read_volatile(slice.as_ptr());

		std::ptr::write_volatile(slice.as_mut_ptr(), value);

	}

}

fn clobber_value<T>(input: &mut T) {

	// Look into `clobber_slice` for a comment.

	unsafe {

		let value = std::ptr::read_volatile(input);

		std::ptr::write_volatile(input, value);

	}

}

pub fn benchmark_cpu(limit: ExecutionLimit) -> Throughput {

	let mut buffer = Vec::new();

	buffer.resize(SIZE, 0x66);

	let mut hash = Default::default();

	let run = || -> Result<(), ()> {

		clobber_slice(&mut buffer);

		hash = sp_crypto_hashing::blake2_256(&buffer);

		clobber_slice(&mut hash);

		Ok(())

	};

	benchmark("CPU score", SIZE, limit.max_iterations(), limit.max_duration(), run)

		.expect("benchmark cannot fail; qed")

}

pub fn benchmark_memory(limit: ExecutionLimit) -> Throughput {

	let mut src = Vec::new();

	let mut dst = Vec::new();

	// Prefault the pages; we want to measure the memory bandwidth,

	// not how fast the kernel can supply us with fresh memory pages.

	src.resize(SIZE, 0x66);

	dst.resize(SIZE, 0x77);

	let run = || -> Result<(), ()> {

		clobber_slice(&mut src);

		clobber_slice(&mut dst);

		// SAFETY: Both vectors are of the same type and of the same size,

		//         so copying data between them is safe.

		unsafe {

			// We use `memcpy` directly here since `copy_from_slice` isn't actually

			// guaranteed to be turned into a `memcpy`.

			libc::memcpy(dst.as_mut_ptr().cast(), src.as_ptr().cast(), SIZE);

		}

		clobber_slice(&mut dst);

		clobber_slice(&mut src);

		Ok(())

	};

	benchmark("memory score", SIZE, limit.max_iterations(), limit.max_duration(), run)

		.expect("benchmark cannot fail; qed")

}

	fn drop(&mut self) {

		let _ = self.fp.take();

		if let Err(error) = std::fs::remove_file(&self.path) {

			log::warn!("Failed to remove the file used for the disk benchmark: {}", error);

		}

	}

	fn deref(&self) -> &Self::Target {

		self.fp.as_ref().expect("`fp` is None only during `drop`")

	}

	fn deref_mut(&mut self) -> &mut Self::Target {

		self.fp.as_mut().expect("`fp` is None only during `drop`")

	}

fn rng() -> rand_pcg::Pcg64 {

	rand_pcg::Pcg64::new(0xcafef00dd15ea5e5, 0xa02bdbf7bb3c0a7ac28fa16a64abf96)

}

fn random_data(size: usize) -> Vec<u8> {

	let mut buffer = Vec::new();

	buffer.resize(size, 0);

	rng().fill(&mut buffer[..]);

	buffer

}

pub fn benchmark_disk_sequential_writes(

	limit: ExecutionLimit,

	directory: &Path,

) -> Result<Throughput, String> {

	let buffer = random_data(SIZE);

	let path = directory.join(".disk_bench_seq_wr.tmp");

	let fp =

		File::create(&path).map_err(|error| format!("failed to create a test file: {}", error))?;

	let mut fp = TemporaryFile { fp: Some(fp), path };

	fp.sync_all()

		.map_err(|error| format!("failed to fsync the test file: {}", error))?;

	let run = || {

		// Just dump everything to the disk in one go.

		fp.write_all(&buffer)

			.map_err(|error| format!("failed to write to the test file: {}", error))?;

		fp.sync_all()

			.map_err(|error| format!("failed to fsync the test file: {}", error))?;

		fp.seek(SeekFrom::Start(0))

			.map_err(|error| format!("failed to seek to the start of the test file: {}", error))?;

		Ok(())

	};

	benchmark(

		"disk sequential write score",

		SIZE,

		limit.max_iterations(),

		limit.max_duration(),

		run,

	)

}

pub fn benchmark_disk_random_writes(

	limit: ExecutionLimit,

	directory: &Path,

) -> Result<Throughput, String> {

	let buffer = random_data(SIZE);

	let path = directory.join(".disk_bench_rand_wr.tmp");

	let fp =

		File::create(&path).map_err(|error| format!("failed to create a test file: {}", error))?;

	let mut fp = TemporaryFile { fp: Some(fp), path };

	// Since we want to test random writes we need an existing file

	// through which we can seek, so here we just populate it with some data.

	fp.write_all(&buffer)

		.map_err(|error| format!("failed to write to the test file: {}", error))?;

	fp.sync_all()

		.map_err(|error| format!("failed to fsync the test file: {}", error))?;

	let mut positions = Vec::with_capacity(SIZE / 4096);

	{

		let mut position = 0;

		while position < SIZE {

			positions.push(position);

			position += 4096;

		}

	positions.shuffle(&mut rng());

	let run = || {

		for &position in &positions {

			fp.seek(SeekFrom::Start(position as u64))

				.map_err(|error| format!("failed to seek in the test file: {}", error))?;

			let chunk = &buffer[position..position + 2048];

			fp.write_all(&chunk)

				.map_err(|error| format!("failed to write to the test file: {}", error))?;

		fp.sync_all()

			.map_err(|error| format!("failed to fsync the test file: {}", error))?;

		Ok(())

	};

	benchmark(

		"disk random write score",

		SIZE / 2,

		limit.max_iterations(),

		limit.max_duration(),

		run,

	)

}

pub fn benchmark_sr25519_verify(limit: ExecutionLimit) -> Throughput {

	let pair = sr25519::Pair::from_string("//Alice", None).unwrap();

	let mut rng = rng();

	let mut msgs = Vec::new();

	let mut sigs = Vec::new();

	for _ in 0..ITERATION_SIZE {

		let mut msg = vec![0u8; INPUT_SIZE];

		rng.fill_bytes(&mut msg[..]);

		sigs.push(pair.sign(&msg));

		msgs.push(msg);

	}

	let run = || -> Result<(), String> {

		for (sig, msg) in sigs.iter().zip(msgs.iter()) {

			let mut ok = sr25519_verify(&sig, &msg[..], &pair.public());

			clobber_value(&mut ok);

		}

		Ok(())

	};

	benchmark(

		"sr25519 verification score",

		INPUT_SIZE * ITERATION_SIZE,

		limit.max_iterations(),

		limit.max_duration(),

		run,

	)

	.expect("sr25519 verification cannot fail; qed")

}

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),

		memory_memcpy_score: benchmark_memory(DEFAULT_MEMORY_EXECUTION_LIMIT),

		disk_sequential_write_score: None,

		disk_random_write_score: None,

	};

	if let Some(scratch_directory) = scratch_directory {

			match benchmark_disk_sequential_writes(DEFAULT_DISK_EXECUTION_LIMIT, scratch_directory)

				Ok(score) => Some(score),

				Err(error) => {

					log::warn!("Failed to run the sequential write disk benchmark: {}", error);

					None

			match benchmark_disk_random_writes(DEFAULT_DISK_EXECUTION_LIMIT, scratch_directory) {

				Ok(score) => Some(score),

				Err(error) => {

					log::warn!("Failed to run the random write disk benchmark: {}", error);

					None

	}

	hwbench

}

	pub fn check_hardware(&self, hwbench: &HwBench) -> Result<(), CheckFailures> {

		let mut failures = Vec::new();

		for requirement in self.0.iter() {

			match requirement.metric {

					if requirement.minimum > hwbench.cpu_hashrate_score {

						failures.push(CheckFailure {

							metric: requirement.metric,

							expected: requirement.minimum,

							found: hwbench.cpu_hashrate_score,

						});

					},

					if requirement.minimum > hwbench.memory_memcpy_score {

						failures.push(CheckFailure {

							metric: requirement.metric,

							expected: requirement.minimum,

							found: hwbench.memory_memcpy_score,

						});

					},

					if let Some(score) = hwbench.disk_sequential_write_score {

						if requirement.minimum > score {

							failures.push(CheckFailure {

								metric: requirement.metric,

								expected: requirement.minimum,

								found: score,

							});

						}

					},

					if let Some(score) = hwbench.disk_random_write_score {

						if requirement.minimum > score {

							failures.push(CheckFailure {

								metric: requirement.metric,

								expected: requirement.minimum,

								found: score,

							});

						}

					},

				Metric::Sr25519Verify => {},

		if failures.is_empty() {

			Ok(())

			Err(failures.into())

	}