swiss_hash 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd83d549a02b9134baf31b4fa97b7eca44f370653cb1a3af0076f9d1196c1e15
-  data.tar.gz: 11a81f20822f58be2f18936e9a7e5bda112759868d91a8d7e2dcc1332bce598a
+  metadata.gz: 0c2f1e2b2c9e7a8ee0ba2b4ab30f7088eeeefdd1e56abc6fb92758bd5a667a64
+  data.tar.gz: 92904e400f7f16702a48c2966afc8c41b4e05aacd769fbd3ff9abd54d8cd5b53
 SHA512:
-  metadata.gz: 79009afb0d1ef895a975ac2ad10c612845f5e81e473e4476e9cb7a5732f482241a5ebb73427633aeecffaf3c516406e8f88c99c69d02da5db19c8ca1aa8db53d
-  data.tar.gz: 0736cadfdf1e688e4c47f29c120edc8c9eddc1602b9ab933fd740fd954db7af076ae1eea4f333028d2be8edf9e066ab7797a4dc1ec6faf91b7fd37a7f10f58bc
+  metadata.gz: e4a90125a2c8d4792299a7899331f14a0f285cb15fe497a5c53258641846f5811d8f07127cee8a3c0f698f35011a6a45190deeaa9149642fa36856ca04fc12fd
+  data.tar.gz: d93013782fc2df669c537d4f0907c2c398781ddf077afd79dc0ddce455f18476ba2e0dc798dd09637c21cb866eb4ceed06c63669b8e625c5f26c5ae48633ab55

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.1.4 - 2026-10-28
+
+- Prevented reentrant Fixnum insertion and `clear`/`initialize` from modifying a table during hash callbacks.
+- Made reinitialization preserve the existing table if capacity validation or allocation fails; rejected overflowing capacities.
+- Made `replace` with itself a no-op and kept contents intact when the replacement cannot convert to a Hash.
+- Updated benchmark memory reporting to compare container storage and directly retained keys/values for Ruby Hash and SwissHash.
+- Refreshed README timings and memory results for Ruby 3.4.3 / arm64-darwin24.
+
+## 0.1.3 - 2026-08-18
+
+- NEON group matching on ARM64 (SSE2 on x86_64, SWAR elsewhere)
+- Single allocation for control bytes and slots
+- Faster Fixnum `[]` / `[]=`
+- 7-bit strings of different encodings hash like Ruby Hash (`"abc"` and `"abc".b` are the same key)
+- Rehash is GC-safe; `#hash` / `#eql?` that mutate the same table raise instead of corrupting it
+- `initialize` no longer leaks on reuse; OOM no longer leaves a half-built table
+
 ## 0.1.2 - Unreleased
 
 Documentation and API polish for the first public release candidate.

data/README.md

@@ -33,63 +33,63 @@ Methodology: 10 runs × 21 measured iterations, 5 warmup iterations per run, IQR
 
 | Operation | Ruby Hash | SwissHash | Delta |
 |---|---:|---:|---:|
-| Insert (sequential int) | 6.324 ms (±0.5%) | 5.023 ms (±0.6%) | **−20.57%** ⚡ |
-| Insert (string keys) | 16.485 ms (±4.6%) | 10.386 ms (±3.0%) | **−37.00%** ⚡ |
-| Insert (random int) | 5.963 ms (±1.2%) | 5.010 ms (±1.0%) | **−15.98%** ⚡ |
-| Lookup (sequential int, 3x) | 13.281 ms (±0.1%) | 11.116 ms (±0.1%) | **−16.31%** ⚡ |
-| Lookup (string keys, 3x) | 20.561 ms (±3.8%) | 21.535 ms (±4.9%) | +4.74% |
-| Delete + reinsert 25% | 8.965 ms (±0.7%) | 7.164 ms (±0.8%) | **−20.09%** ⚡ |
-| Mixed (70% read / 20% write / 10% delete) | 21.784 ms (±0.2%) | 18.990 ms (±0.3%) | **−12.83%** ⚡ |
+| Insert (sequential int) | 6.412 ms (±0.5%) | 4.973 ms (±0.7%) | **−22.44%** ⚡ |
+| Insert (string keys) | 16.130 ms (±0.2%) | 10.470 ms (±0.2%) | **−35.09%** ⚡ |
+| Insert (random int) | 5.994 ms (±0.6%) | 4.763 ms (±0.8%) | **−20.55%** ⚡ |
+| Lookup (sequential int, 3x) | 12.204 ms (±0.1%) | 11.050 ms (±0.1%) | **−9.46%** ⚡ |
+| Lookup (string keys, 3x) | 20.465 ms (±0.2%) | 20.322 ms (±0.2%) | **−0.70%** ⚡ |
+| Delete + reinsert 25% | 8.968 ms (±0.3%) | 7.075 ms (±0.4%) | **−21.10%** ⚡ |
+| Mixed (70/20/10 R/W/D) | 22.168 ms (±0.3%) | 18.818 ms (±0.1%) | **−15.11%** ⚡ |
 
 ### N = 10,000
 
 | Operation | Ruby Hash | SwissHash | Delta |
 |---|---:|---:|---:|
-| Insert (sequential int) | 0.578 ms (±1.1%) | 0.510 ms (±1.1%) | **−11.82%** ⚡ |
-| Insert (string keys) | 1.522 ms (±3.5%) | 0.992 ms (±1.6%) | **−34.80%** ⚡ |
-| Insert (random int) | 0.554 ms (±2.0%) | 0.501 ms (±2.5%) | **−9.53%** ⚡ |
-| Lookup (sequential int, 3x) | 1.071 ms (±0.3%) | 1.065 ms (±0.1%) | −0.55% |
-| Lookup (string keys, 3x) | 1.710 ms (±1.3%) | 1.563 ms (±1.4%) | **−8.58%** ⚡ |
-| Delete + reinsert 25% | 0.814 ms (±1.6%) | 0.714 ms (±1.2%) | **−12.29%** ⚡ |
-| Mixed (70% read / 20% write / 10% delete) | 1.988 ms (±0.4%) | 1.869 ms (±0.5%) | **−5.98%** ⚡ |
+| Insert (sequential int) | 0.577 ms (±1.2%) | 0.499 ms (±1.5%) | **−13.58%** ⚡ |
+| Insert (string keys) | 1.479 ms (±1.6%) | 1.001 ms (±1.3%) | **−32.30%** ⚡ |
+| Insert (random int) | 0.541 ms (±1.9%) | 0.470 ms (±2.2%) | **−13.10%** ⚡ |
+| Lookup (sequential int, 3x) | 1.069 ms (±0.2%) | 1.035 ms (±0.2%) | **−3.22%** ⚡ |
+| Lookup (string keys, 3x) | 1.692 ms (±0.4%) | 1.550 ms (±0.4%) | **−8.42%** ⚡ |
+| Delete + reinsert 25% | 0.808 ms (±0.9%) | 0.701 ms (±0.7%) | **−13.33%** ⚡ |
+| Mixed (70/20/10 R/W/D) | 1.979 ms (±0.6%) | 1.829 ms (±0.8%) | **−7.62%** ⚡ |
 
 ### N = 1,000
 
