HotSpot mark word layout and lock states (unlocked, lightweight, heavyweight, GC mark)

Concurrent Hash Table Designs: Synchronized, Sharding, ConcurrentHashMap, and NonBlockingHashMap

The next milestone is to build a fully thread-safe hash map. Up to this point, the focus has been entirely on single-threaded performance: minimizing memory overhead, improving cache locality, and squeezing out every last bit of throughput from the underlying data layout. However, real-world applications rarely stay single-threaded. To be practically useful, a hash map must behave correctly—and efficiently—under concurrent access. Before jumping straight into implementation, it’s worth stepping back and studying how existing thread-safe hash map implementations approach this problem. Different designs make different trade-offs between simplicity, scalability, memory usage, and read/write performance. By examining these approaches side by side, we can better understand which ideas scale cleanly—and where the pitfalls are—when multiple threads hit the same structure at once. ...

December 27, 2025 · 50 min · Donghyung Ko
Java SwissTable optimization: profiling and SWAR probing

Further Optimizing my Java SwissTable: Profile Pollution and SWAR Probing

Part 2: optimizing the hot path (and finding a weird villain) “Why Objects.equals() showed up in the profile—and why SWAR beat the Vector API on ARM (and x86). In the last post, I finally got a SwissTable-ish map running on the JVM and fast enough to make me smile. Naturally, that meant I immediately started staring at the profiler again, thinking: okay… but how do I make it faster? This follow-up is about that next round of tuning—where the improvements come less from “big design ideas” and more from noticing one weird hotspot at a time, pulling on the thread, and ending up somewhere unexpected. ...

December 17, 2025 · 16 min · Donghyung Ko
Memory footprint comparison for the Java SwissTable experiment

Building a Fast, Memory-Efficient Hash Table in Java (by borrowing the best ideas)

One day, I ran into SwissTable—the kind of design that makes you squint, grin, and immediately regret every naive linear-probing table you’ve ever shipped. This post is the story of how I tried to bring that same “why is this so fast?” feeling into Java. It’s part deep dive, part engineering diary, and part cautionary tale about performance work. 1) The SwissTable project, explained the way it feels when you first understand it SwissTable is an open-addressing hash table design that came out of Google’s work and was famously presented as a new C++ hash table approach (and later shipped in Abseil). ...

December 12, 2025 · 15 min · Donghyung Ko
Visualization used in the SwissTable explanation

Inside Google’s Swiss Table: A High-Performance Hash Table Explained

Swiss Tables:A Modern, High-Performance Hash Table Swiss Table is a high-performance hash table design introduced by Google engineers in 2017. It has since inspired many standard-library implementations across languages, including: Go 1.24 ships its map with this design (up to 60% faster) Rust’s standard HashMap has also moved from Robin Hood hashing to a Swiss Table-inspired layout. Datadog reported as much as 70% memory savings after migrating to Swiss Table Open Addressing, Briefly An open addressing hash table is one of the implementation methods for hash tables. Unlike separate chaining — which uses external data structures such as linked lists or trees — open addressing implements the entire hash table as a single contiguous array. ...

December 10, 2025 · 3 min · Donghyung Ko