Updating map_benchmarks: Send your hashmaps!

1. fph-table

   1 3 45 4.0 C++

   Flash Perfect Hash Table: an implementation of a dynamic perfect hash table, extremely fast for lookup

   

   I believe that when the number of elements is larger than 4 (a rough estimation), the associative linear table won't be faster than ska::flat_hash_map or fph-table with the identity hash function. If you look at the benchmark results, you will find that the average lookup time may well be less than 2 nanoseconds when item number is smaller than one thousand on morden CPUs. For these two hash tables, there are only about ten instructions in the critical path of lookup. And this should be faster than the linear search in a associative table, where there are a lot of branches and comparing instructions. However, you should benchmark it youself to get the real conclusion. This is just a simple analysis on paper from mine. By the way, the associative table can be faster if it is implemented with hardware circuits or SIMD instructions.

2. JetBrains

   surveys.jetbrains.com featured

   Tell us how you use coding tools. You may win a prize! Are you a developer or a data analyst? Share your thoughts about your coding tools in our short survey and get a chance to win prizes!

   

3. google-sparsehash

   2 1 17 10.0 Shell

   Clone of google-sparsehash

   

   google sparsehash would be interesting to see. From what I understand it's the predecessor to the Abseil containers. Would be nice to see a comparison

4. CppPerformanceBenchmarks

   3 5 - -

5. sparsepp

   4 4 1,287 3.6 C++

   A fast, memory efficient hash map for C++

   

   Also, I'm testing https://github.com/greg7mdp/sparsepp which is based on google's sparsehash

6. gtl

   5 5 214 6.6 C++

   Greg's Template Library of useful classes.

   

   AFAIK sparsepp has been dropped entirely in favor of the containers in GTL: https://github.com/greg7mdp/gtl

7. dense_hash_map

   6 1 51 0.0 C++

   A simple replacement for std::unordered_map

   

   https://github.com/Jiwan/dense_hash_map is also a good flat hash map.

8. qc-hash

   7 1 11 5.7 C++

   (Legacy) Extremely fast unordered map and set library for C++20

   

9. Sevalla

   sevalla.com featured

   Deploy and host your apps and databases, now with $50 credit! Sevalla is the PaaS you have been looking for! Advanced deployment pipelines, usage-based pricing, preview apps, templates, human support by developers, and much more!

   

10. eytzinger

    8 1 32 10.0 C++

    Cache-friendly associative STL-like container with an Eytzinger (BFS) layout for C++

    

    https://github.com/mikekazakov/eytzinger should always beat flat_map except for very small maps. That said, for very small maps a simple linear search probably beats everything.

11. flat_hash_map

    9 10 1,780 0.0 C++

    A very fast hashtable

    

    I believe that when the number of elements is larger than 4 (a rough estimation), the associative linear table won't be faster than ska::flat_hash_map or fph-table with the identity hash function. If you look at the benchmark results, you will find that the average lookup time may well be less than 2 nanoseconds when item number is smaller than one thousand on morden CPUs. For these two hash tables, there are only about ten instructions in the critical path of lookup. And this should be faster than the linear search in a associative table, where there are a lot of branches and comparing instructions. However, you should benchmark it youself to get the real conclusion. This is just a simple analysis on paper from mine. By the way, the associative table can be faster if it is implemented with hardware circuits or SIMD instructions.

12. hashtable-bench

    10 1 20 3.1 Jupyter Notebook

    A benchmark for hash tables and hash functions in C++, evaluate on different data as comprehensively as possible

    

    I believe that when the number of elements is larger than 4 (a rough estimation), the associative linear table won't be faster than ska::flat_hash_map or fph-table with the identity hash function. If you look at the benchmark results, you will find that the average lookup time may well be less than 2 nanoseconds when item number is smaller than one thousand on morden CPUs. For these two hash tables, there are only about ten instructions in the critical path of lookup. And this should be faster than the linear search in a associative table, where there are a lot of branches and comparing instructions. However, you should benchmark it youself to get the real conclusion. This is just a simple analysis on paper from mine. By the way, the associative table can be faster if it is implemented with hardware circuits or SIMD instructions.

13. llvm-project

    11 429 34,200 10.0 LLVM

    The LLVM Project is a collection of modular and reusable compiler and toolchain technologies.

    

    I would be interested to see how good is https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/ADT/DenseMap.h

Suggest a related project