path: root/bzipper_benchmarks/src/main.rs

// Copyright 2024 Gabriel Bjørnager Jensen.

use rand::random;

// Bincode uses so much memory that it crashes if
// we set `VALUE_COUNT` too high.
const VALUE_COUNT: usize = 0x0FFFFFFF;

use std::time::Instant;

macro_rules! benchmark {
	{
		$($name:ident: {
			bincode: $bincode_op:block$(,)?

			borsh: $borsh_op:block$(,)?

			bzipper: $bzipper_op:block$(,)?

			ciborium: $ciborium_op:block$(,)?

			postcard: $postcard_op:block$(,)?
		}$(,)?)+
	 } => {{
		use ::std::{concat, eprint, eprintln, stringify};

		macro_rules! time {
			{ $op: block } => {{
				let start = Instant::now();
				$op
				let stop = Instant::now();

				let duration = stop - start;
				(duration.as_nanos() as f64) / 1_000_000_000.0
			}};
		}

		fn format_score(duration: f64, ref_duration: f64) -> String {
			let vps = (VALUE_COUNT as f64 / duration).round();

			let difference = (duration / ref_duration - 1.0) * 100.0;

			let colour: u8 = if difference >= 0.0 {
				0x20
			} else if difference < 0.0 {
				0x1F
			} else {
				0x00
			};

			format!("{duration:.3}s ({vps:.0} vps) => \u{001B}[{colour}m{difference:+.2}%\u{001B}[000m")
		}

		let mut total_bincode_duration  = 0.0;
		let mut total_borsh_duration    = 0.0;
		let mut total_bzipper_duration  = 0.0;
		let mut total_ciborium_duration = 0.0;
		let mut total_postcard_duration = 0.0;

		$({
			eprintln!();
			eprintln!(concat!("\u{001B}[001mrunning benchmark `", stringify!($name), "`...\u{001B}[022m"));
			eprint!("\u{001B}[093m");

			let bincode_duration  = time! { $bincode_op };
			let borsh_duration    = time! { $borsh_op };
			let bzipper_duration  = time! { $bzipper_op };
			let ciborium_duration = time! { $ciborium_op };
			let postcard_duration = time! { $postcard_op };

			eprint!("\u{001B}[000m");
			eprintln!("bincode:  {}", format_score(bincode_duration,  bzipper_duration));
			eprintln!("borsh:    {}", format_score(borsh_duration,    bzipper_duration));
			eprintln!("bzipper:  {}", format_score(bzipper_duration,  bzipper_duration));
			eprintln!("ciborium: {}", format_score(ciborium_duration, bzipper_duration));
			eprintln!("postcard: {}", format_score(postcard_duration, bzipper_duration));

			total_bincode_duration  += bincode_duration;
			total_borsh_duration    += borsh_duration;
			total_bzipper_duration  += bzipper_duration;
			total_ciborium_duration += ciborium_duration;
			total_postcard_duration += postcard_duration;
		})*

		eprintln!();
		eprintln!("\u{001B}[001mtotal score:\u{001B}[022m");
		eprintln!("bincode:  {}", format_score(total_bincode_duration,  total_bzipper_duration));
		eprintln!("borsh:    {}", format_score(total_borsh_duration,    total_bzipper_duration));
		eprintln!("bzipper:  {}", format_score(total_bzipper_duration,  total_bzipper_duration));
		eprintln!("ciborium: {}", format_score(total_ciborium_duration, total_bzipper_duration));
		eprintln!("postcard: {}", format_score(total_postcard_duration, total_bzipper_duration));
	}};
}

#[derive(bzipper::Decode, bzipper::SizedEncode)]
#[derive(borsh::BorshSerialize)]
#[derive(serde::Deserialize, serde::Serialize)]
#[repr(transparent)]
struct Unit;

#[derive(bzipper::Decode, bzipper::SizedEncode)]
#[derive(borsh::BorshSerialize)]
#[derive(serde::Deserialize, serde::Serialize)]
#[repr(transparent)]
struct Unnamed(u32);

impl Unnamed {
	#[inline(always)]
	#[must_use]
	pub const fn from_char(value: char) -> Self {
		Self(value as u32)
	}
}

#[derive(bzipper::Decode, bzipper::SizedEncode)]
#[derive(borsh::BorshSerialize)]
#[derive(serde::Deserialize, serde::Serialize)]
#[repr(transparent)]
struct Named { buf: [u8; 0x8] }