-Ruby Hash uses an AR-table for small hashes, so very small integer-keyed workloads can still favour the built-in implementation. String-heavy workloads continue to be the strongest SwissHash case.
-
 | Operation | Ruby Hash | SwissHash | Delta |
 |---|---:|---:|---:|
-| Insert (sequential int) | 0.056 ms (±0.7%) | 0.057 ms (±0.9%) | +1.88% |
-| Insert (string keys) | 0.156 ms (±2.5%) | 0.102 ms (±0.9%) | **−34.78%** ⚡ |
-| Insert (random int) | 0.054 ms (±3.5%) | 0.051 ms (±3.4%) | −6.54% |
-| Lookup (sequential int, 3x) | 0.111 ms (±0.4%) | 0.111 ms (±0.2%) | +0.29% |
-| Lookup (string keys, 3x) | 0.181 ms (±0.3%) | 0.150 ms (±0.4%) | **−17.10%** ⚡ |
-| Delete + reinsert 25% | 0.082 ms (±0.9%) | 0.079 ms (±0.5%) | −4.12% |
-| Mixed (70% read / 20% write / 10% delete) | 0.202 ms (±0.3%) | 0.197 ms (±0.2%) | −2.04% |
+| Insert (sequential int) | 0.057 ms (±0.8%) | 0.053 ms (±1.3%) | **−6.53%** ⚡ |
+| Insert (string keys) | 0.154 ms (±2.7%) | 0.103 ms (±0.9%) | **−32.69%** ⚡ |
+| Insert (random int) | 0.054 ms (±1.4%) | 0.049 ms (±1.1%) | **−9.27%** ⚡ |
+| Lookup (sequential int, 3x) | 0.110 ms (±0.5%) | 0.106 ms (±0.4%) | **−3.73%** ⚡ |
+| Lookup (string keys, 3x) | 0.177 ms (±0.5%) | 0.151 ms (±0.4%) | **−14.37%** ⚡ |
+| Delete + reinsert 25% | 0.081 ms (±0.8%) | 0.074 ms (±1.1%) | **−8.42%** ⚡ |
+| Mixed (70/20/10 R/W/D) | 0.203 ms (±0.2%) | 0.191 ms (±0.3%) | **−5.88%** ⚡ |
 
 ### Summary
 
-- SwissHash is faster on **6 of 7 operations** at N=100k in the current benchmark run.
-- The strongest win is still string-key insertion: **−34% to −37%** across tested sizes.
-- Large integer-keyed inserts, delete/reinsert churn, and mixed workloads improved substantially after moving more Hash-like operations into C and keeping the hot paths lean.
-- String lookups are workload-sensitive: SwissHash wins at N=1k and N=10k, while the N=100k run is slightly slower than Ruby Hash within a noisier test band.
+- SwissHash is faster on all seven listed operations at N=100k; string lookup is within 1% of Ruby Hash.
+- The strongest win is string-key insertion: **−32% to −35%** across tested sizes.
+- ARM64 uses the NEON group-matching path (`stats[:simd] => "NEON"`).
 - Ruby's built-in `Hash` remains excellent, especially for very small maps and cases that benefit from VM-level Hash specialization.
 
 ### Memory Usage
 
-For 100,000 integer keys in the current benchmark:
+For 100,000 entries, `ObjectSpace.memsize_of` reports the hash object/table and directly retained key/value objects. Integer keys and values are immediate values, so they add no separate object bytes. For string-key tests, stored string keys are counted; the shared input array and source strings are excluded from both totals.
 
-| Implementation | Reported memory |
-|---|---:|
-| SwissHash | 2,176 KB native + 4 GC slots |
-| Ruby Hash | 3 GC slots; native memory not directly measurable from this benchmark |
+| Workload | Implementation | Container | Referenced keys/values | Total |
+|---|---|---:|---:|---:|
+| Integer keys and values | SwissHash | 2,176.1 KiB | 0.0 KiB | 2,176.1 KiB |
+| Integer keys and values | Ruby Hash | 4,096.2 KiB | 0.0 KiB | 4,096.2 KiB |
+| String keys and integer values | SwissHash | 2,176.1 KiB | 6,408.1 KiB | 8,584.2 KiB |
+| String keys and integer values | Ruby Hash | 4,096.2 KiB | 6,408.1 KiB | 10,504.3 KiB |
 
-Additional stats: load factor 76.3%, max load factor 87.5%, SIMD path reported as SWAR on the benchmark machine.
+SwissHash uses 46.87% less measured memory for integer entries and 18.28% less for string-key entries. The measurement excludes allocator fragmentation and objects reachable only through nested values. Load factor: 76.3%; max load factor: 87.5%; SIMD path: NEON.
 
 ## Features
 
 - **Swiss Table probing**: 7-bit `H2` metadata, group probing, triangular probe sequence, and 87.5% max load factor.
-- **Fast string-key path**: wyhash for string keys, frozen string key preparation, ASCII-7bit equality shortcut, and direct `memcmp` when encodings are compatible.
+- **SIMD group matching**: SSE2 on x86_64, NEON on aarch64, SWAR fallback elsewhere.
+- **Fast string-key path**: wyhash for string keys, frozen string key preparation, 7-bit strings of different encodings hash/compare like Ruby Hash, and direct `memcmp` when encodings are compatible.
 - **Low GC pressure**: keys and values are Ruby objects, while control bytes and slots live in contiguous native arrays.
 - **Delete/reinsert friendly**: tombstones are tracked and compacted to avoid pathological slowdown.
 - **Hash-like API**: basic accessors, enumeration, fetch helpers, merge/update/replace, filtering, transforming, slicing, inversion, and conversion helpers.
@@ -200,7 +200,7 @@ Stick with Ruby's built-in `Hash` when:
 ### Swiss Table core
 
 - **Open addressing** with 7-bit `H2` metadata byte per slot; group matching rejects non-matching slots in batches.
-- **Group size 16 on SSE2** and **group size 8 on portable SWAR**. On the benchmarked Apple Silicon machine the active path is SWAR.
+- **Group size 16 on SSE2 (x86_64) and NEON (aarch64)**, **group size 8 on portable SWAR**. The active path is printed by `stats[:simd]` / the benchmark memory section (`NEON` on Apple Silicon).
 - **Triangular probing** — `i(i+1)/2` — over power-of-two group counts.
 - **Max load factor 87.5%** (7/8).
 
@@ -215,7 +215,7 @@ Stick with Ruby's built-in `Hash` when:
 
 ### Memory layout
 
-- Separate control-byte array and slot array.
+- One native allocation for control bytes followed by slots (16-byte aligned). `stats[:memory_bytes]` still counts `capacity * (1 + sizeof(Slot))`.
 - Native arrays are allocated outside Ruby's object heap; keys and values are still marked for GC.
 - Slot memory is not zero-initialized on allocation; slots are read only after their control byte marks them live.
 
