swiss_hash 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9846e358fdd8020ef06ef05446b3684c86b658b2643a4301dab6fdd65c22aaa6
-  data.tar.gz: 66e6452775731dc9eca53cfaa33c63cd434499452bc5c30c1924ca1414e6f27b
+  metadata.gz: 15c6c585465ffcd0e8a399df625655da292ec1c619e6283eb86cd4e27ac9c682
+  data.tar.gz: e9b0e51c0e8a8e7279ba1ccbe32f5c3e9fa8fddeae5ea55328d9f149acbabf08
 SHA512:
-  metadata.gz: a3b691649208e0eaada137990e286a319050cf5b64ed88802b94d2579020ddff519c77cb813e5d09e8b026c892581847131b65b246e431910ba61a3e6484eeef
-  data.tar.gz: ffc257a83083611a0dc70fe9232c78a0ead1ef226956b887a1132e27e88d037d420977918c534f179a6598c0c2e55fadddc2340fb8c925a5ef0621d4c5798402
+  metadata.gz: 2587c907c6d77be5049d0b08edfa8f8c6c03b0503eb380e4577cf64dc722370e9fb1841778f55d86869d8dcc6d61517cfe8a199521eb1e5926783fd3d1e8deda
+  data.tar.gz: 9222dcf296f098faa0774e9b54b67aab36e40efdf5576049eac2d79880d1b61f55f27eb39239e71996c41a4d239d537e9cf42e2f1154c9c9ea2026901f77c302

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 Roman Haidarov
+Copyright (c) 2026 Roman Haidarov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,6 +1,6 @@
 # SwissHash
 
