The idea is to benchmark performance over <byte[32], int32> hashmaps in different languages where byte[32] is itself SHA256 of some data.

Supposing RAM is not an issue, so some tests have consumed up to 16 Gb of RAM.

The custom algorithm can be way imperfect, so take these tests with a grain of salt and of course better alternatives are very welcome.

The algorithm doesn't hash a key, instead it expects SHA256 as a key and stores each key and value pair in it's hash tree.

Everywhere release x64 configurations has been used.

"Tree size" means size of pointer arrays in the top level of hash map and in the consequent layers.

So 3*8+7 / 1*8-4 means 3 bytes plus 7 bits of key data will be used for addressing the top pointer array of the hash tree, while 1 byte minus 4 bits of subsequent key data will be used for addressing pointer arrays of the lower levels of the hash tree.

Basically a pointer array size in bytes of any hash tree level on x64 system can be calculated as (1 << bits) * 8 and these are the most RAM consuming parts of the algorithms.

The results are in milliseconds and consist of two tests in a form of T1/T2 where:

• T1: adding pairs
• T2: getting and validating values

The testing has been performed on Windows 7x64.

• CPU: Intel Core i7-4790 3.6 GHz 4 cores / 8 threads
• RAM: 32 Gb

I have highlighted the best key lookup performance for the languages on 32'000'000 key dataset.

Actually I'm amazed how well go performs, even its native map implementation, and actually I would give it the 1st place in these tests, while с would get the 2nd.

Meanwhile it is highly possible that the models here are far from being well optimized, so the real rating can be absolutely different.