@@ -231,6 +231,7 @@ bundle exec rake compile
 ```bash
 bundle exec ruby test/hash_api_test.rb
 bundle exec ruby test/string_key_mutation_test.rb
+bundle exec ruby test/safety_and_encoding_test.rb
 ```
 
 ## Benchmarking

data/ext/swiss_hash/swiss_hash.c

@@ -146,36 +146,77 @@ 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 16
 #else
 #define SWISS_USE_SWAR 1
 #define GROUP_SIZE     8
-#define GROUP_MASK     0xFFu
+#endif
+
+#if defined(SWISS_USE_SSE2) || defined(SWISS_USE_NEON)
+#define SWISS_USE_VEC 1
 #endif
 
 #ifdef SWISS_USE_SSE2
 
-static inline __m128i ctrl_load(const uint8_t *ctrl) {
+typedef __m128i ctrl_vec_t;
+
+SH_ALWAYS_INLINE ctrl_vec_t ctrl_load(const uint8_t *ctrl) {
     return _mm_loadu_si128((const __m128i *)ctrl);
 }
 
-static inline uint32_t ctrl_match_h2_vec(__m128i cv, uint8_t h2) {
+SH_ALWAYS_INLINE uint32_t ctrl_match_h2_vec(ctrl_vec_t cv, uint8_t h2) {
     __m128i cmp = _mm_cmpeq_epi8(cv, _mm_set1_epi8((char)h2));
     return (uint32_t)_mm_movemask_epi8(cmp);
 }
 
-static inline uint32_t ctrl_match_empty_vec(__m128i cv) {
+SH_ALWAYS_INLINE uint32_t ctrl_match_empty_vec(ctrl_vec_t cv) {
     __m128i cmp = _mm_cmpeq_epi8(cv, _mm_set1_epi8((char)CTRL_EMPTY));
     return (uint32_t)_mm_movemask_epi8(cmp);
 }
 
-static inline uint32_t ctrl_match_empty_or_deleted_vec(__m128i cv) {
+SH_ALWAYS_INLINE uint32_t ctrl_match_empty_or_deleted_vec(ctrl_vec_t cv) {
     return (uint32_t)_mm_movemask_epi8(cv);
 }
 
-static inline uint32_t ctrl_match_empty(const uint8_t *ctrl) {
+SH_ALWAYS_INLINE uint32_t ctrl_match_empty(const uint8_t *ctrl) {
+    return ctrl_match_empty_vec(ctrl_load(ctrl));
+}
+
+#elif defined(SWISS_USE_NEON)
+
+typedef uint8x16_t ctrl_vec_t;
+typedef uint64_t ctrl_mask_t;
+
+#define CTRL_MASK_SLOT(m) ((int)(ctz64(m) >> 2))
+#define NEON_NIBBLE_MASK 0x1111111111111111ULL
+
+SH_ALWAYS_INLINE ctrl_mask_t neon_mask64(uint8x16_t cmp) {
+    /* 4 bits per slot (0x0 / 0xF); keep one bit per nibble so mask &= mask-1 works. */
+    uint64_t packed = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(cmp), 4)), 0);
+    return packed & NEON_NIBBLE_MASK;
+}
+
+SH_ALWAYS_INLINE ctrl_vec_t ctrl_load(const uint8_t *ctrl) {
+    return vld1q_u8(ctrl);
+}
+
+SH_ALWAYS_INLINE ctrl_mask_t ctrl_match_h2_vec(ctrl_vec_t cv, uint8_t h2) {
+    return neon_mask64(vceqq_u8(cv, vdupq_n_u8(h2)));
+}
+
+SH_ALWAYS_INLINE ctrl_mask_t ctrl_match_empty_vec(ctrl_vec_t cv) {
+    return neon_mask64(vceqq_u8(cv, vdupq_n_u8((uint8_t)CTRL_EMPTY)));
+}
+
+SH_ALWAYS_INLINE ctrl_mask_t ctrl_match_empty_or_deleted_vec(ctrl_vec_t cv) {
+    return neon_mask64(vcltzq_s8(vreinterpretq_s8_u8(cv)));
+}
+
+SH_ALWAYS_INLINE ctrl_mask_t ctrl_match_empty(const uint8_t *ctrl) {
     return ctrl_match_empty_vec(ctrl_load(ctrl));
 }
 
@@ -216,6 +257,14 @@ SH_ALWAYS_INLINE uint32_t ctrl_match_empty(const uint8_t *ctrl) {
 
 #endif /* control-byte matching selection */
 
+#ifndef CTRL_MASK_SLOT
+typedef uint32_t ctrl_mask_t;
+#define CTRL_MASK_SLOT(m) ctz32(m)
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+__attribute__((unused))
+#endif
 SH_ALWAYS_INLINE int ctz32(uint32_t v) {
 #if defined(__GNUC__) || defined(__clang__)
     return __builtin_ctz(v);
@@ -233,6 +282,21 @@ SH_ALWAYS_INLINE int ctz32(uint32_t v) {
 #endif
 }
 
+SH_ALWAYS_INLINE int ctz64(uint64_t v) {
+#if defined(__GNUC__) || defined(__clang__)
+    return (int)__builtin_ctzll(v);
+#elif defined(_MSC_VER)
+    unsigned long idx;
+    _BitScanForward64(&idx, v);
+    return (int)idx;
+#else
+    if ((uint32_t)v) {
+        return ctz32((uint32_t)v);
+    }
+    return 32 + ctz32((uint32_t)(v >> 32));
+#endif
+}
+
 typedef struct {
     VALUE key;
     VALUE value;
@@ -250,44 +314,49 @@ typedef struct {
     uint8_t mutating;
 } SwissHash;
 
-#define MUTATE_GUARD_BEGIN(sh)                                                               \
-    do {                                                                                     \
-        if ((sh)->mutating) {                                                                \
-            rb_raise(rb_eRuntimeError, "SwissHash: reentrant modification detected "         \
-                                       "(#hash or #eql? callback modified the same table)"); \
-        }                                                                                    \
-        (sh)->mutating = 1;                                                                  \
-    } while (0)
-
-#define MUTATE_GUARD_END(sh) \
-    do {                     \
-        (sh)->mutating = 0;  \
-    } while (0)
-
 #define FIBONACCI_HASH_C 0x9E3779B97F4A7C15ULL
 
-SH_ALWAYS_INLINE uint64_t compute_hash(VALUE key) {
-    uint64_t v;
+SH_ALWAYS_INLINE uint64_t hash_fixnum(VALUE key) {
+    return ((uint64_t)FIX2LONG(key) ^ swiss_hash_seed0) * FIBONACCI_HASH_C;
+}
 
+SH_ALWAYS_INLINE uint64_t hash_immediate(VALUE key) {
     if (FIXNUM_P(key)) {
-        v = (uint64_t)FIX2LONG(key) ^ swiss_hash_seed0;
-        return v * FIBONACCI_HASH_C;
+        return hash_fixnum(key);
     }
+    return ((uint64_t)SYM2ID(key) ^ swiss_hash_seed0) * FIBONACCI_HASH_C;
+}
 
-    if (SYMBOL_P(key)) {
-        v = (uint64_t)SYM2ID(key) ^ swiss_hash_seed0;
-        return v * FIBONACCI_HASH_C;
+SH_ALWAYS_INLINE uint64_t hash_string(VALUE key) {
+    const char *ptr = RSTRING_PTR(key);
+    long len = RSTRING_LEN(key);
+    uint64_t seed = swiss_hash_seed0;
+
+    if (len > 0) {
+        int enc = ENCODING_GET(key);
+        if (enc) {
+            int cr = ENC_CODERANGE(key);
+            if (cr == ENC_CODERANGE_UNKNOWN) {
+                cr = rb_enc_str_coderange(key);
+            }
+            if (cr != ENC_CODERANGE_7BIT) {
+                seed ^= (uint64_t)enc;
+            }
+        }
+    }
+    return wyhash(ptr ? ptr : (const char *)"", (size_t)len, seed);
+}
+
+SH_ALWAYS_INLINE uint64_t compute_hash(VALUE key) {
+    if (FIXNUM_P(key) || SYMBOL_P(key)) {
+        return hash_immediate(key);
     }
 
     if (RB_TYPE_P(key, T_STRING)) {
-        const char *ptr = RSTRING_PTR(key);
-        long len = RSTRING_LEN(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);
+        return hash_string(key);
     }
 
-    v = (uint64_t)NUM2LONG(rb_hash(key));
+    uint64_t v = (uint64_t)NUM2LONG(rb_hash(key));
     v ^= swiss_hash_seed1;
     v ^= v >> 33;
     v *= 0xff51afd7ed558ccdULL;
@@ -300,6 +369,32 @@ SH_ALWAYS_INLINE uint64_t compute_hash(VALUE key) {
 #define H1(hash) ((hash) >> 7)
 #define H2(hash) ((uint8_t)((hash) & H2_MASK))
 
+SH_ALWAYS_INLINE int strings_equal(VALUE a, VALUE b) {
+    long la = RSTRING_LEN(a);
+    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(pa, pb, (size_t)la) == 0;
+    }
+    return rb_eql(a, b);
+}
+
 SH_ALWAYS_INLINE int keys_equal(VALUE a, VALUE b) {
     if (a == b)
         return 1;
@@ -307,28 +402,7 @@ SH_ALWAYS_INLINE int keys_equal(VALUE a, VALUE b) {
         return 0;
 
     if (RB_TYPE_P(a, T_STRING) && RB_TYPE_P(b, T_STRING)) {
-        long la = RSTRING_LEN(a);
-        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(pa, pb, (size_t)la) == 0;
-        }
-        return rb_eql(a, b);
+        return strings_equal(a, b);
     }
 
     return rb_eql(a, b);
@@ -345,28 +419,64 @@ SH_ALWAYS_INLINE VALUE prepare_key(VALUE key) {
             key = rb_str_new_frozen(key);
         }
 #endif
-        rb_enc_str_coderange(key);
     }
     return key;
 }
 
+SH_ALWAYS_INLINE size_t swiss_ctrl_bytes(size_t capacity) {
+    return (capacity + 15u) & ~(size_t)15u;
+}
+
+static int swiss_alloc_block(size_t capacity, uint8_t **ctrl, Slot **slots) {
+    if (capacity == 0 || capacity > (SIZE_MAX / (sizeof(Slot) + 16))) {
+        return 0;
+    }
+    size_t ctrl_bytes = swiss_ctrl_bytes(capacity);
+    if (capacity > (SIZE_MAX - ctrl_bytes) / sizeof(Slot)) {
+        return 0;
+    }
+    uint8_t *block = (uint8_t *)malloc(ctrl_bytes + capacity * sizeof(Slot));
+    if (!block) {
+        return 0;
+    }
+    *ctrl = block;
+    *slots = (Slot *)(block + ctrl_bytes);
+    return 1;
+}
+
 static void swiss_free_arrays(SwissHash *sh) {
     free(sh->ctrl);
     sh->ctrl = NULL;
-    free(sh->slots);
     sh->slots = NULL;
 }
 
 static void swiss_init(SwissHash *sh, size_t min_capacity) {
-    size_t min_groups = (min_capacity + GROUP_SIZE - 1) / GROUP_SIZE;
+    size_t min_groups = min_capacity / GROUP_SIZE + (min_capacity % GROUP_SIZE != 0);
     size_t num_groups = 1;
-    while (num_groups < min_groups)
+    while (num_groups < min_groups) {
+        if (num_groups > SIZE_MAX / 2) {
+            rb_raise(rb_eArgError, "SwissHash capacity is too large");
+        }
         num_groups <<= 1;
+    }
     if (num_groups < 2)
         num_groups = 2;
 
+    if (num_groups > SIZE_MAX / GROUP_SIZE) {
+        rb_raise(rb_eArgError, "SwissHash capacity is too large");
+    }
     size_t capacity = num_groups * GROUP_SIZE;
+    uint8_t *ctrl = NULL;
+    Slot *slots = NULL;
 
+    if (!swiss_alloc_block(capacity, &ctrl, &slots)) {
+        rb_raise(rb_eNoMemError, "failed to allocate SwissHash");
+    }
+
+    memset(ctrl, CTRL_EMPTY, capacity);
+    uint8_t *old_ctrl = sh->ctrl;
+    sh->ctrl = ctrl;
+    sh->slots = slots;
     sh->num_groups = num_groups;
     sh->group_mask = num_groups - 1;
     sh->capacity = capacity;
@@ -374,19 +484,7 @@ static void swiss_init(SwissHash *sh, size_t min_capacity) {
     sh->tombstone_count = 0;
     sh->mutating = 0;
     sh->growth_left = capacity * MAX_LOAD_NUM / MAX_LOAD_DEN;
-
-    sh->ctrl = (uint8_t *)malloc(capacity);
-    sh->slots = (Slot *)malloc(capacity * sizeof(Slot));
-
-    if (!sh->ctrl || !sh->slots) {
-        free(sh->ctrl);
-        free(sh->slots);
-        sh->ctrl = NULL;
-        sh->slots = NULL;
-        rb_raise(rb_eNoMemError, "failed to allocate SwissHash");
-    }
-
-    memset(sh->ctrl, CTRL_EMPTY, capacity);
+    free(old_ctrl);
 }
 
 typedef struct {
@@ -410,28 +508,75 @@ SH_ALWAYS_INLINE void probe_next(ProbeSeq *ps) {
 
 #define GROUP_OFF(gi) ((gi) * GROUP_SIZE)
 
-static VALUE *swiss_lookup(SwissHash *sh, VALUE key) {
-    uint64_t hash = compute_hash(key);
+#ifdef SWISS_USE_VEC
+#define SH_SCAN_GROUP(sh, off, h2, match, empty)            \
+    do {                                                    \
+        ctrl_vec_t cv = ctrl_load((sh)->ctrl + (off));      \
+        SH_PREFETCH(&(sh)->slots[off]);                     \
+        (match) = ctrl_match_h2_vec(cv, (h2));              \
+        (empty) = ctrl_match_empty_vec(cv);                 \
+    } while (0)
+#define SH_SCAN_GROUP_INSERT(sh, off, h2, match, empty, avail) \
+    do {                                                       \
+        ctrl_vec_t cv = ctrl_load((sh)->ctrl + (off));         \
+        SH_PREFETCH(&(sh)->slots[off]);                        \
+        (match) = ctrl_match_h2_vec(cv, (h2));                 \
+        (empty) = ctrl_match_empty_vec(cv);                    \
+        (avail) = ctrl_match_empty_or_deleted_vec(cv);         \
+    } while (0)
+#else
+#define SH_SCAN_GROUP(sh, off, h2, match, empty)            \
+    do {                                                    \
+        SH_PREFETCH(&(sh)->slots[off]);                     \
+        (match) = ctrl_match_h2_raw((sh)->ctrl + (off), (h2)); \
+        (empty) = ctrl_match_empty_raw((sh)->ctrl + (off)); \
+    } while (0)
+#define SH_SCAN_GROUP_INSERT(sh, off, h2, match, empty, avail) \
+    do {                                                       \
+        SH_PREFETCH(&(sh)->slots[off]);                        \
+        (match) = ctrl_match_h2_raw((sh)->ctrl + (off), (h2)); \
+        (empty) = ctrl_match_empty_raw((sh)->ctrl + (off));    \
+        (avail) = ctrl_match_empty_or_deleted_raw((sh)->ctrl + (off)); \
+    } while (0)
+#endif
+
+static inline VALUE *swiss_lookup_hashed(SwissHash *sh, VALUE key, uint64_t hash, int identity_only) {
     uint8_t h2 = H2(hash);
     ProbeSeq ps = probe_start(H1(hash), sh->group_mask);
 
     for (;;) {
         size_t off = GROUP_OFF(ps.group_idx);
+        ctrl_mask_t match, empty;
+        SH_SCAN_GROUP(sh, off, h2, match, empty);
+
+        while (match) {
+            int slot = CTRL_MASK_SLOT(match);
+            Slot *s = &sh->slots[off + slot];
+            if (RB_LIKELY(s->key == key) || (!identity_only && keys_equal(s->key, key))) {
+                return &s->value;
+            }
+            match &= match - 1;
+        }
+
+        if (empty)
+            return NULL;
+        probe_next(&ps);
+    }
+}
+
+static inline VALUE *swiss_lookup_string(SwissHash *sh, VALUE key, uint64_t hash) {
+    uint8_t h2 = H2(hash);
+    ProbeSeq ps = probe_start(H1(hash), sh->group_mask);
+
+    for (;;) {
+        size_t off = GROUP_OFF(ps.group_idx);
+        ctrl_mask_t match, empty;
+        SH_SCAN_GROUP(sh, off, h2, match, empty);
 
-#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);
-#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
         while (match) {
-            int slot = ctz32(match);
+            int slot = CTRL_MASK_SLOT(match);
             Slot *s = &sh->slots[off + slot];
-            if (RB_LIKELY(s->key == key) || keys_equal(s->key, key)) {
+            if (RB_LIKELY(s->key == key) || (RB_TYPE_P(s->key, T_STRING) && strings_equal(s->key, key))) {
                 return &s->value;
             }
             match &= match - 1;
@@ -443,23 +588,75 @@ static VALUE *swiss_lookup(SwissHash *sh, VALUE key) {
     }
 }
 
+typedef struct {
+    SwissHash *sh;
+    VALUE key;
+    VALUE value;
+    VALUE result;
+    VALUE *found;
+} CallbackCtx;
+
+SH_ALWAYS_INLINE int key_may_callback(VALUE key) {
+    return !(FIXNUM_P(key) || SYMBOL_P(key) || RB_TYPE_P(key, T_STRING));
+}
+
+static void swiss_lock(SwissHash *sh) {
+    if (sh->mutating) {
+        rb_raise(rb_eRuntimeError, "SwissHash: reentrant modification detected "
+                                   "(#hash or #eql? callback modified the same table)");
+    }
+    sh->mutating = 1;
+}
+
+static VALUE swiss_unlock_ensure(VALUE shv) {
+    ((SwissHash *)shv)->mutating = 0;
+    return Qnil;
+}
+
+static VALUE swiss_lookup_custom(VALUE arg) {
+    CallbackCtx *c = (CallbackCtx *)arg;
+    c->found = swiss_lookup_hashed(c->sh, c->key, compute_hash(c->key), 0);
+    return Qnil;
+}
+
+static inline VALUE *swiss_lookup(SwissHash *sh, VALUE key) {
+    if (FIXNUM_P(key)) {
+        return swiss_lookup_hashed(sh, key, hash_fixnum(key), 1);
+    }
+    if (SYMBOL_P(key)) {
+        return swiss_lookup_hashed(sh, key, hash_immediate(key), 1);
+    }
+    if (RB_TYPE_P(key, T_STRING)) {
+        return swiss_lookup_string(sh, key, hash_string(key));
+    }
+    if (sh->mutating) {
+        return swiss_lookup_hashed(sh, key, compute_hash(key), 0);
+    }
+    CallbackCtx ctx = {sh, key, Qnil, Qnil, NULL};
+    swiss_lock(sh);
+    rb_ensure(swiss_lookup_custom, (VALUE)&ctx, swiss_unlock_ensure, (VALUE)sh);
+    return ctx.found;
+}
+
 static void swiss_grow(SwissHash *sh);
 static void swiss_compact(SwissHash *sh);
 
-SH_ALWAYS_INLINE void swiss_insert_rehash(SwissHash *sh, uint64_t hash, VALUE key, VALUE value) {
+SH_ALWAYS_INLINE void swiss_insert_rehash_into(uint8_t *ctrl, Slot *slots, size_t group_mask,
+                                               size_t *size, size_t *growth_left,
+                                               uint64_t hash, VALUE key, VALUE value) {
     uint8_t h2 = H2(hash);
-    ProbeSeq ps = probe_start(H1(hash), sh->group_mask);
+    ProbeSeq ps = probe_start(H1(hash), group_mask);
 
     for (;;) {
         size_t off = GROUP_OFF(ps.group_idx);
-        uint32_t empty_mask = ctrl_match_empty(sh->ctrl + off);
+        ctrl_mask_t empty_mask = ctrl_match_empty(ctrl + off);
         if (empty_mask) {
-            size_t idx = off + ctz32(empty_mask);
-            sh->ctrl[idx] = h2;
-            sh->slots[idx].key = key;
-            sh->slots[idx].value = value;
-            sh->size++;
-            sh->growth_left--;
+            size_t idx = off + (size_t)CTRL_MASK_SLOT(empty_mask);
+            ctrl[idx] = h2;
+            slots[idx].key = key;
+            slots[idx].value = value;
+            (*size)++;
+            (*growth_left)--;
             return;
         }
         probe_next(&ps);
@@ -470,44 +667,87 @@ static inline int should_compact(SwissHash *sh) {
     return sh->tombstone_count >= sh->capacity / TOMBSTONE_COMPACT_DIVISOR;
 }
 
-static void swiss_compact(SwissHash *sh) {
-    size_t cap = sh->capacity;
-    size_t old_size = sh->size;
-
-    uint8_t *old_ctrl = sh->ctrl;
-    Slot *old_slots = sh->slots;
+typedef struct {
+    SwissHash *sh;
+    uint8_t *new_ctrl;
+    Slot *new_slots;
+    const uint8_t *old_ctrl;
+    const Slot *old_slots;
+    size_t old_cap;
+    size_t new_cap;
+    size_t new_num_groups;
+} RebuildCtx;
+
+static VALUE swiss_rebuild_body(VALUE arg) {
+    RebuildCtx *ctx = (RebuildCtx *)arg;
+    size_t group_mask = ctx->new_num_groups - 1;
+    size_t size = 0;
+    size_t growth_left = ctx->new_cap * MAX_LOAD_NUM / MAX_LOAD_DEN;
+
+    for (size_t i = 0; i < ctx->old_cap; i++) {
+        uint8_t c = ctx->old_ctrl[i];
+        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
+            VALUE key = ctx->old_slots[i].key;
+            uint64_t hash = FIXNUM_P(key) ? hash_fixnum(key) : compute_hash(key);
+            swiss_insert_rehash_into(ctx->new_ctrl, ctx->new_slots, group_mask,
+                                     &size, &growth_left, hash, key, ctx->old_slots[i].value);
+        }
+    }
 
-    sh->ctrl = (uint8_t *)malloc(cap);
-    sh->slots = (Slot *)malloc(cap * sizeof(Slot));
+    free(ctx->sh->ctrl);
+    ctx->sh->ctrl = ctx->new_ctrl;
+    ctx->sh->slots = ctx->new_slots;
+    ctx->sh->num_groups = ctx->new_num_groups;
+    ctx->sh->group_mask = group_mask;
+    ctx->sh->capacity = ctx->new_cap;
+    ctx->sh->size = size;
+    ctx->sh->growth_left = growth_left;
+    ctx->sh->tombstone_count = 0;
+    ctx->new_ctrl = NULL;
+    ctx->new_slots = NULL;
+    return Qnil;
+}
 
-    if (!sh->ctrl || !sh->slots) {
-        free(sh->ctrl);
-        free(sh->slots);
-        sh->ctrl = old_ctrl;
-        sh->slots = old_slots;
-        sh->size = old_size;
-        sh->growth_left = 0;
-        rb_raise(rb_eNoMemError, "failed to compact SwissHash");
+static VALUE swiss_rebuild_ensure(VALUE arg) {
+    RebuildCtx *ctx = (RebuildCtx *)arg;
+    if (ctx->new_ctrl) {
+        free(ctx->new_ctrl);
+        ctx->new_ctrl = NULL;
+        ctx->new_slots = NULL;
     }
+    return Qnil;
+}
 
-    memset(sh->ctrl, CTRL_EMPTY, cap);
-    sh->size = 0;
-    sh->growth_left = cap * MAX_LOAD_NUM / MAX_LOAD_DEN;
-    sh->tombstone_count = 0;
+static void swiss_rebuild(SwissHash *sh, size_t new_num_groups) {
+    RebuildCtx ctx;
+    memset(&ctx, 0, sizeof(ctx));
+    ctx.sh = sh;
+    ctx.old_ctrl = sh->ctrl;
+    ctx.old_slots = sh->slots;
+    ctx.old_cap = sh->capacity;
+    ctx.new_num_groups = new_num_groups;
+    ctx.new_cap = new_num_groups * GROUP_SIZE;
 
-    for (size_t i = 0; i < cap; i++) {
-        uint8_t c = old_ctrl[i];
-        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
-            uint64_t hash = compute_hash(old_slots[i].key);
-            swiss_insert_rehash(sh, hash, old_slots[i].key, old_slots[i].value);
-        }
+    if (!swiss_alloc_block(ctx.new_cap, &ctx.new_ctrl, &ctx.new_slots)) {
+        rb_raise(rb_eNoMemError, "failed to rebuild SwissHash");
     }
+    memset(ctx.new_ctrl, CTRL_EMPTY, ctx.new_cap);
+    rb_ensure(swiss_rebuild_body, (VALUE)&ctx, swiss_rebuild_ensure, (VALUE)&ctx);
+}
 
-    free(old_ctrl);
-    free(old_slots);
+SH_ALWAYS_INLINE void swiss_place_new(SwissHash *sh, size_t insert_idx, uint8_t h2, VALUE key, VALUE value) {
+    if (sh->ctrl[insert_idx] == CTRL_EMPTY) {
+        sh->growth_left--;
+    } else {
+        sh->tombstone_count--;
+    }
+    sh->ctrl[insert_idx] = h2;
+    sh->slots[insert_idx].key = key;
+    sh->slots[insert_idx].value = value;
+    sh->size++;
 }
 
-static VALUE swiss_insert(SwissHash *sh, VALUE key, VALUE value) {
+static VALUE swiss_insert_hashed(SwissHash *sh, VALUE key, VALUE value, uint64_t hash, int identity_only, int may_callback) {
     if (sh->growth_left == 0) {
         if (should_compact(sh)) {
             swiss_compact(sh);
@@ -516,32 +756,33 @@ static VALUE swiss_insert(SwissHash *sh, VALUE key, VALUE value) {
         }
     }
 
-    uint64_t hash = compute_hash(key);
     uint8_t h2 = H2(hash);
     ProbeSeq ps = probe_start(H1(hash), sh->group_mask);
-
     size_t insert_idx = (size_t)-1;
 
     for (;;) {
         size_t off = GROUP_OFF(ps.group_idx);
-
-#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);
+        ctrl_mask_t match, empty, avail;
+#ifdef SWISS_USE_VEC
+        {
+            ctrl_vec_t cv = ctrl_load(sh->ctrl + off);
+            SH_PREFETCH(&sh->slots[off]);
+            match = ctrl_match_h2_vec(cv, h2);
+            empty = ctrl_match_empty_vec(cv);
+            avail = (sh->tombstone_count == 0) ? empty : ctrl_match_empty_or_deleted_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);
-        uint32_t avail = ctrl_match_empty_or_deleted_raw(sh->ctrl + off);
+        SH_SCAN_GROUP_INSERT(sh, off, h2, match, empty, avail);
+        if (sh->tombstone_count == 0) {
+            avail = empty;
+        }
 #endif
+
         while (match) {
-            int slot = ctz32(match);
+            int slot = CTRL_MASK_SLOT(match);
             size_t idx = off + slot;
             Slot *s = &sh->slots[idx];
-            if (RB_LIKELY(s->key == key) || keys_equal(s->key, key)) {
+            if (RB_LIKELY(s->key == key) || (!identity_only && keys_equal(s->key, key))) {
                 s->value = value;
                 return value;
             }
@@ -549,7 +790,7 @@ static VALUE swiss_insert(SwissHash *sh, VALUE key, VALUE value) {
         }
 
         if (insert_idx == (size_t)-1 && avail) {
-            insert_idx = off + ctz32(avail);
+            insert_idx = off + (size_t)CTRL_MASK_SLOT(avail);
         }
 
         if (empty)
@@ -557,108 +798,172 @@ static VALUE swiss_insert(SwissHash *sh, VALUE key, VALUE value) {
         probe_next(&ps);
     }
 
-    MUTATE_GUARD_BEGIN(sh);
+    swiss_place_new(sh, insert_idx, h2, key, value);
+    return value;
+}
 
-    if (sh->ctrl[insert_idx] == CTRL_EMPTY) {
-        sh->growth_left--;
-    } else {
-        sh->tombstone_count--;
+SH_ALWAYS_INLINE VALUE swiss_insert_fixnum(SwissHash *sh, VALUE key, VALUE value) {
+    if (RB_UNLIKELY(sh->growth_left == 0)) {
+        if (should_compact(sh)) {
+            swiss_compact(sh);
+        } else {
+            swiss_grow(sh);
+        }
     }
-    sh->ctrl[insert_idx] = h2;
-    sh->slots[insert_idx].key = key;
-    sh->slots[insert_idx].value = value;
-    sh->size++;
 
-    MUTATE_GUARD_END(sh);
+    uint64_t hash = hash_fixnum(key);
+    uint8_t h2 = H2(hash);
+    ProbeSeq ps = probe_start(H1(hash), sh->group_mask);
+    size_t insert_idx = (size_t)-1;
+
+    for (;;) {
+        size_t off = GROUP_OFF(ps.group_idx);
+        ctrl_mask_t match, empty, avail;
+#ifdef SWISS_USE_VEC
+        ctrl_vec_t cv = ctrl_load(sh->ctrl + off);
+        SH_PREFETCH(&sh->slots[off]);
+        match = ctrl_match_h2_vec(cv, h2);
+        empty = ctrl_match_empty_vec(cv);
+        avail = (sh->tombstone_count == 0) ? empty : ctrl_match_empty_or_deleted_vec(cv);
+#else
+        SH_SCAN_GROUP_INSERT(sh, off, h2, match, empty, avail);
+        if (sh->tombstone_count == 0) {
+            avail = empty;
+        }
+#endif
+        while (match) {
+            int slot = CTRL_MASK_SLOT(match);
+            if (RB_LIKELY(sh->slots[off + slot].key == key)) {
+                sh->slots[off + slot].value = value;
+                return value;
+            }
+            match &= match - 1;
+        }
+
+        if (insert_idx == (size_t)-1 && avail) {
+            insert_idx = off + (size_t)CTRL_MASK_SLOT(avail);
+        }
+        if (RB_LIKELY(empty))
+            break;
+        probe_next(&ps);
+    }
+
+    swiss_place_new(sh, insert_idx, h2, key, value);
     return value;
 }
 
-static VALUE swiss_delete(SwissHash *sh, VALUE key) {
+static VALUE swiss_insert_unlocked(VALUE arg) {
+    CallbackCtx *c = (CallbackCtx *)arg;
+    if (FIXNUM_P(c->key)) {
+        c->result = swiss_insert_fixnum(c->sh, c->key, c->value);
+    } else if (SYMBOL_P(c->key)) {
+        c->result = swiss_insert_hashed(c->sh, c->key, c->value, hash_immediate(c->key), 1, 0);
+    } else if (RB_TYPE_P(c->key, T_STRING)) {
+        c->result = swiss_insert_hashed(c->sh, c->key, c->value, hash_string(c->key), 0, 0);
+    } else {
+        c->result = swiss_insert_hashed(c->sh, c->key, c->value, compute_hash(c->key), 0, 0);
+    }
+    return c->result;
+}
+
+static VALUE swiss_insert(SwissHash *sh, VALUE key, VALUE value) {
+    if (sh->mutating) {
+        rb_raise(rb_eRuntimeError, "SwissHash: reentrant modification detected "
+                                   "(#hash or #eql? callback modified the same table)");
+    }
+
+    CallbackCtx ctx = {sh, key, value, Qnil, NULL};
+    if (!key_may_callback(key) && sh->growth_left != 0) {
+        return swiss_insert_unlocked((VALUE)&ctx);
+    }
+
+    swiss_lock(sh);
+    rb_ensure(swiss_insert_unlocked, (VALUE)&ctx, swiss_unlock_ensure, (VALUE)sh);
+    return ctx.result;
+}
+
+static VALUE swiss_delete_unlocked(VALUE arg) {
+    CallbackCtx *c = (CallbackCtx *)arg;
+    SwissHash *sh = c->sh;
+    VALUE key = c->key;
     uint64_t hash = compute_hash(key);
+    int identity_only = FIXNUM_P(key) || SYMBOL_P(key);
     uint8_t h2 = H2(hash);
     ProbeSeq ps = probe_start(H1(hash), sh->group_mask);
 
     for (;;) {
         size_t off = GROUP_OFF(ps.group_idx);
+        ctrl_mask_t match, empty;
+        SH_SCAN_GROUP(sh, off, h2, match, empty);
 
-#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);
-#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
         while (match) {
-            int slot = ctz32(match);
+            int slot = CTRL_MASK_SLOT(match);
             size_t idx = off + slot;
             Slot *s = &sh->slots[idx];
-            if (RB_LIKELY(s->key == key) || keys_equal(s->key, key)) {
+            if (RB_LIKELY(s->key == key) || (!identity_only && keys_equal(s->key, key))) {
                 VALUE old_value = s->value;
-
-                MUTATE_GUARD_BEGIN(sh);
                 sh->ctrl[idx] = CTRL_DELETED;
                 sh->slots[idx].key = Qnil;
                 sh->slots[idx].value = Qnil;
                 sh->size--;
                 sh->tombstone_count++;
-                MUTATE_GUARD_END(sh);
-
+                c->result = old_value;
                 return old_value;
             }
             match &= match - 1;
         }
 
-        if (empty)
+        if (empty) {
+            c->result = Qnil;
             return Qnil;
+        }
         probe_next(&ps);
     }
 }
 
-static void swiss_grow(SwissHash *sh) {
-    size_t old_cap = sh->capacity;
-    size_t old_size = sh->size;
-
-    uint8_t *old_ctrl = sh->ctrl;
-    Slot *old_slots = sh->slots;
-
-    size_t new_num_groups = sh->num_groups * 2;
-    size_t new_cap = new_num_groups * GROUP_SIZE;
-
-    sh->ctrl = (uint8_t *)malloc(new_cap);
-    sh->slots = (Slot *)malloc(new_cap * sizeof(Slot));
+static VALUE swiss_delete(SwissHash *sh, VALUE key) {
+    if (sh->mutating) {
+        rb_raise(rb_eRuntimeError, "SwissHash: reentrant modification detected "
+                                   "(#hash or #eql? callback modified the same table)");
+    }
 
-    if (!sh->ctrl || !sh->slots) {
-        free(sh->ctrl);
-        free(sh->slots);
-        sh->ctrl = old_ctrl;
-        sh->slots = old_slots;
-        sh->size = old_size;
-        sh->growth_left = 0;
-        rb_raise(rb_eNoMemError, "failed to grow SwissHash");
+    CallbackCtx ctx = {sh, key, Qnil, Qnil, NULL};
+    if (!key_may_callback(key)) {
+        return swiss_delete_unlocked((VALUE)&ctx);
     }
 
-    memset(sh->ctrl, CTRL_EMPTY, new_cap);
+    swiss_lock(sh);
+    rb_ensure(swiss_delete_unlocked, (VALUE)&ctx, swiss_unlock_ensure, (VALUE)sh);
+    return ctx.result;
+}
 
-    sh->num_groups = new_num_groups;
-    sh->group_mask = new_num_groups - 1;
-    sh->capacity = new_cap;
-    sh->size = 0;
-    sh->growth_left = new_cap * MAX_LOAD_NUM / MAX_LOAD_DEN;
-    sh->tombstone_count = 0;
+typedef struct {
+    SwissHash *sh;
+    size_t new_num_groups;
+} RebuildCall;
 
-    for (size_t i = 0; i < old_cap; i++) {
-        uint8_t c = old_ctrl[i];
-        if (c != CTRL_EMPTY && c != CTRL_DELETED) {
-            uint64_t hash = compute_hash(old_slots[i].key);
-            swiss_insert_rehash(sh, hash, old_slots[i].key, old_slots[i].value);
-        }
+static VALUE swiss_rebuild_call(VALUE arg) {
+    RebuildCall *c = (RebuildCall *)arg;
+    swiss_rebuild(c->sh, c->new_num_groups);
+    return Qnil;
+}
+
+static void swiss_rebuild_locked(SwissHash *sh, size_t new_num_groups) {
+    RebuildCall call = {sh, new_num_groups};
+    if (sh->mutating) {
+        swiss_rebuild(sh, new_num_groups);
+        return;
     }
+    swiss_lock(sh);
+    rb_ensure(swiss_rebuild_call, (VALUE)&call, swiss_unlock_ensure, (VALUE)sh);
+}
 
-    free(old_ctrl);
-    free(old_slots);
+static void swiss_grow(SwissHash *sh) {
+    swiss_rebuild_locked(sh, sh->num_groups * 2);
+}
+
+static void swiss_compact(SwissHash *sh) {
+    swiss_rebuild_locked(sh, sh->num_groups);
 }
 
 static void swiss_hash_mark(void *ptr) {
@@ -712,6 +1017,10 @@ static VALUE swiss_hash_initialize(int argc, VALUE *argv, VALUE self) {
     SwissHash *sh;
     TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
 
+    if (sh->mutating) {
+        rb_raise(rb_eRuntimeError, "SwissHash: reentrant modification detected");
+    }
+
     size_t capacity = NIL_P(capacity_val) ? 16 : NUM2SIZET(capacity_val);
     swiss_init(sh, capacity);
 
@@ -728,10 +1037,6 @@ static VALUE swiss_hash_initialize_copy(VALUE self, VALUE original) {
     TypedData_Get_Struct(original, SwissHash, &swiss_hash_type, src);
     TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, dst);
 
-    if (dst->ctrl || dst->slots) {
-        swiss_free_arrays(dst);
-    }
-
     if (!src->ctrl || !src->slots) {
         swiss_init(dst, 16);
         return self;
@@ -750,7 +1055,14 @@ static VALUE swiss_hash_initialize_copy(VALUE self, VALUE original) {
 
 static VALUE swiss_hash_aset(VALUE self, VALUE key, VALUE value) {
     SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
-    if (RB_UNLIKELY(!(FIXNUM_P(key) || SYMBOL_P(key)))) {
+    if (RB_UNLIKELY(sh->mutating)) {
+        rb_raise(rb_eRuntimeError, "SwissHash: reentrant modification detected "
+                                   "(#hash or #eql? callback modified the same table)");
+    }
+    if (FIXNUM_P(key)) {
+        return swiss_insert_fixnum(sh, key, value);
+    }
+    if (RB_UNLIKELY(!SYMBOL_P(key))) {
         key = prepare_key(key);
     }
     return swiss_insert(sh, key, value);
@@ -758,7 +1070,12 @@ static VALUE swiss_hash_aset(VALUE self, VALUE key, VALUE value) {
 
 static VALUE swiss_hash_aref(VALUE self, VALUE key) {
     SwissHash *sh = (SwissHash *)RTYPEDDATA_DATA(self);
-    VALUE *val = swiss_lookup(sh, key);
+    VALUE *val;
+    if (FIXNUM_P(key)) {
+        val = swiss_lookup_hashed(sh, key, hash_fixnum(key), 1);
+    } else {
+        val = swiss_lookup(sh, key);
+    }
     return val ? *val : Qnil;
 }
 
@@ -783,6 +1100,11 @@ static VALUE swiss_hash_clear(VALUE self) {
     SwissHash *sh;
     TypedData_Get_Struct(self, SwissHash, &swiss_hash_type, sh);
 
+    if (RB_UNLIKELY(sh->mutating)) {
+        rb_raise(rb_eRuntimeError, "SwissHash: reentrant modification detected "
+                                   "(#hash or #eql? callback modified the same table)");
+    }
+
     memset(sh->ctrl, CTRL_EMPTY, sh->capacity);
     memset(sh->slots, 0, sh->capacity * sizeof(Slot));
     sh->size = 0;
@@ -1057,8 +1379,16 @@ static VALUE swiss_hash_merge(int argc, VALUE *argv, VALUE self) {
 }
 
 static VALUE swiss_hash_replace(VALUE self, VALUE other) {
+    if (self == other) {
+        return self;
+    }
+
+    VALUE converted = rb_check_hash_type(other);
+    if (NIL_P(converted) && !RTEST(rb_obj_is_kind_of(other, cSwissHashHash))) {
+        rb_raise(rb_eTypeError, "no implicit conversion of %s into Hash", rb_obj_classname(other));
+    }
     swiss_hash_clear(self);
-    VALUE argv[1] = {other};
+    VALUE argv[1] = {NIL_P(converted) ? other : converted};
     swiss_hash_merge_bang(1, argv, self);
     return self;
 }
@@ -1401,6 +1731,8 @@ static VALUE swiss_hash_stats(VALUE self) {
 
 #ifdef SWISS_USE_SSE2
     rb_hash_aset(hash, ID2SYM(rb_intern("simd")), rb_str_new_cstr("SSE2"));
+#elif defined(SWISS_USE_NEON)
+    rb_hash_aset(hash, ID2SYM(rb_intern("simd")), rb_str_new_cstr("NEON"));
 #else
     rb_hash_aset(hash, ID2SYM(rb_intern("simd")), rb_str_new_cstr("SWAR"));
 #endif

data/lib/swiss_hash/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swiss_hash
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Roman Haidarov