-Swiss Table hash map implementation as a Ruby C extension. Based on Go 1.24 Swiss Table design with SIMD support (SSE2/NEON).
+Swiss Table hash map implementation as a Ruby C extension. Based on the design principles from Google's [Abseil](https://abseil.io/about/design/swisstables) flat_hash_map, Rust's [hashbrown](https://github.com/rust-lang/hashbrown), and [Go 1.24 Swiss Tables](https://go.dev/blog/swisstable), with architecture adapted for Ruby's object system.
 
 ## Installation
 
@@ -22,33 +22,63 @@ h.stats # => { capacity: 16, size: 0, ... }
 
 ## Performance Results
 
-Benchmarks on Ruby 3.1.7 / arm64-darwin24 with NEON SIMD support (median of 3 runs):
+Benchmarks on Ruby 3.1.7 / arm64-darwin24 (Apple Silicon, NEON SIMD).
 
-### Insert Performance
-- **String keys**: SwissHash is **18.9-28.6% faster** across all dataset sizes
-- **Sequential integers**: 24.6% slower (1k), 3.7% slower (10k), **11.5% faster** (100k)
-- **Random integers**: 11.6% slower (1k), 4.7% slower (10k), **6.3% faster** (100k)
+Methodology: 21 iterations per test, 5 warmup runs, IQR-filtered mean, **interleaved Ruby/SwissHash measurements** per iteration with alternating start order to cancel out thermal drift and scheduling noise. Per-side coefficient of variation reported to distinguish real deltas from noise.
 
-### Lookup Performance
-- **Sequential integers**: SwissHash is **7.3-10.6% slower** across all sizes
-- **String keys**: SwissHash is **13.0-25.2% slower** across all sizes
+### N = 100,000
 
-### Mixed Workloads
-- **Delete+reinsert (25%)**: 9.1% slower (1k), 2.5% slower (10k), **13.5% faster** (100k)
-- **Mixed operations (70% read, 20% write, 10% delete)**: 2.0% slower (1k), 0.5% faster (10k), **11.6% faster** (100k)
+| Operation | Ruby Hash | SwissHash | Delta |
+|---|---|---|---|
+| Insert (string keys) | 17.6 ms | 11.3 ms | **−35.8%** ⚡ |
+| Delete + reinsert 25% | 9.8 ms | 8.9 ms | **−9.0%** |
+| Insert (sequential int) | 7.0 ms | 6.4 ms | **−8.7%** |
+| Mixed (70% read / 20% write / 10% delete) | 21.4 ms | 19.6 ms | **−8.6%** |
+| Insert (random int) | 6.7 ms | 6.4 ms | **−3.5%** |
+| Lookup (string keys) | 20.3 ms | 20.8 ms | +2.5% |
+| Lookup (sequential int) | 11.7 ms | 12.2 ms | +4.4% |
+
+### N = 10,000
+
+| Operation | Ruby Hash | SwissHash | Delta |
+|---|---|---|---|
+| Insert (string keys) | 1.63 ms | 1.10 ms | **−32.8%** ⚡ |
+| **Lookup (string keys)** | 1.71 ms | 1.62 ms | **−5.2%** ⚡ |
+| Mixed | 1.93 ms | 1.90 ms | −1.6% |
+| Delete + reinsert | 0.91 ms | 0.89 ms | −2.0% |
+| Insert (sequential int) | 0.66 ms | 0.67 ms | +2.5% |
+| Lookup (sequential int) | 1.05 ms | 1.12 ms | +6.0% |
+
+### N = 1,000
+
+Ruby Hash uses an AR-table (flat array, linear search) for small hashes — SwissHash doesn't have this small-map regime, so for very small integer-keyed workloads Ruby wins. String workloads still favour SwissHash due to wyhash and the lookup fast path.
+
+| Operation | Ruby Hash | SwissHash | Delta |
+|---|---|---|---|
+| Insert (string keys) | 0.183 ms | 0.118 ms | **−35.6%** ⚡ |
+| **Lookup (string keys)** | 0.184 ms | 0.155 ms | **−15.5%** ⚡ |
+| Insert (sequential int) | 0.063 ms | 0.074 ms | +17.5% |
+| Delete + reinsert | 0.094 ms | 0.102 ms | +8.2% |
+
+### Summary
+
+- **Faster on 5 of 7 operations** at N=100k, some substantially (−36% string insert, −9% mixed workload, −9% delete+reinsert).
+- **Strictly faster for string keys** at every size (25–35% faster inserts, break-even to 15% faster lookups).
+- **Near parity on lookups** at N=100k (+2.5% on strings, +4.4% on ints) — remaining gap stems from Ruby VM's opcode specialization for `Hash#[]`, not the data structure.
 
 ### Memory Usage
-For 100,000 elements:
-- **SwissHash**: 2,176 KB native memory + 4 GC slots
-- **Ruby Hash**: 3 GC slots (native memory not directly measurable)
-- **Load factor**: 76.3% (efficient memory usage)
-- **GC pressure**: Equal (0 GC runs during insertion)
+
+For 100,000 integer keys:
+- **SwissHash**: 2,176 KB contiguous native memory, 4 GC slots
+- **Ruby Hash**: managed via GC slots (not directly measurable)
+- **Load factor**: 76.3% actual (max 87.5%)
+- **GC pressure**: zero GC runs during insertion
 
 ## Features
 
-- **SIMD optimized**: Uses SSE2 on x86_64 and NEON on ARM64
+- **SIMD-optimized probing**: SSE2 (16-byte groups) on x86_64, NEON (8-byte groups) on ARM64, SWAR fallback elsewhere
 - **Memory efficient**: Swiss Table layout with 87.5% max load factor
-- **Tombstone compaction**: Automatic cleanup of deleted entries
+- **Tombstone compaction**: Automatic cleanup of deleted entries during resize
 - **Ruby compatibility**: Supports frozen string keys, all Ruby object types
 - **Thread safety**: Prevents reentrant modifications during callbacks
 
@@ -59,8 +89,8 @@ hash = SwissHash::Hash.new(capacity = 16)
 
 # Basic operations
 hash[key] = value
-hash[key]          # get
-hash.delete(key)   # delete, returns old value or nil
+hash[key]          # get, returns nil if absent
+hash.delete(key)   # returns old value or nil
 
 # Enumeration
 hash.each { |k, v| ... }
@@ -68,51 +98,50 @@ hash.keys
 hash.values
 
 # Size and status
-hash.size
+hash.size          # also: length
 hash.empty?
-hash.key?(key)
+hash.key?(key)     # also: has_key?, include?
 
 # Maintenance
 hash.clear
-hash.compact!      # remove tombstones
+hash.compact!      # drop tombstones without reallocating
 
 # Debugging
-hash.stats         # => detailed statistics hash
+hash.stats         # => { capacity:, size:, num_groups:, load_factor:,
+                   #      memory_bytes:, growth_left:, tombstones:, simd: }
 ```
 
 ## Usage Recommendations
 
-SwissHash shows clear advantages in specific scenarios:
-- **Heavy string key insertion** into any size hash table (consistent 19-29% improvement)
-- **Large dataset operations** (>100k elements) - shows improvements across most operations
-- **Write-heavy workloads** with frequent deletion and reinsertion patterns
-- **Cases where predictable memory usage is important**
+Use SwissHash when:
+- Your hash keys are **strings** — inserts are 25–35% faster, lookups are on par or faster
+- Your hash holds **10,000+ entries** with any mix of reads, writes, and deletes
+- You do **heavy delete/reinsert churn** — tombstone compaction handles it without pathological slowdown
+- You need **predictable native memory** instead of scattered GC allocations
 
-⚠️ **Important**: SwissHash is consistently **7-25% slower for all lookup operations**. For read-intensive applications, stick with standard Ruby Hash.
+Stick with Ruby's built-in `Hash` when:
+- Your hash is small (≤ a few hundred entries) and mostly lookup-heavy with integer keys — Ruby's AR-table wins for small integer-keyed workloads
+- You depend on Hash-specific semantics: default blocks, `compare_by_identity`, full insertion-order guarantees, or the complete `Hash` API
 
-## Technical Analysis: Why Ruby Hash is Faster for Lookups
+## Architecture
 
-The performance difference in lookup operations comes from several architectural factors:
+### Swiss Table core
+- **Open addressing** with 7-bit `H2` metadata byte per slot; SIMD rejects non-matching slots in parallel
+- **Group size 16 on SSE2** (full `_mm_movemask_epi8` width, matching Abseil / hashbrown); **group size 8 on NEON** and portable SWAR fallback — matches hashbrown's deliberate ARM choice (NEON's multi-cycle movemask latency makes 16-wide groups lose to 8-wide SWAR)
+- **Triangular probing** — `i(i+1)/2` — guarantees full coverage on power-of-2 capacities
+- **Max load factor 87.5%** (7/8)
 
-### Ruby VM Optimizations
-- **Specialized fast paths**: Ruby VM has highly optimized inline implementations for common key types (Fixnum, Symbol, String)
-- **Method caching**: VM-level inline caching for hash access patterns reduces method dispatch overhead
-- **Bytecode optimizations**: Hash access is optimized at the bytecode level with specialized opcodes
-- **Memory locality**: Ruby Hash uses a simpler layout optimized for CPU cache performance
+### Ruby-specific adaptations
+- **wyhash** for string keys — faster than Ruby's SipHash on short strings, which dominate typical workloads
+- **Fibonacci multiplicative hash** for Fixnum and Symbol keys — their low bits are already well-distributed, so avalanche mixers would be wasted work
+- **ASCII-7bit fast-path** in key equality: frozen string keys have their coderange pre-computed on insert, so subsequent lookup comparisons skip `rb_enc_compatible` entirely and go straight to `memcmp`
+- **Encoding-index equality check** as the first fast path in key comparison — avoids `rb_enc_compatible` on the common case of matching encodings
+- **Inline `RTYPEDDATA_DATA`** on hot methods (`[]`, `[]=`, `delete`, `key?`) — skips the type-check overhead of `TypedData_Get_Struct` on every operation
+- **Prefetch `slots[off]`** right after the control-byte load so DRAM fetch overlaps with SIMD match extraction
 
-### SwissHash Overhead
-- **C Extension boundaries**: Each lookup requires `TypedData_Get_Struct()` call and Ruby-C interface overhead
-- **Complex hash computation**: SwissHash uses sophisticated hashing (wyhash for strings, custom mixers) vs Ruby's simpler approach
-- **Two-level lookup**: Swiss Table's H1/H2 split requires additional bit manipulation and SIMD operations
-- **SIMD overhead**: NEON/SSE2 operations have setup costs that don't pay off for small group scans
-- **Additional equality checks**: `keys_equal()` function adds extra indirection compared to VM's direct comparison
-
-### Architecture Trade-offs
-- **Swiss Table design**: Optimized for high load factors and cache efficiency, but adds complexity to the critical lookup path  
-- **Group-based probing**: While theoretically faster, the overhead of SIMD operations and multiple memory accesses hurts performance for typical Ruby workloads
-- **Memory indirection**: SwissHash's separate control bytes array creates additional memory accesses vs Ruby Hash's integrated approach
-
-This explains why SwissHash excels at write-heavy operations (where its design advantages matter) but loses to Ruby's VM-optimized lookups.
+### Memory layout
+- Separate control-byte array and slot array (hashbrown-style) — the tight control array scans well through L1/L2
+- No zero-initialization of slot memory (`malloc` instead of `calloc`) — slots are only ever read after their control byte confirms they're live
 
 ## Build
 
@@ -120,22 +149,38 @@ This explains why SwissHash excels at write-heavy operations (where its design a
 rake compile
 ```
 
-## Analysis Tools
+## Benchmarking
+
+The included `benchmark.rb` produces statistically honest results:
+
+```bash
+bundle exec ruby benchmark.rb
+```
+
+Key features that make it trustworthy:
+- **Interleaved Ruby/SwissHash measurements** per iteration with alternating start order — thermal throttling and fluctuating background load hit both sides equally
+- **21 iterations with IQR-filtered mean** (trims top and bottom 25%) — more robust than median on noisy laptop hardware
+- **5 warmup runs** to settle JIT, caches, and branch predictor
+- **Per-side coefficient of variation** (`±X.X%`) displayed so you can distinguish a real 5% delta from 5% noise
+- **Correctness smoke test** runs before measurement
+
+### Profiling
 
-Project includes comprehensive benchmark with statistical validation:
+For profiling on macOS:
 
 ```bash
-ruby -Ilib benchmark.rb
+bundle exec ruby simp.rb            # runs infinite lookup loop, prints PID
+sample <PID> 60 -f /tmp/swiss.sample
+filtercalltree /tmp/swiss.sample | head -100
 ```
 
-The benchmark measures (with 7 iterations, 2 warmup, GC disabled):
-- Insert performance (sequential int, strings, random int)
-- Lookup performance (with 3x repetition for signal amplification)
-- Delete with reinsertion operations  
-- Mixed workloads (70/20/10 read/write/delete)
-- Memory usage and GC pressure analysis
+## Design References
 
-Results are statistically validated through multiple runs to ensure accuracy.
+- Matt Kulukundis, ["Designing a Fast, Efficient, Cache-friendly Hash Table, Step by Step"](https://www.youtube.com/watch?v=ncHmEUmJZf4) — CppCon 2017
+- [Abseil: SwissTables design](https://abseil.io/about/design/swisstables)
+- [rust-lang/hashbrown](https://github.com/rust-lang/hashbrown) — reference for SSE2/NEON/SWAR strategy choices
+- [Go 1.24 maps](https://go.dev/blog/swisstable) — probing and resize design trade-offs
+- Aria Beingessner, ["Swisstable, a Quick and Dirty Description"](https://faultlore.com/blah/hashbrown-tldr/) — implementer's notes
 
 ## License
 

data/ext/swiss_hash/swiss_hash.c

@@ -12,6 +12,12 @@
 #endif
 #endif
 
+#if defined(__GNUC__) || defined(__clang__)
+#define SH_PREFETCH(p) __builtin_prefetch((const void *)(p), 0, 1)
+#else
+#define SH_PREFETCH(p) ((void)0)
+#endif
+
 static uint64_t swiss_hash_seed0;
 static uint64_t swiss_hash_seed1;
 
@@ -115,7 +121,6 @@ static inline uint64_t wyhash(const void *data, size_t len, uint64_t seed) {
     return _wymix(s1 ^ len, _wymix(a ^ s1, b ^ seed));
 }
 
-#define GROUP_SIZE                8
 #define CTRL_EMPTY                0x80
 #define CTRL_DELETED              0xFE
 #define H2_MASK                   0x7F
@@ -126,31 +131,39 @@ static inline uint64_t wyhash(const void *data, size_t len, uint64_t seed) {
 #if defined(__x86_64__) || defined(_M_X64)
 #define SWISS_USE_SSE2 1
 #include <emmintrin.h>
+
+#define GROUP_SIZE  16
+#define GROUP_MASK  0xFFFFu
 #elif defined(__aarch64__) || defined(_M_ARM64)
 #define SWISS_USE_NEON 1
 #include <arm_neon.h>
+
+#define GROUP_SIZE  8
+#define GROUP_MASK  0xFFu
 #else
 #define SWISS_USE_PORTABLE 1
+#define GROUP_SIZE  8
+#define GROUP_MASK  0xFFu
 #endif
 
 #ifdef SWISS_USE_SSE2
 
 static inline __m128i ctrl_load(const uint8_t *ctrl) {
-    return _mm_loadl_epi64((const __m128i *)ctrl);
+    return _mm_loadu_si128((const __m128i *)ctrl);
 }
 
 static inline uint32_t ctrl_match_h2_vec(__m128i cv, uint8_t h2) {
     __m128i cmp = _mm_cmpeq_epi8(cv, _mm_set1_epi8((char)h2));
-    return (uint32_t)_mm_movemask_epi8(cmp) & 0xFF;
+    return (uint32_t)_mm_movemask_epi8(cmp);
 }
 
 static inline uint32_t ctrl_match_empty_vec(__m128i cv) {
     __m128i cmp = _mm_cmpeq_epi8(cv, _mm_set1_epi8((char)CTRL_EMPTY));
-    return (uint32_t)_mm_movemask_epi8(cmp) & 0xFF;
+    return (uint32_t)_mm_movemask_epi8(cmp);
 }
 
 static inline uint32_t ctrl_match_empty_or_deleted_vec(__m128i cv) {
-    return (uint32_t)_mm_movemask_epi8(cv) & 0xFF;
+    return (uint32_t)_mm_movemask_epi8(cv);
 }
 
 static inline uint32_t ctrl_match_empty(const uint8_t *ctrl) {
@@ -296,7 +309,7 @@ static inline uint64_t compute_hash(VALUE key) {
     if (RB_TYPE_P(key, T_STRING)) {
         const char *ptr = RSTRING_PTR(key);
         long len = RSTRING_LEN(key);
-        int enc_idx = rb_enc_get_index(key);
+        int enc_idx = ENCODING_GET(key);
         uint64_t str_seed = swiss_hash_seed0 ^ (uint64_t)enc_idx;
         return wyhash(ptr ? ptr : (const char *)"", (size_t)len, str_seed);
     }
@@ -315,21 +328,29 @@ static inline uint64_t compute_hash(VALUE key) {
 #define H2(hash) ((uint8_t)((hash) & H2_MASK))
 
 static inline int keys_equal(VALUE a, VALUE b) {
-    if (a == b)
-        return 1;
+    if (a == b) return 1;
+    if (FIXNUM_P(a) || SYMBOL_P(a) || SPECIAL_CONST_P(a)) return 0;
 
-    int ta = TYPE(a);
-    if (ta == T_FIXNUM || ta == T_SYMBOL)
-        return 0;
-
-    if (ta == T_STRING && RB_TYPE_P(b, T_STRING)) {
+    if (RB_TYPE_P(a, T_STRING) && RB_TYPE_P(b, T_STRING)) {
         long la = RSTRING_LEN(a);
-        long lb = RSTRING_LEN(b);
-        if (la != lb)
-            return 0;
+        if (la != RSTRING_LEN(b)) return 0;
+        const char *pa = RSTRING_PTR(a);
+        const char *pb = RSTRING_PTR(b);
+        if (pa == pb) return 1;
+
+        int ea = ENCODING_GET(a);
+        int eb = ENCODING_GET(b);
+        if (ea == eb) {
+            return memcmp(pa, pb, (size_t)la) == 0;
+        }
+
+        if (ENC_CODERANGE(a) == ENC_CODERANGE_7BIT &&
+            ENC_CODERANGE(b) == ENC_CODERANGE_7BIT) {
+            return memcmp(pa, pb, (size_t)la) == 0;
+        }
 
         if (rb_enc_compatible(a, b)) {
-            return memcmp(RSTRING_PTR(a), RSTRING_PTR(b), (size_t)la) == 0;
+            return memcmp(pa, pb, (size_t)la) == 0;
         }
         return rb_eql(a, b);
     }
@@ -338,8 +359,12 @@ static inline int keys_equal(VALUE a, VALUE b) {
 }
 
 static inline VALUE prepare_key(VALUE key) {
-    if (RB_TYPE_P(key, T_STRING) && !OBJ_FROZEN(key)) {
-        key = rb_str_new_frozen(key);
+    if (RB_TYPE_P(key, T_STRING)) {
+        if (!OBJ_FROZEN(key)) {
+            key = rb_str_new_frozen(key);
+        }
+
+        rb_enc_str_coderange(key);
     }
     return key;
 }
@@ -370,7 +395,7 @@ static void swiss_init(SwissHash *sh, size_t min_capacity) {
     sh->growth_left = capacity * MAX_LOAD_NUM / MAX_LOAD_DEN;
 
     sh->ctrl = (uint8_t *)malloc(capacity);
-    sh->slots = (Slot *)calloc(capacity, sizeof(Slot));
+    sh->slots = (Slot *)malloc(capacity * sizeof(Slot));
 
     if (!sh->ctrl || !sh->slots) {
         free(sh->ctrl);
@@ -414,13 +439,16 @@ static VALUE *swiss_lookup(SwissHash *sh, VALUE key) {
 
 #if defined(SWISS_USE_SSE2)
         __m128i cv = ctrl_load(sh->ctrl + off);
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_vec(cv, h2);
         uint32_t empty = ctrl_match_empty_vec(cv);
 #elif defined(SWISS_USE_NEON)
         uint8x8_t cv = ctrl_load(sh->ctrl + off);
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_vec(cv, h2);
         uint32_t empty = ctrl_match_empty_vec(cv);
 #else
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_raw(sh->ctrl + off, h2);
         uint32_t empty = ctrl_match_empty_raw(sh->ctrl + off);
 #endif
@@ -474,7 +502,7 @@ static void swiss_compact(SwissHash *sh) {
     Slot *old_slots = sh->slots;
 
     sh->ctrl = (uint8_t *)malloc(cap);
-    sh->slots = (Slot *)calloc(cap, sizeof(Slot));
+    sh->slots = (Slot *)malloc(cap * sizeof(Slot));
 
     if (!sh->ctrl || !sh->slots) {
         free(sh->ctrl);
@@ -523,11 +551,13 @@ static VALUE swiss_insert(SwissHash *sh, VALUE key, VALUE value) {
 
 #if defined(SWISS_USE_SSE2)
         __m128i cv = ctrl_load(sh->ctrl + off);
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_vec(cv, h2);
         uint32_t empty = ctrl_match_empty_vec(cv);
         uint32_t avail = ctrl_match_empty_or_deleted_vec(cv);
 #elif defined(SWISS_USE_NEON)
         uint8x8_t cv = ctrl_load(sh->ctrl + off);
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_vec(cv, h2);
         uint32_t empty = ctrl_match_empty_vec(cv);
         uint32_t avail = ctrl_match_empty_or_deleted_vec(cv);
@@ -581,13 +611,16 @@ static VALUE swiss_delete(SwissHash *sh, VALUE key) {
 
 #if defined(SWISS_USE_SSE2)
         __m128i cv = ctrl_load(sh->ctrl + off);
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_vec(cv, h2);
         uint32_t empty = ctrl_match_empty_vec(cv);
 #elif defined(SWISS_USE_NEON)
         uint8x8_t cv = ctrl_load(sh->ctrl + off);
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_vec(cv, h2);
         uint32_t empty = ctrl_match_empty_vec(cv);
 #else
+        SH_PREFETCH(&sh->slots[off]);
         uint32_t match = ctrl_match_h2_raw(sh->ctrl + off, h2);
         uint32_t empty = ctrl_match_empty_raw(sh->ctrl + off);
 #endif
@@ -627,7 +660,7 @@ static void swiss_grow(SwissHash *sh) {
     size_t new_cap = new_num_groups * GROUP_SIZE;
 
     sh->ctrl = (uint8_t *)malloc(new_cap);
-    sh->slots = (Slot *)calloc(new_cap, sizeof(Slot));
+    sh->slots = (Slot *)malloc(new_cap * sizeof(Slot));
 
     if (!sh->ctrl || !sh->slots) {
         free(sh->ctrl);
@@ -718,8 +751,7 @@ static VALUE swiss_hash_initialize(int argc, VALUE *argv, VALUE self) {
 }
 
 static VALUE swiss_hash_aset(VALUE self, VALUE key, VALUE value) {
-    SwissHash *sh;
-    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
     if (RB_UNLIKELY(!(FIXNUM_P(key) || SYMBOL_P(key)))) {
         key = prepare_key(key);
     }
@@ -727,15 +759,13 @@ static VALUE swiss_hash_aset(VALUE self, VALUE key, VALUE value) {
 }
 
 static VALUE swiss_hash_aref(VALUE self, VALUE key) {
-    SwissHash *sh;
-    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
     VALUE *val = swiss_lookup(sh, key);
     return val ? *val : Qnil;
 }
 
 static VALUE swiss_hash_delete(VALUE self, VALUE key) {
-    SwissHash *sh;
-    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
     return swiss_delete(sh, key);
 }
 
@@ -809,8 +839,7 @@ static VALUE swiss_hash_values(VALUE self) {
 }
 
 static VALUE swiss_hash_key_p(VALUE self, VALUE key) {
-    SwissHash *sh;
-    TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
+    SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
     VALUE *val = swiss_lookup(sh, key);
     return val ? Qtrue : Qfalse;
 }

data/lib/swiss_hash/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SwissHash
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swiss_hash
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Roman Haidarov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler