Computing cryptography hashes: Rust, F#, D and Scala

Let's compare how fast Rust, D and F# (.NET actually) at computing cryptography hashes, namely MD5, SHA1, SHA256 and SHA512. We're going to use rust-crypto cargo:

	extern crate crypto;
	extern crate time;
	use crypto::md5::Md5;
	use crypto::sha1::Sha1;
	use crypto::sha2::{Sha256, Sha512};
	use crypto::digest::Digest;
	use time::now;
	fn bench<T: Digest>(name: &str, digest: &mut T, input: &Vec<u8>) {
	let started = time::now();
	for _ in 1..100 {
	digest.input(&input);
	digest.reset();
	}
	let elapsed = time::now() - started;
	println!("{:?} elapled {}", name, elapsed);
	}
	fn main() {
	let input = vec![0u8; 10000000];
	bench("MD5", &mut Md5::new(), &input);
	bench("SHA1", &mut Sha1::new(), &input);
	bench("SHA256", &mut Sha256::new(), &input);
	bench("SHA512", &mut Sha512::new(), &input);
	}

view raw digests.rs hosted with ❤ by GitHub

Results:

• MD5 - 3.39s 
• SHA1 - 2.89s 
• SHA256 - 6.97s
• SHA512 - 4.47s

Now the F# code:

	open System.Security.Cryptography
	open System.Diagnostics
	open System
	let bench (input: byte[]) (digest: HashAlgorithm) =
	let sw = Stopwatch.StartNew()
	for _ in 1..100 do
	digest.ComputeHash input |> ignore // |> M.toHex |> printfn "%s"
	sw.Stop()
	printfn "%s elapled %O" (digest.GetType().Name) sw.Elapsed
	let input = Array.zeroCreate<byte> 10000000
	[ new MD5CryptoServiceProvider() :> HashAlgorithm
	new SHA1CryptoServiceProvider() :> _
	SHA256.Create() :> _
	new SHA256CryptoServiceProvider() :> _
	new SHA256Cng() :> _
	SHA512.Create() :> _
	new SHA512CryptoServiceProvider() :> _
	new SHA512Cng() :> _ ]
	|> List.iter (bench input)

view raw digests.fs hosted with ❤ by GitHub

Results (.NET 4.5, VS 2013, F# 3.1):

• MD5CryptoServiceProvider - 2.32s (32% faster)
• SHA1CryptoServiceProvider - 2.92s (1% slower)
• SHA256Managed - 16.50s (236% slower)
• SHA256CryptoServiceProvider - 11.50s (164% slower)
• SHA256Cng - 11.71s (168% slower)
• SHA512Managed - 61.04s (1365% slower)
• SHA512CryptoServiceProvider - 21.88s (489% slower)
• SHA512Cng - 22.19s (496% slower)

(.NET 4.6, VS 2015, F# 4.0):

• MD5CryptoServiceProvider elapled 2.55
• SHA1CryptoServiceProvider elapled 2.89
• SHA256Managed elapled 17.01
• SHA256CryptoServiceProvider elapled 8.74
• SHA256Cng elapled 8.75
• SHA512Managed elapled 23.42
• SHA512CryptoServiceProvider 5.81
• SHA512Cng elapled 5.79

D:

	module main;
	import std.stdio;
	import std.digest.md;
	import std.digest.sha;
	import std.datetime;
	void bench(T)(string name, T digest, const ubyte[] input) {
	auto sw = StopWatch(AutoStart.yes);
	for (auto i = 0; i < 100; i++) {
	digest.put(input);
	auto hash = digest.finish();
	}
	sw.stop();
	writefln("%s - %s ms elapsed.", name, sw.peek.msecs);
	}
	void main(string[] args)
	{
	auto input = new const ubyte[10_000_000];
	MD5 md5; bench("MD5", md5, input);
	SHA1 sha1; bench("SHA1", sha1, input);
	SHA256 sha256; bench("SHA256", sha256, input);
	SHA512 sha512; bench("SHA512", sha512, input);
	stdin.readln();
	}

view raw digests.d hosted with ❤ by GitHub

DMD

• MD5 - 16.05s (470% slower)
• SHA1 - 2.35s (19% faster)
• SHA256 - 47.96s (690% slower (!))
• SHA512 - 61.47s (1375% slower (!))

LDC2

• MD5 - 2,18s (55% faster)
• SHA1 - 2.88s (same)
• SHA256 - 6,79s (3% faster)
• SHA512 - 4,6s (3% slower)

GDC

• MD5 - 2,43 (29% faster)
• SHA1 - 2,84 (2% faster)
• SHA256 - 12,62 (45% slower)
• SHA512 - 8,56 (48% slower)

Scala:

	object Util {
	def time[A](name: String) (f: => A) = {
	val s = System.nanoTime
	val ret = f
	println(s"$name elapsed ${(System.nanoTime-s)/1e6} ms")
	ret
	}
	}
	private object Bench {
	def bench(input: Array[Byte]) (digestName: String) = {
	import java.security.MessageDigest
	val digest = MessageDigest.getInstance(digestName)
	Util.time(digest.getAlgorithm) {
	(1 to 100).foreach(_ => digest.digest(input))
	}
	}
	}
	object Main {
	def main(args: Array[String]) = {
	val input = new Array[Byte](10000000)
	Seq("MD5", "SHA1", "SHA-256", "SHA-512")
	.foreach { Bench.bench (input) }
	}
	}

view raw digests.scala hosted with ❤ by GitHub

• MD5 - 4.2s (23% slower)
• SHA1 - 6.09s (110% slower)
• SHA256 - 9.96s (42% slower)
• SHA512 - 7.32s (63% slower)

Interesting things:

• Rust and D (LDC2) show very close results. D is significantly faster on MD5, so it's the winner!
• D (DMD) has very bad performance on all algorithms, except SHA1, where it's won.
• SHA512Managed .NET class is very slow. Do not use it.