parallel-hashmap
Stockfish
Our great sponsors
parallel-hashmap | Stockfish | |
---|---|---|
31 | 150 | |
2,307 | 10,433 | |
- | 2.7% | |
7.6 | 9.6 | |
14 days ago | 7 days ago | |
C++ | C++ | |
Apache License 2.0 | GNU General Public License v3.0 only |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
parallel-hashmap
-
The One Billion Row Challenge in CUDA: from 17 minutes to 17 seconds
Standard library maps/unordered_maps are themselves notoriously slow anyway. A sparse_hash_map from abseil or parallel-hashmaps[1] would be better.
-
My own Concurrent Hash Map picks
Cool! Looking forward to you trying my phmap - and please let me know if you have any question.
-
Boost 1.81 will have boost::unordered_flat_map...
I do this as well in my phmap and gtl implementations. It makes the tables look worse in benchmarks like the above, but prevents really bad surprises occasionally.
-
Comprehensive C++ Hashmap Benchmarks 2022
Thanks a lot for the great benchmark, Martin. Glad you used different hash functions, because I do sacrifice some speed to make sure that the performance of my hash maps doesn't degrade drastically with poor hash functions. Happy to see that my phmap and gtl (the C++20 version) performed well.
-
Can C++ maps be as efficient as Python dictionaries ?
I use https://github.com/greg7mdp/parallel-hashmap when I need better performance of maps and sets.
-
How to build a Chess Engine, an interactive guide
Then they should really try https://github.com/greg7mdp/parallel-hashmap, the current state of the art.
-
boost::unordered map is a new king of data structures
Unordered hash map shootout CMAP = https://github.com/tylov/STC KMAP = https://github.com/attractivechaos/klib PMAP = https://github.com/greg7mdp/parallel-hashmap FMAP = https://github.com/skarupke/flat_hash_map RMAP = https://github.com/martinus/robin-hood-hashing HMAP = https://github.com/Tessil/hopscotch-map TMAP = https://github.com/Tessil/robin-map UMAP = std::unordered_map Usage: shootout [n-million=40 key-bits=25] Random keys are in range [0, 2^25). Seed = 1656617916: T1: Insert/update random keys: KMAP: time: 1.949, size: 15064129, buckets: 33554432, sum: 165525449561381 CMAP: time: 1.649, size: 15064129, buckets: 22145833, sum: 165525449561381 PMAP: time: 2.434, size: 15064129, buckets: 33554431, sum: 165525449561381 FMAP: time: 2.112, size: 15064129, buckets: 33554432, sum: 165525449561381 RMAP: time: 1.708, size: 15064129, buckets: 33554431, sum: 165525449561381 HMAP: time: 2.054, size: 15064129, buckets: 33554432, sum: 165525449561381 TMAP: time: 1.645, size: 15064129, buckets: 33554432, sum: 165525449561381 UMAP: time: 6.313, size: 15064129, buckets: 31160981, sum: 165525449561381 T2: Insert sequential keys, then remove them in same order: KMAP: time: 1.173, size: 0, buckets: 33554432, erased 20000000 CMAP: time: 1.651, size: 0, buckets: 33218751, erased 20000000 PMAP: time: 3.840, size: 0, buckets: 33554431, erased 20000000 FMAP: time: 1.722, size: 0, buckets: 33554432, erased 20000000 RMAP: time: 2.359, size: 0, buckets: 33554431, erased 20000000 HMAP: time: 0.849, size: 0, buckets: 33554432, erased 20000000 TMAP: time: 0.660, size: 0, buckets: 33554432, erased 20000000 UMAP: time: 2.138, size: 0, buckets: 31160981, erased 20000000 T3: Remove random keys: KMAP: time: 1.973, size: 0, buckets: 33554432, erased 23367671 CMAP: time: 2.020, size: 0, buckets: 33218751, erased 23367671 PMAP: time: 2.940, size: 0, buckets: 33554431, erased 23367671 FMAP: time: 1.147, size: 0, buckets: 33554432, erased 23367671 RMAP: time: 1.941, size: 0, buckets: 33554431, erased 23367671 HMAP: time: 1.135, size: 0, buckets: 33554432, erased 23367671 TMAP: time: 1.064, size: 0, buckets: 33554432, erased 23367671 UMAP: time: 5.632, size: 0, buckets: 31160981, erased 23367671 T4: Iterate random keys: KMAP: time: 0.748, size: 23367671, buckets: 33554432, repeats: 8, sum: 4465059465719680 CMAP: time: 0.627, size: 23367671, buckets: 33218751, repeats: 8, sum: 4465059465719680 PMAP: time: 0.680, size: 23367671, buckets: 33554431, repeats: 8, sum: 4465059465719680 FMAP: time: 0.735, size: 23367671, buckets: 33554432, repeats: 8, sum: 4465059465719680 RMAP: time: 0.464, size: 23367671, buckets: 33554431, repeats: 8, sum: 4465059465719680 HMAP: time: 0.719, size: 23367671, buckets: 33554432, repeats: 8, sum: 4465059465719680 TMAP: time: 0.662, size: 23367671, buckets: 33554432, repeats: 8, sum: 4465059465719680 UMAP: time: 6.168, size: 23367671, buckets: 31160981, repeats: 8, sum: 4465059465719680 T5: Lookup random keys: KMAP: time: 0.943, size: 23367671, buckets: 33554432, lookups: 34235332, found: 29040438 CMAP: time: 0.863, size: 23367671, buckets: 33218751, lookups: 34235332, found: 29040438 PMAP: time: 1.635, size: 23367671, buckets: 33554431, lookups: 34235332, found: 29040438 FMAP: time: 0.969, size: 23367671, buckets: 33554432, lookups: 34235332, found: 29040438 RMAP: time: 1.705, size: 23367671, buckets: 33554431, lookups: 34235332, found: 29040438 HMAP: time: 0.712, size: 23367671, buckets: 33554432, lookups: 34235332, found: 29040438 TMAP: time: 0.584, size: 23367671, buckets: 33554432, lookups: 34235332, found: 29040438 UMAP: time: 1.974, size: 23367671, buckets: 31160981, lookups: 34235332, found: 29040438
-
Is A* just always slow?
std::unordered_map is notorious for being slow. Use a better implementation (I like the flat naps from here, which are the same as abseil’s). The question that needs to be asked too is if you need to use a map.
-
New Boost.Unordered containers have BIG improvements!
A comparison against phmap would also be nice.
-
How to implement static typing in a C++ bytecode VM?
std::unordered_map is perfectly fine. You can do better with external libraries, like parallel hashmap, but these tend to be drop-in replacements
Stockfish
-
Manipulating the Internal World Model of a Chess Playing Language Model
The Stockfish program can be set to play at strength level 0-20. Estimates of the levels' Elo is provided here: https://github.com/official-stockfish/Stockfish/commit/a08b8...
-
A chess terminal user interface implementation
- and handicapped Stockfish (https://stockfishchess.org).
The whole thing is at https://github.com/magv/bchess, and can be installed with just 'pip install bchess'.
- What could I contribute to chess as a developer?
-
posttest-cli beta testers wanted
This was the result searching for all the 35 stockfish benchmark positions to depth 6.
-
How many positions can the top GMs analyze per second? In engine terms what is the highest nps for humans?
Stockfish doesn't have a classical evaluation anymore. And before this, most of the time (around 90%), NNUE was used to evaluate.
-
Stockfish 16 Released +47 Elo gain over Stockfish 15 (Single threaded, UHO)
If you use ChessBase on a MacBook through Parallels, there's an issue where people have posted Apple Silicon compiles for Windows: https://github.com/official-stockfish/Stockfish/issues/4241
-
Stockfish 16 is ready!
Progress can be found here https://github.com/official-stockfish/Stockfish/wiki/Regression-Tests At 1 thread it has gained +18.3 elo on a balanced book, and +47.03 on UHO (unbalanced) book as well as +39.4 elo for FRC and +65.56 for DFRC. At 8 threads it has gained +14.33 elo on a balanced book and +49.46 on UHO (unbalanced book). Also testing was done on 8 threads with 180+1.8 (this is considered very long time control for fishtest standards) and progress was +9.45 on balanced book and +49.65 on UHO.
-
Stockfish 16 is ready
Downloads are available temporarily here https://github.com/official-stockfish/Stockfish/releases/tag/stockfish-dev-20230622-a49b3ba7
-
Is there an engine stronger than Stockfish 15.1?
The strongest version of Stockfish is the latest development version of Stockfish
-
How to integrate Stockfish chess engine into React Native app (for both Android and iOS)
I am trying to implement Stockfish (a popular chess engine) into my React Native app.
What are some alternatives?
Folly - An open-source C++ library developed and used at Facebook.
nibbler - Chess analysis GUI for UCI engines, with extra features for Leela (Lc0) in particular.
robin-hood-hashing - Fast & memory efficient hashtable based on robin hood hashing for C++11/14/17/20
nnue-pytorch - Stockfish NNUE (Chess evaluation) trainer in Pytorch
libcuckoo - A high-performance, concurrent hash table
lc0 - The rewritten engine, originally for tensorflow. Now all other backends have been ported here.
rust-phf - Compile time static maps for Rust
fishtest - The Stockfish testing framework
flat_hash_map - A very fast hashtable
maia-chess - Maia is a human-like neural network chess engine trained on millions of human games.
tracy - Frame profiler
Ciphey - ⚡ Automatically decrypt encryptions without knowing the key or cipher, decode encodings, and crack hashes ⚡