#[derive(bzipper::Decode, bzipper::SizedEncode)]
#[derive(borsh::BorshSerialize)]
#[derive(serde::Deserialize, serde::Serialize)]
enum Enum {
	Unit(Unit),
	Unnamed(Unnamed),
	Named(Named),
}

impl Named {
	#[inline(always)]
	#[must_use]
	pub const fn from_u64(value: u64) -> Self {
		let buf = [
			 (value & 0x00_00_00_00_00_00_00_FF)         as u8,
			((value & 0x00_00_00_00_00_00_FF_00) >> 0x2) as u8,
			((value & 0x00_00_00_00_00_FF_00_00) >> 0x4) as u8,
			((value & 0x00_00_00_00_FF_00_00_00) >> 0x6) as u8,
			((value & 0x00_00_00_FF_00_00_00_00) >> 0x8) as u8,
			((value & 0x00_00_FF_00_00_00_00_00) >> 0xA) as u8,
			((value & 0x00_FF_00_00_00_00_00_00) >> 0xC) as u8,
			((value & 0xFF_00_00_00_00_00_00_00) >> 0xE) as u8,
		];

		Self { buf }
	}
}

fn main() {
	println!("######################");
	println!("# BZIPPER BENCHMARKS #");
	println!("######################");
	println!();
	println!("Each benchmark has a version written for the following crates:");
	println!();
	println!("- Bincode:  <https://crates.io/crates/bincode/>");
	println!("- Borsh:    <https://crates.io/crates/borsh/>");
	println!("- Ciborium: <https://crates.io/crates/ciborium/>");
	println!("- bzipper:  <https://crates.io/crates/bzipper/>");
	println!("- Postcard: <https://crates.io/crates/postcard/>");
	println!();
	println!("The total time the benchmark took (including memory allocations and dealloca-");
	println!("tions) is printed when the benchmark has completed. The `vps` counter signifies");
	println!("the amount of values per second that the benchmark has handled (during the en-");
	println!("tirety of the benchmark).");
	println!();
	println!("When every benchmark has concluded, the total run time and vps is listed for");
	println!("each crate. A percantage additionally compares the run time between the listed");
	println!("crate and bzipper (which should always be `0%` for bzipper itself). DO NOTE THAT");
	println!("THESE FINAL RESULTS INDICATE A NON-WEIGHTED AVERAGE ACROSS BENCHMARKS. It can");
	println!("therefore be skewed relative to real-world performance by the similarity of some");
	println!("benchmarks.");
	println!();

	eprintln!("value_count: {VALUE_COUNT}");

	benchmark! {
		encode_u8: {
			bincode: {
				// Requires `std`.

				use bincode::serialize_into;
				use std::io::Cursor;

				let buf_size = size_of::<u8>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					serialize_into(&mut buf, &random::<u8>()).unwrap();
				}
			}

			borsh: {
				use std::io::Cursor;

				let buf_size = size_of::<u8>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					borsh::to_writer(&mut buf, &random::<u8>()).unwrap();
				}
			}

			bzipper: {
				use bzipper::{Encode, OStream, SizedEncode};

				let buf_size = u8::MAX_ENCODED_SIZE; // value

				let mut buf = vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice();
				let mut stream = OStream::new(&mut buf);

				for _ in 0x0..VALUE_COUNT {
					random::<u8>().encode(&mut stream).unwrap();
				}
			}

			ciborium: {
				use std::io::Cursor;

				let buf_size =
					size_of::<u8>()    // header
					+ size_of::<u8>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					ciborium::into_writer(&random::<u8>(), &mut buf).unwrap();
				}
			}

			postcard: {
				use std::io::Cursor;

				let buf_size = size_of::<u8>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					postcard::to_io(&random::<u8>(), &mut buf).unwrap();
				}
			}
		}

		encode_struct_unit: {
			bincode: {
				use bincode::serialize_into;
				use std::io::Cursor;

				let buf_size = size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					serialize_into(&mut buf, &Unit).unwrap();
				}
			}

			borsh: {
				use std::io::Cursor;

				let buf_size = size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					borsh::to_writer(&mut buf, &Unit).unwrap();
				}
			}

			bzipper: {
				use bzipper::{Encode, OStream, SizedEncode};

				let buf_size = Unit::MAX_ENCODED_SIZE; // value

				let mut buf = vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice();
				let mut stream = OStream::new(&mut buf);

				for _ in 0x0..VALUE_COUNT {
					Unit.encode(&mut stream).unwrap();
				}
			}

			ciborium: {
				use std::io::Cursor;

				let buf_size =
					size_of::<u8>()      // header
					+ size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					ciborium::into_writer(&Unit, &mut buf).unwrap();
				}
			}

			postcard: {
				use std::io::Cursor;

				let buf_size = size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					postcard::to_io(&Unit, &mut buf).unwrap();
				}
			}
		}

		encode_struct_unnamed: {
			bincode: {
				use bincode::serialize_into;
				use std::io::Cursor;

				let buf_size = size_of::<Unnamed>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					serialize_into(&mut buf, &Unnamed::from_char(random())).unwrap();
				}
			}

			borsh: {
				use std::io::Cursor;

				let buf_size = size_of::<Unnamed>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					borsh::to_writer(&mut buf, &Unnamed::from_char(random())).unwrap();
				}
			}

			bzipper: {
				use bzipper::{Encode, OStream, SizedEncode};

				let buf_size = Unnamed::MAX_ENCODED_SIZE; // value

				let mut buf = vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice();
				let mut stream = OStream::new(&mut buf);

				for _ in 0x0..VALUE_COUNT {
					Unnamed::from_char(random()).encode(&mut stream).unwrap();
				}
			}

			ciborium: {
				use std::io::Cursor;

				let buf_size =
					size_of::<u8>()         // header
					+ size_of::<Unnamed>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					ciborium::into_writer(&Unnamed::from_char(random()), &mut buf).unwrap();
				}
			}

			postcard: {
				use std::io::Cursor;

				let buf_size = size_of::<Unnamed>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					postcard::to_io(&Unnamed::from_char(random()), &mut buf).unwrap();
				}
			}
		}

		encode_struct_named: {
			bincode: {
				use bincode::serialize_into;
				use std::io::Cursor;

				let buf_size = size_of::<Named>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					serialize_into(&mut buf, &Named::from_u64(random())).unwrap();
				}
			}

			borsh: {
				use std::io::Cursor;

				let buf_size = size_of::<Named>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					borsh::to_writer(&mut buf, &Named::from_u64(random())).unwrap();
				}
			}

			bzipper: {
				use bzipper::{Encode, OStream, SizedEncode};

				let buf_size = Named::MAX_ENCODED_SIZE; // value

				let mut buf = vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice();
				let mut stream = OStream::new(&mut buf);

				for _ in 0x0..VALUE_COUNT {
					Named::from_u64(random()).encode(&mut stream).unwrap();
				}
			}

			ciborium: {
				use std::io::Cursor;

				let buf_size =
					size_of::<u8>()       // header
					+ size_of::<u64>()    // tag
					+ size_of::<u8>()     // header
					+ size_of::<Named>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					ciborium::into_writer(&Named::from_u64(random()), &mut buf).unwrap();
				}
			}

			postcard: {
				use std::io::Cursor;

				let buf_size = size_of::<Named>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					postcard::to_io(&Named::from_u64(random()), &mut buf).unwrap();
				}
			}
		}

		encode_enum_unit: {
			bincode: {
				use bincode::serialize_into;
				use std::io::Cursor;

				let buf_size =
					size_of::<u32>()     // discriminant
					+ size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT]);

				for _ in 0x0..VALUE_COUNT {
					serialize_into(&mut buf, &Enum::Unit(Unit)).unwrap();
				}
			}

			borsh: {
				use std::io::Cursor;

				let buf_size =
					size_of::<u8>()      // discriminant
					+ size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					borsh::to_writer(&mut buf, &Enum::Unit(Unit)).unwrap();
				}
			}

			bzipper: {
				use bzipper::{Encode, OStream, SizedEncode};

				let buf_size =
					isize::MAX_ENCODED_SIZE   // discriminant
					+ Unit::MAX_ENCODED_SIZE; // value

				let mut buf = vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice();
				let mut stream = OStream::new(&mut buf);

				for _ in 0x0..VALUE_COUNT {
					Enum::Unit(Unit).encode(&mut stream).unwrap();
				}
			}

			ciborium: {
				use std::io::Cursor;

				let buf_size =
					size_of::<u8>()      // header
					+ size_of::<u64>()   // tag (discriminant)
					+ size_of::<u8>()    // header
					+ size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					ciborium::into_writer(&Enum::Unit(Unit), &mut buf).unwrap();
				}
			}

			postcard: {
				use std::io::Cursor;

				let buf_size =
					size_of::<u32>()     // discriminant
					+ size_of::<Unit>(); // value

				let mut buf = Cursor::new(vec![0x00; buf_size * VALUE_COUNT].into_boxed_slice());

				for _ in 0x0..VALUE_COUNT {
					postcard::to_io(&Enum::Unit(Unit), &mut buf).unwrap();
				}
			}
		}
	};
}